wemakethings

dmx-dimmer 19-inch rack mount case

2013-05-18T00:00:00+03:00

I first thought of buying a pre-made 19-inch rack mount case, 3U high, 19 inches deep, but those were unavailable locally, and shipping such a large item would cost a fortune. Even if one was available, I’d still have to cut out holes for screws and air vents, which would take too much time.

Instead, pwf suggested I order a custom-made one, cut out with a water jet and folded at a shop that specialises in doing just that.

The shop needed an AutoCAD .dawg file for their machines. I don’t have AutoCAD, so used FreeCAD instead. It went better than last time, especially since this time I used its sketch feature and constraints a-la SolidWorks.

But it doesn’t export directly to .dwg, only .dxf. Draftsight can handle both, though, so I exported to .dxf in FreeCAD, imported that in Draftsight, moved things around to coloured layers, exported to .dwg and sent the file to the shop. A little convoluted, sure. The files are available here.

The shop didn’t quite do it by-the drawing, since I didn’t include a 3D view of what I was expecting. (DraftSight is essentially AutoCAD for 2D, at least the free version.) Also, I made some poor design choices in my drawing, so there was more work to do on the case than initially anticipated.

First, I didn’t specify the bending radii, and didn’t account for the thickness (1 mm) of the sheet metal in the cutout. Then, I went for the bottom-and-four-sides being one piece, instead of bottom-and-two-sides, so the shop couldn’t fold the box perfectly. I had to align it up before welding two adjacent sides.

Also note that had I gone the bottom-and-two-sides + top-and-two-sides route, no welding would have been necessary. Maybe I’ll fix that in some future revision of the drawing, if I ever need a 19” rack again.

Sheet metal doesn’t dissipate heat so well. To prevent warpage, I clamped in a brass “heatsink” on the backside:

Clamps are good arm rests, too:

I also didn’t include two mounting brackets for the DIN rail holding the circuit breakers, so had to hammer those out and plug-weld them from the front side of the case:

Then, I forgot to include screw holes for the top, so had to drill and tap those. Here’s how it looks:

Bent a few pieces of 6 mm rod, tapped their ends, cut out a front plate from 2 mm sheet metal, drilled two pairs of holes on either side and welded the rods in as handles. Also drilled a two pairs of holes for the rack mounting screws, and cut out rectangular pieces for the front panel stuff:

Cleaned the case, covered in primer, painted black. Got no photos of that.

Mounted the electonics inside. The bottom looks screwed:

Those rectangular holes are for air flow, they’re right beneath the triacs’ heatsinks.

The wires were a mess, tidied them up with zip-ties, attached to these neat little adhesive zip-tie holders:

The original Sherlock Holmes Pipe is included for size comparison.

That’s almost it! Once I get to run a final power test, with the top lid screwed in place, I’ll do a final rant, promise to update the schematics, PCB layout and case drawing, conveniently forget all of that, and move on to other extremely time-consuming stuff.

dmx-dimmer power tests

2013-04-13T00:00:00+03:00

Last time I mentioned the chokes were buzzing too much, so I’d have to dip them in epoxy. Doing that helped somewhat with the noise, and I expect it to be a non-issue once they’re in a closed case.

It took me a few days or so to wire it all up – stripping wires, checking the power cable, yada-yada.

I couldn’t run it at full-power just yet. Software was being non-cooperative. Previously, I’ve tested the system with the master and just one slave. Now, with three slaves connected, there were conflicts. One of them was all the slaves using the same physical OK line. (After the master sends an interrupt, the slave uses that to signal it’s ready to receive data.) How silly of me. Luckily, there were still some unused pins on the master board, so I didn’t have to invent a yet another multiplexer, and just use separate OK lines. It’s all in the code now, and the schematic, too, but I haven’t propagated it to the PCB (as of this writing).

That didn’t fix another problem: the master locking up, as if all slaves were receiving an interrupt, even though separate lines have always been used for that. After a few days of bewilderment, I decided to do the one thing which is known to solve issues almost universally. Namely, get drunk.

The hangover helped me in looking over the design calmly and realising that, although the interrupt lines are separate, the Master-In-Slave-Out is connected to all three slaves, and they are not in Hi-Z state by default. There is no reason for the master to receive data from slaves, really, other than verifying the slave is functional. But rather than disconnecting the MISO line, I fixed it in software.

After that, I was finally able to run the full-power tests. The heatsink goes to 50 °C in half an hour, and stays that way, with 8 kW (4 channels set at 100%). Triacs’ package was 5-10 °C above that. So with heatsinks as big as these, I might not even need a fan in the case, alhough that is yet to be proven.

Still there were 3 more things to do with software:

DMX address selection – turned out two address lines got accidentally swapped; fixed in software, not fixed in hardware;
setting preheat an maximum value – involved mucking with ADC multiplexing, and I eventually convinced myself this is not needed at all, and should be handled by the lighting console anyway; the UNIX philosophy works in hardware, too: do one thing and do it well (well, try at least);
setting a light curve – chopping a sinusoid’s half-period in 256 equal parts means the lower and upper percentage changes give a small delta in output power, whereas the middle is rather sensitive.

The last one is rather important, and I thought it could be solved by chopping the half-period in non-equal parts. That didn’t work: either the timer interrupt routine wasn’t fast enough, or you can’t really change a timer’s TOP value while the timer is running in CTC mode. Turning the timer off, changing the TOP and then turning it back on helped, but it introduced an unacceptable lag. Modifying the timer value to accomodate the lag sounds like too much guesswork. Bored with the project by now, I decided not to implement this feature.

Here’s a dirty Python script I used to generate the timer’s values. Note that a 16 bit timer is required with these if no prescaling is used.

#!/usr/bin/env python

import math

a = 0
b = 0
# tmp = 0
step = 2.0/256
durzc = []   # duration (total time) passed from zero crossing
delays = []  # duration between two durzc values
cycles = 6000000.0/(2*50)  # cycles between two zero crossings

for n in range(0,255):
    b = math.acos(math.cos(a) - step)
    # print(n, a, b)  # debug
    durzc.append((b/math.pi) * cycles)
    a = b

durzc.append(1.0 * cycles)
# print(durzc)  # debug

delays.append(durzc[0])
for n in range(1,256):
    delays.append(durzc[n] - durzc[n-1])
delays = [round(x) for x in delays]
print(delays)

# for n in range(0,256):
#     tmp += delays[n]
# print(tmp)  # debug

Its output, slightly formatted:

[2389, 992, 762, 644, 569, 515, 475, 443,
417, 395, 376, 360, 346, 334, 323, 313,
304, 296, 288, 281, 275, 269, 264, 258,
254, 249, 245, 241, 237, 234, 230, 227,
224, 221, 218, 216, 213, 211, 209, 207,
204, 202, 201, 199, 197, 195, 194, 192,
190, 189, 187, 186, 185, 183, 182, 181,
180, 179, 178, 177, 176, 175, 174, 173,
172, 171, 170, 169, 169, 168, 167, 166,
166, 165, 164, 164, 163, 162, 162, 161,
161, 160, 160, 159, 159, 158, 158, 157,
157, 156, 156, 156, 155, 155, 155, 154,
154, 154, 153, 153, 153, 153, 152, 152,
152, 152, 151, 151, 151, 151, 151, 150,
150, 150, 150, 150, 150, 150, 150, 150,
149, 149, 149, 149, 149, 149, 149, 149,
149, 149, 149, 149, 149, 149, 149, 149,
150, 150, 150, 150, 150, 150, 150, 150,
150, 151, 151, 151, 151, 151, 152, 152,
152, 152, 153, 153, 153, 153, 154, 154,
154, 155, 155, 155, 156, 156, 156, 157,
157, 158, 158, 159, 159, 160, 160, 161,
161, 162, 162, 163, 164, 164, 165, 166,
166, 167, 168, 169, 169, 170, 171, 172,
173, 174, 175, 176, 177, 178, 179, 180,
181, 182, 183, 185, 186, 187, 189, 190,
192, 194, 195, 197, 199, 201, 202, 204,
207, 209, 211, 213, 216, 218, 221, 224,
227, 230, 234, 237, 241, 245, 249, 254,
258, 264, 269, 275, 281, 288, 296, 304,
313, 323, 334, 346, 360, 376, 395, 417,
443, 475, 515, 569, 644, 762, 992, 2389]

And, finally, the whole thing, all wired and waiting for a case:

Welding a Palm Sunday bouquet

2013-03-09T00:00:00+02:00

A ‘Palm Sunday bouquet’, an ‘Easter palm’, ‘verba’ or ‘Palma wielkanocna’ is a Lithuanian/Polish contraption used by local Catholics for Easter rituals. Since no palm trees grow here, people started making their own out of willow and juniper branches, dried herbs and flowers and other stuff. They are, as a rule, ugly dust collectors (the bouquets).

Several years ago I thought about welding them from junk and putting them up for sale during a spring fair, simply for fun. Now, I couldn’t weld two things together without melting half of the planet, but pwf can and so he made an Easter palm out of old cutlery we had around. Just for the sake of implementing the idea.

He washed away the old fat and dust, then cut off the plastic handles and welded spoons/knifes/forks together with a TIG welder. There was also a selling story about Lithuanian bridal customs and killing wild elks with a verba, but it was lost during a period of inebriation that followed.

Winding chokes for the dmx-dimmer

2013-03-03T00:00:00+02:00

It’s that time of the year again, and I’ve been working these past few weeks on the dmx-dimmer project: putting it together on a piece of cardboard a-la science fair, re-designing the power dimmer module, and running power tests.

Last visit I mentioned winding my own chokes (inductors). These will be used for rush current suppression in the power line, so they need not be precise and uniform.

We salvage ferrites among other things, and there was enough wire laying around. If I had to buy either of these, doin’ it myself would’ve been more expensive that buying pre-made ones – provided, of course, the local shop carries them at all.

Anyway, I started out by smoothing the straight edges on my ferrites, otherwise laquer on the wires would’ve gotten damaged during bending, which means spark gaps. Used a small round file for the first one, but it took too long, so switched to a hand-held rotary tool with a sanding stone drillbit. On the image below, the smoothed toroid is on the right.

Then I cut two pieces of 1 mm copper wire, both 90 cm long (determined by trial). I removed laquer on their ends using sand paper, since none of the solvents we had on hand worked. ioch speculated it could be done in boiling base, but we haven’t tried that.

I clamp the ferrite in a vise with some padding, put a pair of straigtened wires through the hole and, well, start winding. This requires both hands to constantly press the wire to the ferrite, keep gaps as small as possible, prevent wire arcing and bending, get equal spacing and many other things that take many other words to describe.

If you intend doing something like this, I suggest practice first. There’s nothing about chokes but getting the hang of it.

After one half is done, turn it around in the vise. Ideally, it should be perfectly symmetric when finished. In practice, one of my first chokes looked something like this:

Not too bad, really.

Before I solder them into the boards, I decided to check if any laquer got damaged after all, and see if they burn. So I cut them into the phase line of the mains, one at a time:

On the other end sits a 2 kW load of light fixtures. The chokes heat up to 40 °C. The blown socket in the picture above is from an unrelated experiment.

I’ve also tested one with the new dimmer module, and it works, but noisily (as in sound). Which means I’ll be dipping them into epoxy.

In the image above, from bottom to top: three populated slave boards; a dozen chokes; and one 4-channel dimmer board, missing a few caps, a few headers, and the inductors, of course.

As always, all design files are available on GitHub.

How does an ADC work?

2013-02-25T00:00:00+02:00

This is a little experiment on how does a SAR ADC work.

A register, a DAC, a comparator and some control logic make an ADC. To perform a conversion, a binary search is performed. Bits in the register are turned on consecutevely from most significant bit to least significant one. If the voltage at the DAC output is higher than the voltage ADC is digitizing, the bit is turned off, if it’s lower, the bit is left on.

What I don’t mention in the video is how accuracy of resistors is important and how different kinds of errors creep in, but it’s a very broad topic on itself. Suffice to say that resistors should be as accurate as possible to get a linear response with low offset and gain errors.

One more thing to mention is that usually there is a so called “sample and hold” capacitor at the “unknown voltage” input of ADC where the voltage is sampled before the conversion so that rapidly changing input does not affect the reading.

This is schematic and Arduino code if someone wants to try it themselves.

#define COMPARATOR 8
#define BUTTON 9

/* button states */
#define PRESSED 1
#define MAYBE_PRESSED 2
#define RELEASED 3
#define MAYBE_RELEASED 4
byte buttonState = RELEASED;
byte lastButtonState = RELEASED;

/* the mask bit we are shifting each step */
byte mask = 0b10000000;

void setup() {
  DDRD = 0xFF; //port D set to output (digital outputs 0 to 7)
  PORTD = 0;   //all bits off
  pinMode(COMPARATOR, INPUT);
  pinMode(BUTTON, INPUT);
  digitalWrite(BUTTON, HIGH); //turn a puu up for a button on
}

void loop() {
  PORTD |= mask; //turn on one bit
  while(!buttonPress()){ //wait for the button press for demo purposes
    //NOTHING
  }
  if(LOW == digitalRead(COMPARATOR)) {
    PORTD &= ~mask; //if comparator turns on, turn off the bit
  }
  mask = mask >> 1; //shift for next bit
  
  if(0 == mask) {
    while(!buttonPress()){
      //NOTHING
    }
    mask = 0b10000000;
    PORTD = 0;
    while(!buttonPress()){
      //NOTHING
    }
  }
}

/* button debouncing routine */
boolean buttonPress() {
  byte button = digitalRead(BUTTON);
  switch(buttonState) {
    case MAYBE_PRESSED:
      delay(0);
      if(LOW == button) {
        buttonState = PRESSED;
      } else {
        buttonState = RELEASED;
      }
      break;
    case PRESSED:
      if(HIGH == button) {
        buttonState = MAYBE_RELEASED;
      }
      break;
    case MAYBE_RELEASED:
      delay(0);
      if(HIGH == button) {
        buttonState = RELEASED;
      } else {
        buttonState = PRESSED;
      }
      break;
    case RELEASED:
      if(LOW == button) {
        buttonState = MAYBE_PRESSED;
      }
      break;
  }
  boolean ret = lastButtonState != buttonState && PRESSED == buttonState;
  lastButtonState = buttonState;

  return ret;
}

Near Earth objects impact probabilities

2013-02-22T00:00:00+02:00

Collisions with rocks from space are hot news these days. rxdtxd posted the link to ESA Near Earth Objects risk table, I started playing with it since it was a new shiny distraction, and because we are quite oblivious to what the raw data has to say.

Humans are rather incapable at internalising numbers – we did not evolve to manage risks rationally. We skim over tables with horrifying observations (say, ocean acidification) and shrug, but duck and run from a tiger-shaped bush, because it suddenly seems so urgent and personal.

These are logarithms of impact probabilities over the next 100 years or so, based on ESA data. Sizes of dots are proportional to volumes of meteorites (assuming they are spherical): the largest one corresponds to 2010AU118, a 1200 m diameter rock that’s supposed to fly nearby sometime in 2015. The smallest object in the sample is 2 meters across.

NASA also maintains its impact risk table, without any machine-friendly download options, however. rxdtxd, being a very technical boy, used a tangle of regexps to parse it (I’d have gone with the Beautiful Soup, as I’m lazy). Some of the objects in these tables match.

The NASA table is curious: they do not provide possible impact dates, only intervals when an object might be of any danger. And they probably calculate impact probabilities in a different way than ESA. I used the middle year of those intervals as a possible impact date in the following plot, which throws the NASA and ESA data together.

A possibility of an impact tells us pretty nothing: the consequences depend on the atmospheric entry angle, composition and velocity of the object, impact location (water or rock), etc. (I didn’t know before that asteroids can graze Earth’s atmosphere and fly away). I couldn’t find the exact energy yield equations during a quick browse-around, but here are a few more or less serious calculators and an article by E. Oepik from 1958. He was an Estonian astronomer way ahead of his time. We are actually quoting his letter on galaxy inclinations from 1923 in one of our scholarly papers!

Both NASA and ESA datasets offer two scales to evaluate the actual threats raised by near-Earth objects, that is, the Torino and Palermo scales, both combining impact probabilities and yields (kinetic energies). The former, I think, is for the mainstream media mainly – it gives a convenient, quite subjective indication of level of concern warranted. Currently there is 1 known object with a non-zero Torino scale rating.

The Palermo scale is rather complex, but more objective: it denotes relative risks with respect to background. Go read more about it here.

The ESA and NASA Palermo ratings do not match, though they correlate: they must be calculating the impact probabilities differently, and NASA does not provide timing for separate impact events.

If one sums up the impact probabilities, she gets 0.101-0.09 for ESA and NASA respectively. These are probabilities that we will be hit by an object we already know about. However, here’s the cumulative probability chart for ESA data:

The gaps denote years that have no impact probability data, nevermind them. As you can see, the majority of that 0.101 probability is due to 2010RF12, which is a 9 m diameter rock (Chelyabinsk meteorite is assumed to be twice larger, although it entered at a very low angle). Which is to say, we’ll probably will be hit by a similar-sized meteorite before RF12’s presumed impact date (well, we were hit last week without any warning!).

The following is rather speculative.

I noticed that there is an overdensity of impact probabilities around 2080. The saying goes, ‘if you don’t know what to do with your data, do a Fourier transform’. Since FT does not work well on unevenly-spaced data, I used Lomb-Scargle analysis instead. Spectral analysis, such as L-S or Fourier analysis, is used in order to find any periodicities in time-series data, that is, finding dominant subcomponents of a signal, if there are any.

There might be a periodicity of ~37 years in the impact probabilities data, or it might be an artifact of rather short (~100 years) time interval available. It can be spurious, or maybe there is some orbital resonance with a group of NEOs.

One reason for the higher number of probable impact events at the end of this century might be the fact that impact probabilities are initially given larger values, and then revised downwards. As we learn of a flyby of a space rock, we know about its orbit with some certainty, and some close encounters alter the orbit of the asteroid enough to warrant attention later. (If you’re interested in what ‘a keyhole’ is, start here.) So far, chances that a known small asteroid will come back are smaller than chances of being hit by an unknown rock.

All code we used is here. I probably won’t be bothered to make it tidy.

Now the disclaimer: my research area is the galaxies and quasars. I know squat about the Solar System, except that Pluto is not a planet anymore. Don’t panic, but don’t throw away your Kalashnikov and the cans of condensed milk yet.

Stepper motors as rotary encoders

2013-02-18T00:00:00+02:00

I’ve spent some time playing around the idea of using stepper or brushless motors as rotary encoders.

Stepper acts as a high impedance AC voltage source outputing sinusoidal waveform, it’s just a matter of apmlifying and converting this signal to a square wave:

R1 and R2 set up a reference voltage, R3 and C2 low-pass filter the signal from a motor - when this signal goes above the reference voltage, comparator changes it’s output producing a nice square wave.

The same effect can be obtained using a high gain noninverting op amp circuit, but as opamps are not really ment to be operated in saturation regions, I’ve decided to go with a comparator.

You have to do this to two phases of a stepper motor - one phase will lag the other - this way you can determine a direction of rotation.

Here is a piece of arduinized avr code that reads the encoder and drives a single digit 7 segment display:

void setup() {
  DDRD = 0xFF;//setup port D as ouput for 7-seg display
  pinMode(8, INPUT);//motor phase 1 on PORTC 0
  pinMode(9, INPUT);//motor phase 2 on PORTC 1
}


byte digits[] = {
  0b00000011,//0
  0b11110011,//1
  0b10000101,//2
  0b00001101,//3
  0b00111001,//4
  0b01001001,//5
  0b01000001,//6
  0b00011111,//7
  0b00000001,//8
  0b00001001,//9
};

byte t = 0; //step counter
byte lastVal = 0; //last value of motor phase inputs
byte b = 1; //segment which is displayed
byte digit = 0; //digit that is displayed

void loop() {
  //flash one segment every loop
  PORTD = digits[digit] | ~(0x01 << b);
  b++;
  if(b > 7) {
    b = 1;
  }

  //read status of motor pins  
  byte val = PINB & 0x03;

  if(val != lastVal) {
    if((val == 3 && lastVal == 2) ) {
      //t is just a step counter, we change the digit every 3 steps
      t++;
      if(4 == t) {
        t = 0;
        digit++;
        if(10 == digit) {
          digit = 0;
        }
      }
    } else if ((val == 2 && lastVal == 3) ) {
        if(0 == t) {
          t = 4;
          if(0 == digit) {
            digit = 10;
          }
          digit --;
        }
        t--;
    }
    lastVal = val;
  }
}

Auto-off bike light

2013-02-03T00:00:00+02:00

I wanted to make an auto-off bike light because I just keep forgetting to switch it off and the batteries are constantly flat. And I hate dynamos.

I was looking into accelerometers, but couldn’t find one that would enter sleep mode and give me interrupts with zero configuration. This implies using microcontroller and it gets boring pretty fast. So I decided to choose the low-tech way. All I needed was a switch that would close when disturbed mechanically. After digging in various junk bins I found a spring and came up with this solution:

The schematics are simple:

The resistor keeps the mosfet off. When the switch is closed briefly, capacitor instantly charges up above the mosfet’s gate threshold voltage, the mosfet turns on the LED. Then the capacitor discharges slowly through the resistor until its voltage drops below the gate threshold voltage, causing the mosfet to turn off. So if my spring switch closes rapidly while I ride (say, at least once in a minute), the light stays on. If I stop for more than a minute, the light goes off. I chose a 10 megaohm resistor and a 22uF capacitor, in theory this should give about 30 seconds until the threshold voltage is reached.

This is the switch with the circuit soldered:

A copper clad board, a knife and smd components…

Open source Lithium battery charger modules

2013-02-02T00:00:00+02:00

For a long time I wanted to enter the 21st century by stopping using NiCad or NiMH batteries and upgrading to Lithium accumulators as they provide more power per volume and are cool in general. Constant flow of obsolete cell phones provides a nice source of reasonably high-performance batteries for free - I felt compelled to tap into this resource for my battery operated projects.

Well, there are a couple of issues you have to take care of when moving to Li-ion or LiPoly:

you have to charge them in a particular specific way they like
you can’t discharge them below a certain threshold
oh, yeah, did I mention they blow up violently if you screw up?

What’s nice about cell phone batteries is that they usually come with a protection circuitry that protects them when they are overdischarged and short-circuited. Once we tried to blow up a cell phone battery by shorting it, connecting to external power supply in proper polarity, then in reverse polarity, then directly to 240V - the sucker just didn’t blow up! This is just how good protection circuit on cell phone batteries is.

Ok, enough of this retarded shit. I needed a proper way to charge batteries, and I’ve chosen USB from a computer as the primary power source since those are ubiquitous. So, to get the job done I chose to test three (essentially two) popular Li-ion charging ICs: MAX1551, MAX1555 and MCP73831.

There are loads of the charger designs based on these ICs on the net, but I couldn’t find one that would meet my requirements:

made in Eagle
DIY toner transfer friendly
charging/finished indication
jumper/resistor selectable charging current
optional USB connector

So I made my own and am posting them online for people to use: https://github.com/Miceuz/USBLiPoCharger

MAX1551 does not provide feedback about charging status, so there’s no point talking about it. MAX1555 does provide charging status though, so I took some effort to make use of it:

MAX1555 CHG pin is an open drain output that goes low while the battery is charging, stays high impedance otherwise. While the battery is charging, Q1 is off as its gate is pulled low, lucky combination of LEDs and MOSFETs salvaged from some motherboards allows for Q2 to turn on and light up the LED_CHARGING. When the CHG pin goes high impedance, gate of Q1 is pulled up by R2, Q1 turns on while turning on LED_CHARGED and pulling down the gate of Q2.

The MOSFETs I used are of jelly-bean kind with “702” marking on them, the LED_CHARGED has a voltage drop of about 1.6V, this makes a gate voltage of 5V - 1.6V = 3.4V apparently this is enough for 702 to turn on.

I’ve added a solder jumper that can be used to change charging current mode.

MCP73831 has a tri-state STAT output, this makes indication trivial:

Another nice thing about MCP73831 is that it provides a possibility to tune the charging current for the size of your battery - if the battery is small, you don’t want to charge it at very high currents, probably you’d aim for 0.8 x battery capacity to be on the safe side. This can be done by selecting a suitable resistor on PROG pin - consult the datasheet. Note that you can easily violate the USB specification which does not allow for devices to draw currents higher that 100mA without negotiation. But all the USB hosts in computers I’ve met usually don’t care.

I’m not sure about MAX155X, but I can tell from personal experience that MCP73831 does not have any internal protection form reversed battery. It goes poof! with a tiny trace of smoke.

This is a photo of one of my projects - TV-B-Gone packed into a Nokia phone case utilising the original battery:

This is a photo of a raw phone battery cell charging. The battery was old and was outputing no voltage, but after I ripped out the protection circuitry, the cell showed some 2.5V - just on the edge of becoming useless. I was able to charge it without any problems - no heating, etc. I don’t recommend this way of using old batteries, it’s here just to show how retarded I am.

Three classic fixes for SMD PCB mishaps

2013-02-02T00:00:00+02:00

Now, don’t tell me you’ve seen this one!..

After a long hiatus, I wanted to get back to electronics for a while. Finish dmx-dimmer and all. For warm-up, I decided to put together a CatNip kit that miceuz gave me.

A few sloppy minutes later I was de-soldering one side of a TQFP package (ARM chip), which was placed on a bed of SMD paste and slipped a bit. It was all going well, then a trace flaked off the board. Oops.

No biggie, just solder in a thin wire. 0.1 mm will do just fine. It’s commonly available in the form of transformer refuse.

I kept on soldering, listening to psytrance, minding my own business, when suddenly and for no apparent reason a 0603 resistor jumped right at me, and was gone the second after. Bad luck, it was 2 kΩ, and ~~I didn't have any more of those on hand~~ I was too lazy to look for one. I did have several 1 kΩ and a pin handy, so I hooked these up in series.

After having populated most of the board, I noticed one resistor was still missing. 150 Ω, wasn’t in the kit. For demo purpose only, I decided to connect several larger-value resistors in parallel.

What I did here, as you most probably see, is stack five 1 kΩ resistors atop one another. Could have gone with six, but this is just current limiting for a LED, so the same precise value is not strictly required.

Here’s the complete board before I rub it with acetone and glue the frankensteins:

Does it work? Well, it powers up and enumerates as USB storage, so I guess it does. No way to be sure, got no toolchain.

To give some context, here’s a lamp’s-eye view.

That thing with a black/yellow handle? Unregulated 40 W noname, stock tip, China Export certified. The iron I was using. A close-up…

Why in the world?.. For fun mostly, so that I truly can.

A wide-angle, low-pressure shower head

2013-01-30T00:00:00+02:00

We wanted a shower head that doesn’t feel like you’re in the sink under the tap. We ordered one from DealExtreme, but it never arrived, and they didn’t return our calls. We shopped around, but they all cost like a washing machine.

Therefore this. Stainless steel, no filters, no frills. 16 cm wide, 188 1 mm holes. Four common HSS drill bits broke while doing the plate.

Smooth.

Wide shower head demo video, on YouTube.

A moka pot stove from a clothing iron

2013-01-24T00:00:00+02:00

I am a scientist, and I’m powered by coffee. The problem was, the only source of coffee at my venerable institution is a vending machine that spits back some brownish, watery Scheisse-coffee for 0.4 euro. Either that, or drinking coffee the Polish way, what will rot one’s stomach and soul eventually.

One way to build a stove is to go back to the basics and make the heating plate from nichrome wire, similar to what we did with the cat heater. After an evening spent with ioch calculating resistances and cross-sections I decided that handling 80m of wire is too much and went with pwf’s suggestion, that is, using a clothing iron. Such a stove wasn’t a new thing for us – we got the same idea from some Lithuanian students. Adapting a clothing iron makes perfect sense: it uses a kW or so, so it is quite efficient, the surface is non-sticky and it has inbuilt temperature control. Besides, who irons their clothes nowadays anyway?

One gloomy Sunday we went to a Gibsonesque Turkish flea market nearby and bought a spanking new clothing iron, made in GDR, for a few euros. I took it apart immediately – there weren’t much more than the heating plate with the heating element around it (seen here as the circular bulge between the rivets), the bi-metal plate that is probably the most basic temperature controller, a small lightbulb that we kept and the remnants of a temperature control wheel (you know, the silk-wool-cotton-linen sequence). The case is held together with the heating plate by the prominent screw. The plastic parts – the handle and such – were lost immediately so I can’t say anything about them.

Since I have access to a ceramic kiln and several pounds of clay, it seemed a natural choice: clay is heat and water resistant, an insulator, easy to mold and clean. I used grainy (~2mm chamotte fraction) stoneware, as it’s cheap and contracts less than regular fine clay. All flat parts were rolled with an empty bottle, cut by hand and glued together with stoneware slip. This part of the process is hard to describe, so I’ll throw in a couple of pictures instead.

I left it to dry for a few days, fired once at 960C, forgot about it, went to Israel, then glazed it one night and fired again up to 1020C.

The problem with ceramics is that the stoneware shrinks during the drying and firing. Nevertheless, this project was not a precision mechanics endeavour anyway – so we cut and drilled a metal plate and fastened it to the belly of the heating plate so that it looked horizontal and would not fall off.

I had made some nichrome loops inside, so we tied the cord in with some zip ties, checked if the tiny indication light was working and made a test run:

It takes about 2 minutes for this moka pot to boil. ioch and pwf already suggested adding an alarm clock w/ a relay to it, so that one’s coffee is ready after the first ‘snooze’. I’m also considering making a whale-shaped one, using a steam iron for some second degree burns.

How to set up an open-source Stellaris Launchpad toolchain on Arch Linux

2012-12-30T00:00:00+02:00

We got some Stellaris boards from Texas Instruments. Two each, of course. We put ‘em in the closet until the dev chain matures. After getting a nudge from miceuz, I finally decided to try it out. It turns out that setting up on Arch Linux has now become trivial.

There are many ways to get it working. I prefer open-source. The AUR is a total mess of EABI packages. As per cross-compiling tool guidelines, the proper name for this toolchain is arm-none-eabi (if no vendor is specified). This name is taken by the Sourcery CodeBench stuff. Note also that it’s a binary redistribution.

Another set of packages (more widely adopted) is cross-arm-none-eabi-*. This is what I want. It is based on the summon-arm-toolchain script and uses the GCC toolchain.

To debug, you will also need OpenOCD. To flash, lm4tools. Create a few config files, and you are go.

So, the procedure.

As a bare minimum, get the following from AUR: cross-arm-none-eabi-gcc lm4flash-git.
For debugging, also get these: cross-arm-none-eabi-gdb openocd-git. I asked veox to pack the latter. By the time you read this, the stable openocd from community will probably support Stellaris, so just use pacman. There is also lmicdiusb-git, but I haven’t tried that.
Add a udev rule, so you don’t have to sudo all the time.
Test your debugger. As per the guide, I used stellaris-launchpad-template-gcc to avoid obscure TI licenses.
Optionally, get the official StellarisWare library. The page has broken JavaScript and wants you to log in, which I couldn’t. If you do manage to accompish this feat, know that you won’t be able to use their code for anything – just read the license. I propose we ditch it.

Now just figure out why use this instead of your usual workhorse. Perhaps a CAN bus interface by Thomas Fischl, the guy who gave us USBasp?..

Merry-go-round electronics

2012-12-08T00:00:00+02:00

It’s an electronics part of merry-go-round saga. Read the first part about mechanics before.

The task

When pwf asked me if I’d like to put some thought into this merry-go-round affair they were going to pull of, I didn’t hesitate much - the project was a good test of my electronics skills and my niggaz needed me - how could I refuse?

The task at hand was like this - the carousel hangs from a ceiling, it is driven by a variable frequency drive, there is a stage wheel beneath it which rotates, the carousel has to rotate together with the stage wheel in one mode and has to rotate fast (how fast is too fast?) in the other mode.

At first we were going to take readings from the shaft of the motor that drives the stage wheel (i’d even quickly made a tachometer from parts from a junk bin), but after inspection of all the mechanisms we understood that there was no chance - the age of the system approaches the years when people were walking on the Moon and it hasn’t seen much love from any caring engineer during all this time.

We decided to take the readings by attaching a rubber wheel with a rotary encoder to the steel bottom rim of the stage wheel - this way we could be sure that we get the exact measurements of movement of the edge of the stage wheel.

What about the carousel? We’ve chosen a variable frequency drive with a modbus option, so we could control it remotely, but what about the feedback? Luckily it came to me early enough in the process: we need a closed loop system for synchronization to work properly. It might have worked in the open loop mode, but the system was unknown, there was no time for testing, so when in doubt - overengineer - we’ll have another rotary encoder that’s reading the rotation of the carousel. This way we have a PID system that ensures that both the stage wheel and carousel have rotated exactly the same amount. Provided encoder readings correspond to a real rotation. Read on.

Reading encoders

Ok, how do you transfer pulses from the encoder that might be up to 100m from the control panel? When in doubt… I’ve decided to use RS485 as a wire protocol for that. Quickly enough nice folks from Linear Technology and Maxim-ic have provided me with free engineering samples of receivers, drivers and transceivers. Far quicker than buying from distributors. And free.

We used a high-end encoder from precizika. Conveniently it was outputting a differential signal, so I’ve used MAX3095 to read it and LTC486 to transmit it down the line.

I had time to take some nice pictures:

But that’s boring. The fun part was designing all the protection - the thing was meant to be used in a theatre and things do get messed up in a theatre. The adapter uses the same RJ45 connectors for input and output, I know it’s a BAD THING(tm), but those connectors were too convenient to not to use them, so I’ve had a nice afternoon designing a foolproof protection from reverse connections. And a fault indication. It’s an encoder-side connector that usually outputs voltage. If the system sees voltage on 1 and 2 pins (this happens if you reverse connectors), the FUBLIA LED lights up and bad things do not happen.

Another fun part was developing an edge detector to blink some LEDs when pulses from the encoder are coming: Note the extensive use of PNP transistors - I have a pile of them left after a project before, had to use ‘em up!

Control unit

The control part is really boring, it’s just my CatNip board with a special ‘kitteh’ - a ‘shield’ to condition RS485 signals, read some buttons and blink some LEDs. I’ve used LTC488 receiver to match the Linear Technology driver on the encoder adapter and LTC485 to talk to the variable frequency drive. I’ve written a of couple semi decent modbus functions. The whole code is at my github repo.

This is a picture of our control panel:

Well, all of this was a “clean room” design exercise - as the guys in the workshop were cutting and welding steel like real men, I had to emulate the unknown parts of the system. When I came to the workshop, the carousel was in rather early stages of being complete, so I had to spend some time writing utilities to graph step response, read on control systems theory and design a DMX LED dimmer while eating spacecake. I didn’t have an opportunity to run my system until the carousel, still hot from welding, was brought and installed in the destination place.

The Motorized Plow

That’s where the fun started. My system worked quite well, but there was a problem with a stage wheel - the steel rim we were running our encoder wheel on was not that round after all. One fourth of the circle was squashed inside, so the carousel would go with the stage within the error of 10cm for 3/4 of the circle and run away in the last quarter. I could have thought of some trick in software, but because of sleep deprivation my skull was full of scrambled eggs instead of brains. So either you solve optic problems with optics, mechanical with mechanics and electrical with electronics or you solve all the problems in software. This time we went the former way - pwf added one more degree of freedom to the encoder wheel fixture, changed its angle and orientation on the rim and we were able to follow the wheel for two to three rotations within allowance of 20cm. Which was totally OK for our purposes, but it left a bad taste in my mouth. Check out the first part for the crappy video of synchronization in action.

When I got up in the theatre (I’ve slept there, because I was too exhausted to go home), I was greeted by a flock of 50-year old males in formal suits - the theatre management. They brought an old man with them, who still works there as an electrician, but probably still remembers the times when men were walking on the Moon. This old man started telling me story about how he managed to build himself a motorized plow for his garden out of ropes and pulleys. Aha! That’s why stage wheel is in such a sorry state…

There is some pr0n to look at in the meantime:

Here you can see an AC induction motor, variable frequency drive for it, a reduction box with a chain to drive the carousel and a box that will hold electronics for a DMX LED dimmer.

DMX LED dimmer

How long does it take to design and make a fully functional DMX LED dimmer? Two nights while eating spacecake to draw a PCB, one day to get the parts, etch and solder the boards and one day and one night to write firmware, test and install it.

As an optional bonus there had to be LED strips on the carousel, controllable via DMX. Well, how do you transfer power to a rotating thing? Ground goes through the frame, and live wire goes through a graphite brush on a slip ring. How much resistance/voltage drop do you get when the carousel rotates? Unknown. When in doubt… overengineer! We got this beefy transformer out of a trashed guitar amplifier, it was outputting 30V. And we hooked up a constant current source that would compensate for the voltage drop through the slip ring and bearings. And we made a nice 50W heater out of 4 parallel MOSFETs and a huge heatsink. But what if one of several LED strips is not connected? You get the same current pushed through the remaining ones of course. Hm.. no good, let’s put a PTC on every LED strip.

This is a constant current source:

As for DMX part - it’s nothing fancy - just an AVR atmega8 hooked up via MAX3095 to DMX line via an optocoupled open collector output to pull the gates of MOSFETs down via PWM.

I used some rxdtxd’s DMX decoding code. The whole thing is on github if someone is interested: https://github.com/Miceuz/DmxLedDimmerBasic

PTC’s on the strips paid off nicely as one of those crap Chinese strips was shorting to the frame! Now just imagine all the things we said after discovering this at 5 o’clock in the morning!

Aftermath

Well, it was a nice hell of a deathmarch involving a bunch of people, using a load of different skills and techniques. There was too much of things we didn’t know beforehand and no time to test ideas. Nevertheless, we are very lucky to have pulled this off. When in doubt… overengineer!

Merry-go-round

2012-12-06T00:00:00+02:00

Introduction

Gotta get off, gotta get off, gotta get off of this merry-go-round…

This is another big one, and it came in together with the rails, so you can guess why there ain’t many pictures. We had our hands full of tools more labour-worthy than a camera.

Anyway, a carousel was to be made in ~~little~~ no time. It had to be 4 meters across. It had to spin, at various speeds. It had to sync with a revolving stage. It had to be stable enough during rotation that articles of fine modern furniture could be suspended from it.

My part in this was the rotating circle and its suspension to the axis. The rotor, in short.

Blueprints? What blueprints? (A FreeCAD review)

In short: there were none.

For all I intended to do, I really wanted some: we’re talking circles here, people! Lots of angles cut at precise lengths, and most of them in volume. But, alas, every artist is his own engineer.

I tried some open-source CAD programs, spending most time on FreeCAD (version 0.12.5284), and the verdict is: not stage-ready.

First off, FreeCAD is a front-end with frills, written in Python 2 (and Qt). The back-end is OpenCascade. There are big issues with both.

The biggest one with me is this. Since FreeCAD is written in Python (essentially a prototyping language, in my view), it breaks a lot. My system is probably quite different from that of the current developers’, and it dumped core once every three minutes (on average). Filing bug reports would have been useless: there were at least ten different exceptions in trace-backs, and we would have spent hours arguing whether this is a misconfiguration. Of Python.

If you do decide to try out FreeCAD, have the following in mind.

Do not upgrade your real work parts to a combined part, upgrade copies instead and hide the originals. If you decide to edit the combined part later, exploding it will give you ~~feces~~ faces instead of solid objects.
Making a lot of copies at once might not copy everything, but it fills the object list anyway. Deleting objects that are listed but don’t exist drops core.
It seems there’s no way to specify an arbitrary reference axis when rotating, which caused me a lot of grief.
You either rotate in the current view’s plane, or one of pre-defined XY/XZ/YZ, which are also called top/front/side elsewhere. Confusing.
Rotating multiple objects in the same plane by a certain angle does not always result in them rotating the same angle. If it sounds wrong, that’s because it is.
Snapping uses algebraic units and doesn’t take the current view’s zoom level into account.
A lot of essential functionality is implemented as macros, which are not included in the basic package. Solid Sweep proves useful, if you can get used to it.
Boolean operations on solids do not always work, which is mentioned in the FAQ.
Also, they sometimes drop core.

After several hours of cursing, I got this.

Which is, in my book, too long for too little. I eventually drew and calculated everything I really needed on paper.

Why not AutoCAD? Because I don’t use Windows. Why not Google SketchUp? Because that doesn’t have Boolean operations on solids in the freeware version. Why not DraftSight? Because that has very limited 3D functionality. Why open-source? Because we don’t really get anything but experience points for this.

Sorry for the long-wrought review, I just had it sitting in my home dir for three months. Back to the topic.

A slice of Pi

As soon as metal got into the shop, I set out to cut those beautiful long slender things into stacks of beautiful short identical things.

Remember, it’s a “circle” 4 meters across, made of short straight segments. A polygon, right. The circle’s perimeter is d * π = 4 π. We decided 24 corners is circular enough.

Technically, it was possible to take a square pipe blank and roll it to achieve desired curvature, but we don’t have the equipment, and there were no resourses to order from a specialised shop.

As always, we designed it so that it could be taken apart (into four parts). This has a few advantages.

It takes less space in the storage room when not needed. You don’t hang stuff you don’t need from a high ceiling, do you?..
It fits through the workshop’s door, and also into our painting chamber, in case we had time and paint to paint it (we didn’t).
Splitting the circle into four arcs that have a length of π is a nice inside joke. It lets us feel like we know what we’re doing.

I then tack-welded these pieces into eight arcs, and tack-welded those parallel, in couples. It didn’t go too well. I made a jig to weld the short segments together into long arcs at a precise angle. The angle was good, but the jig was too short – it could only support three segments until the arc would start to curve due to its own weight. I set up a convoluted system of props to keep the dangling end from bending too much. This unwanted curvature was reduced somewhat, but still demanded an array of clamps to hold paired arcs together during welding.

Long story short: I was too lazy to set up one proper jig, and so had to set up two instead.

eggman cut and drilled eight plates for segment connections. In the image below, you can see the four tack-welded segments, clamped together with the plates in between. The clamping was also needed for alignment. Luckily, it was just tack-welded, which allowed for fine adjustment (two holding and one adjusting with rebar). The hammer, fridge and van are for size reference.

Most of it was rectangular profile, 30x15x1,5 mm. Pretty lightweight, and considerably more flexible along its 15 mm side compared to the 30 mm side. 6 pieces per arc, with end pieces slightly shorter than the middle ones, to accommodate the thickness of the connection assembly. The connection plates are just lengths of a wide strip, something like 5 or 6 mm thick. It will be slightly clearer from later images.

Suspension: lower bearing mount

The axis at the center had two machined bearing mounts, one at the top, one at the bottom. The circle connects to both with a total of 16 profiles (30x30x2 mm). We called them “strings”. 8 strings to the top, 8 to the bottom.

I started with the bottom mount, once again only tack-welding connection pates to the side.

There were holes for the bearing’s lid in the mount, which came handy for a kind of piggy-back-ride alignment job: screw on two alignment brackets, put a connection plate in the middle, tack, turn, repeat. It is hard to see in the image above, but there are also two pieces of metal, cut to the same length, held at the other side of the bearing mount with welding magnets. So the connection plate is right in the middle. It turned out later most of this wasn’t exactly necessary, and the connection plates could have been welded at the edge just as well.

I then put the bearing mount in the middle of the circle, cut four strings, with different angles at both ends, and welded plates with holes to those. Then four more strings, with yet another set of angles. It came together like this.

What I leave out of the picture here is engineering: measuring the exact angles and lengths, taking the thickness of connecting pates and plane rotations into account, and all the running back and forth in between.

Four strings connect to the top of the circle at the middle of its segments, and four more connect to the bottom where segments meet.

What’s also different is we put in diagonals into the rectangles, to improve rigidity. It would have probably been even better if they were put in rotated 90 degrees along their own axes, so that the 30x15 profile’s flat side was co-planar with the circle’s imaginary cylinder. That would give rigidity in a plane tangent to said cylinder’s surface. But it would also mean we’d have to cut the ends of the diagonal profiles at two different angles, four times per diagonal, a total of 96 cuts. There was no time for that.

Inside the circle’s angle

I must have been waiting for something, since I have many pictures of this stage.

Here’s another angle of the previous photo. It shows a closer view of all the connections mentioned thus far.

Here’s how the pie segments connect:

Connection plates have three screws. This way, you can always take one screw out, and the other two will still be holding the thing together.

Also visible is one end of the lower string, screwed to the segment’s connection plate. Since a screw hole was available here, we thought it could as well be used for something other than just sticking two circle segments together.

It wasn’t so easy in the middle of the segments, where the other four strings go:

An additional (thick) plate had to be welded to the (thin) profile here, and inside the circle’s angle. Took some fiddling, and I eventually settled on high-frequency pulse welding.

It all comes together at the bearing mount:

There were also pieces of rod under the connection plates, to fill the gaps:

Stator and axis

What I was waiting for was for the stator and axis assembly to be finished. pwf did all of it, except for a few small parts I made while there was nothing else to do.

We initially planned the axis to be 2 meters high, but later settled on 1,5 m to reduce weight. This quickly proved to be the right choice, since the entire length could be reached from the floor. A shaky ladder was involved, sure, but only later on, during some final welding, and wasn’t required to hang the stator on a girder.

Anyway, here it is, upside down:

On the right is the motor and gearbox. On the left, the axis and upper bearing mount. The latter’s alignment is being checked.

In the measured plane, the maximum deviation was 0,032 mm.

I’ve also tacked four plates for strings to the upper mount by this point.

Death march

We were running out of time, so there are no more pictures of the build process. I’m also not sure what happened after what exactly.

What I do have on the hard drive is many pictures of couplers.

These would eventually be used in suspending the carousel. Can’t tell much about why and how many, since I had nothing to do with it. There were 16 of them, I think. I do remember various artists cutting machined cylinders lengthwise.

Also visible is the lower bearing mount, with plates welded all the way.

Fast-forward to a full assembly, past the night when everything that was tacked got welded.

Eight more strings, to the upper bearing mount. Four of them straight, just as the lower ones. Four more at a tangent to the upper bearing mount, an almost 90° angle, because we thought this would be useful in rotation moment transfer. A few helical spirals would have been better, of course, but that would have been too much.

Several couplers are also visible. Well, almost. The hatched system of battens is required for weight distribution. When lifted, the merry-go-round’s rotation may introduce swinging, so the pipes have to be attached to a static structure with strip belts (one, orange, can be seen hanging in the image above).

Here it is again, in all its glare:

What’s not in the description

Everything mechanical and electrical – essentially rotation and synchronising with the revolving stage. Also, everything that got hung (a Styrofoam closet can be seen, though). I was not involved in those parts.

I did manage to get a few crappy videos, though.

First, stuffed animals spinning at half of maximum speed.

Washing machine drum coffee roaster (live run), on YouTube.

Second, rotation tracking. A stuffed flamingo is propped up on a box that stands on the stage, and suspended from a cord that is attached to the carousel at the same time.

Washing machine drum coffee roaster (live run), on YouTube.

Chairs on rails, and other stuff

2012-11-18T00:00:00+02:00

I accidentally lost the habit of taking photos, which is an important accessory with cameras. So this isn’t going to be too concise.

Anyway, we’ve been up to this:

What is this blurry picture? It’s rails! (Ruby didn’t make it.) There are five segments like this one, 10 meters total. They connect with a simple ~~pipe-walks-into-bar~~ bar-goes-into-pipe joint. (No picture.)

As you might expect, the tolerance for rail-to-rail distance is really tight. One millimeter of deviation is near-disastrous. A manned chair rolls on top (as you might have guessed from the title), so it is imperative the thing be straight. To achieve that, we used precision-machined cylinders paired into guides.

The cylinders, alas, were not precise enough. A few let the pipe slide in just right, most had too small a hole, and one was being an ass altogether. I used files (a few) and sandpaper (lots) to make ‘em spec. It took half a day. You see, had any wobble been introduced, I’d have a big fat ring instead, and I don’t wear jewellery.

There were also other goofs with the machinist’s work, and that had to be worked around as well. (No picture.) This gave me a lot of time to think on various kinds of jobs and how you naturally expect a certain degree of precision, how big a millimeter really is, and stuff.

Anyway, making four guides with the same rail-to-rail distance was not exactly hard once I had the cylinders. A few clamps and a few magnets, basically (no picture).

The guides are then put on a pair of awry rails and straighten those out. If you’re wondering, the cross section looks like this:

I used the same cylinders mentioned above, before they became paired guides, to weld a pipe to a T-bar.

With the rails aligned and the section’s diagonals measured, I put sleepers on top. The guides are cut in two and removed.

Repeat five times, have a little fun in the workshop. Repeat a hundred times, start a mining operation.

Oh, there were also two contraptions where the railroad ends, to stop incoming locomotives. (No picture.) A little piece of it, though, aligned for welding:

The final thing, cropped for image size (again, Ruby didn’t make it):

I didn’t do the chairs, so there’s not a lot I can write about them, except that they roll on four wheels, have eight additional bearings for alignment, and have been deemed safe for use in long-distance travel.

Gear review

Working at the railroad was not the true reason we did this project. At the end of the day, it all boils down to how my gloves do in the workshop.

On the left is a pair of brand-new, never-before-used Guide gloves, model 5005. On the right, a pair of same gloves, two months into regular hard work. From experience, this is a month into posthumous life.

If you asked me, these are good enough for general metalwork. I think the box said the palm side is synthetic leather and covered in Teflon. I’ve literally soaked them in oil twice (during drilling) and they didn’t turn into stone (as natural leather tends to).

To the touch, they’re pretty thin, so they won’t do at the wood shop, but they hold up reasonably well otherwise. Those holes on the knuckles are from grinder sparks (the backhand is, of course, nylon or polyester or something like that). The holes on the fingers are from turning tight screws, so these won’t do in the auto shop, either.

I’ve done quite some welding with these gloves, too. A thing I learned is they let heat through, to the point where I got light burns on my palms, but the gloves themselves didn’t burn or shrink (as, again, natural leather would).

Another weird thing is they are lightly metallic. Put these on, and you’re a magnet magnet!..

P.S. If you’re a Guide representative, please send various models from your catalogue in our general direction. Size 9. Thank you.

A simple car battery charger

2012-11-13T00:00:00+02:00

This is about making a very simple charger for lead-acid batteries, commonly used in automobiles.

In case you can’t parse the picture, the setup is simple: mains power is connected to a variable autotransformer, then in series to a transformer, a diode bridge, an ammeter (not visible in the picture), and a battery. There are also capacitors and a voltmeter in parallel with the bridge’s output.

The purpose of each block is as follows:

the autotransformer is used to regulate voltage and current, simultaneously;
the transformer drops voltage;
the diode bridge rectifies AC;
capacitors smooth out the rectified waveform;
the ammeter and voltmeter are for monitoring;
the battery is the load.

I have no idea whatsoever what the exact parameters of each block are, except that most of them are big.

Both transformers’ wire windings should be thick enough to withstand the current pumped through them.

The step-down transformer should have a ratio such that it can drop mains voltage to a value slightly above the desired output voltage. This accounts for the voltage drop on the bridge and the fact that to charge a battery in reasonable time, a higher than rated voltage has to be applied.

My diode bridge here is four individual diodes whose ratings are certainly overkill for the task. Voltage drop on the bridge is twice the drop on a single diode.

The caps are rated for 400V – that’s what I found in the bin. They can surely be quite smaller, but at least twice the maximum voltage.

The ammeter was also available in the bin. It’s analog, with a dial and a maximum value of 10 A. If you intend to use a multimeter as an ammeter, know that they might not have the appropriate circuitry inside, even if it’s on the dial. Also, there might be a cigarette butt instead of a fuse if a friend of yours blows it and decides to play a prank on you.

The voltmeter is an el-cheapo multimeter from the store. (EDIT: I eventually swapped that out for an analog voltmeter, so the multimeter could be used elsewhere.) Its range should be bigger than the charger’s maximum output voltage.

In desperate times, all of this can be done with just a voltage-down transformer and a diode bridge. Everything else is optional, if you’re careful. Otherwise, you’ll zap batteries, since 1925:

If a transformer’s winding is too thin (say, less than 1 mm² with 5 amps DC on the output), you’ll fry it:

On a whole different note: is this all we’ve been up to last month? A makeshift car battery charger?.. Of course not.

What was it? Well, tune up your internet receivers, it’s coming soon!

CatNip ADC performance measurement

2012-10-12T00:00:00+03:00

I’ve quickly measured ADC performance by putting a 2 x 10K voltage divider into ADC0 and taking 64K samples. This by no means is a proper test, but let the images speak for themselves.

ADC performance of Microbuilder’s design on a board fabricated by us before:

ADC performance of CatNip:

Here is the histogram comparison:

It seams, the effort I put while routing ADC traces is paying off…

CatNip - LPC1343 development board

2012-10-04T00:00:00+03:00

Roughly a year ago we have expressed our interest in ARM based micro controllers and a concern in shortage of devboards of these to order. After doing a couple of projects on our cheapo-pro made boards I’ve stumbled on lack of some features I want and I ran out of my boards. I wanted an ARM devboard tailored for my purposes. So, what does one do in such circumstances in our open hardware world of freedom? Roll your own of course! After a week long routing and 5 months wait for the customs and post offices to resolve ė in my name, today I’ve accidentally met the postman and saved myself a trip to a post office:

So, the devboard is based on LPC1343 Reference Design by Microbuilder and the main differences are:

USB connection header is added in order to facilitate adding an external case mounted USB connector that is placed far away from the board
RESET pin is in a breakout in order to allow putting a reset button on the device case
non-usb power is connected via screw terminals
eeprom in SO8 package is used as it’s more common
separate power header is added to export regulated and incoming voltages to daughter boards
most of 3.3 V and GND connections removed from breakout as it encourages ground loops, GND connections are left near communication pins (SPI, I2C, RXTX) for easier prototyping, 3.3 V connection is left near ADC inputs as it’s handy to limit ADC input to 3.3 V by adding a diode
all UART pins except RX and TX are reclaimed for other purposes
more ADC pins added
onboard LED pin is added to header
JTAG connector removed and it’s pins reclaimed for GPIO/ADC (I don’t have a JTAG programmer currently)
an effort has been made to not to route digital lines under ADC lines in order to achieve ADC performance that sucks less

I wanted myself a board that I could use in projects I do and leave it there, the board should be big enough to support expansion “shields” and it had to be easy to put the board into random box that has all connectors mounted - I didn’t like the idea of exposing on-board mini-USB connector to hostile outside world, neither I liked the idea of 2.5mm power jack. I like to connect analog and digital grounds at power supply, hence the single power export to daughter boards.

The eagle files are available on my github: https://github.com/Miceuz/CatNip. The board is compatible with original firmware library by Microbuilder, but you also can check my own fork: https://github.com/Miceuz/LPC1343CodeBase

In general, what I like most about this design is that LPC1343 micro has USB 2.0 hardware inside and together with eeprom chip onboard, it let’s you perform configuration of your device “in the field”. Microbuilder has started a good initiative by writing an easy and flexible command line framework, so a standard blinky example comes with a command line interface that you can access by virtual serial port. I’m working on adding various peripheral functions like ADC, SPI, PWM, I2C to the command line so it has some resemblance to bus pirate for free. Another thing - it has internal boot loader by NXP, that makes the chip to appear as a mass storage device in programming mode - you just copy your new firmware and reset the chip - no external programmer hardware is required. On compiling side - GNU development environment is available. Oh, BTW, did I mention that you can find LPC1343 for cheaper than ATMEGA328?

I have parts and PCBs for 10 boards and currently have no intention to sell them. The price I was able to achieve is $12.20 per board on this small run, so if someone would like to get one for $25 or so, ping me or get ir from tindie.com, I might do another run. But you can hardly beat TI stellaris launchpad for five bucks and free shipping…

Capacitance measurement using low pass filter

2012-09-26T00:00:00+03:00

Update 2012-11-30 A new working vesion of plant watering alarm is available for sale! It’s open source and it goes Chirp!

So I’m building the new version of my Plant Watering Alarm. I’m doing it based on capacitive humidity sensing - damp soil acts as an electrolyte increasing the capacitance of some makeshift capacitor made of couple of traces on PCB. I’m currently just counting amount of processor ticks while charging the capacitor till 0.63Vcc and it’s working quite OK, but a few days ago I have stumbled on this technique to measure capacitance:

Idea is straight forward - you feed square wave into low pass filter composed of a resistor and your probe as capacitor C1. As capacitance of C1 changes, so does cut off frequency of this low pass filter, lowering the peaks of output waveform, then this kinda-triangular waveform is rectified by a diode D1 and a capacitor C2 to give voltage estimation of capacitance of C1. Here you can see an approximation of what I saw on my shabby analog scope:

I’ve instantly put together a circuit using 555 timer to generate a square wave. While playing with the circuit I’ve noticed that when I increase C1 or R1, peak values do not go lower linearly, then I’ve noticed, that capacitor does not discharge fully as square wave is exactly 50% - so the peak-to-peak value is changing, not zero-to-peak. This creates some problems as voltage on the rectified output would not swing as much as it could, we are loosing dynamic range…

The fix was easy - just discharge C1 on zero phase of square wave. You could use a PNP transistor for that:

It looked much better on the scope, but there is one slight problem - emitter-base junction will conduct until there is more than 0.7V difference between them. So, I’m left with constant 0.7V on C1 after each charge/discharge cycle. Ok, lets use two transistors:

Q3 acts as a logic NOT component outputting HIGH, when the square wave goes LOW - this turns Q2 on really hard and capacitor discharges until it reaches Vce of the transistor which is much lower than 0.7V. OK, so far so good, I can go on with calculations: what is the most optimal value for R1 so I would have the biggest voltage swing in my capacitance range? Here comes The Formula (taken from the great Electronics Tutorial about the RC Time Constant):

Vc is voltage across capacitor, Vs is square wave HIGH voltage, t is time, R and C are resistance and capacitance of your RC network. OK, lets put it into Wolframalpha:

This is a graph of Vc for t=62.5ns, R=4.1K and capacitance from 7pF to 42pF as this is my current probe capacitance range when in air and when fully submersed in water. Not too linear, but oh well, tradeoffs must be made.

I know 4.1K is optimal because of this graph:

On Y axis there is a voltage difference between points at 7pF and 42pF and on X axis is resistance of R1. Heck, I can calculate that precisely:

So, optimal value for R1 is 4.1K and voltage swing is from 2.66V to 1.57 minus the diode drop. The response is not linear, so R1 could be chosen smaller so the graph would shift to more linear region or it can be handled in software.

On final note, I’m yet to build a prototype based on this technique. I’m not sure if all of this will go into Plant Watering Alarm as it’s working quite ok in its current iteration. 1.75V is 1.74/(3V/1024)=596 values on Attiny44 10 bit ADC, it could be improved by adding an external voltage reference or doing some op-amp shifting/scaling kung fu, but it’s not really feasible for such a simple device as Plant Watering Alarm is ment to be. Maybe I will get on building a high end soil moisture probe, so let me know if you would be interested in that.

Meanwhile here’s a sneak peak preview of current iteration of Plant Watering Alarm:

Phono preamp as a first electronics project

2012-09-21T00:00:00+03:00

Mr. Hat contacted me asking for a help in building a phono preamp for his vinyl record player that he recovered from oblivion somewhere.

As you probably know, there are some issues with vinyl records that require audio tracks to be mastered in certain way before they are put into a disc. Particularly, you have to attenuate low frequencies, so that the needle won’t jump between tracks when that kick drum is really delivering, and you have to amplify high frequencies so that they rise above the noise floor. When you want to play a record back, you have to reverse this process - amplify lows and attenuate highs - that’s why you need a phono preamplifier.

Mr. Hat has chosen this design for his build. There are lots of other phono preamp designs that have a potential to be better, but I’ve told him to simmer down - when you are building your First Project, you want results and you want them fast. So I skipped on all that fancy unobtanium audio purposed polystyrene capacitors and designed in simple plain ceramics with horrible tolerances that I believe will make real audiophiles turn blue. I’ve etched a couple PCBs so he wouldn’t need to make a mess on a protoboard.

This was my first attempt at designing for success from the first try and I’ve failed miserably in designing a two rail power supply. At first the footprint for bridge rectifier was wrong, then I’ve discovered that pinouts for LM79XX parts differ from LM78XX. Yeah, never assume anything and double check the pinout ant footprint. The power supply turned out as retarded as it can go - when cutting traces to fix the LM79XX pinout I’ve cut the wrong traces! Later i’ve discovered that LM79XX parts need more capacitance on the output than LM78XX, as negative rail was oscillating like hell!

And finally, relaying on this design for two rail power supply is just dumb as output tolerances for LM78XX and LM79XX are 2% to 4% when you get them from reliable manufacturer, in other words, you won’t have you rail voltages to be equal unless you handpick the matching parts. I’d better just put a 24V linear regulator, split its output via 1% tolerance resistors and buffered that with op-amp.

I made Mr. Hat to solder his first project in SMD and he managed it ok, but goofed up the wires horribly.

Later he made an enclosure from copper clad board.

It didn’t work on the first try - Mr. Hat had messed up some mechanics in a turntable and outputs were shorted, but after some poking with multimeter and a little bit of common sense, we have found a part that was upside down. After dealing with that, we’ve heard that special popping sound of vinyl and the first chords - the eyes of Mr. Hat were glowing and the mouth had that sleazy smile - it works!

If someone is interested in ready made Eagle files, you can get them form my github repository: https://github.com/Miceuz/PhonoPreamp (power bugs were fixed)

Bus Pirate and random plasma TV indicator

2012-08-20T00:00:00+03:00

We found a plasma TV by the dumpster. Lots of neat stuff inside. Say, this here 6-LED indicator with a M62320FP chip, an I/O port expander for I2C. Not to mention all the aluminum…

Very conveniently, BP has a BASIC interpreter, enough to goof around.

10   REM PROGRESSBAR
20   LET A=116
30   LET M=255
40   LET V=63
50   START
60   SEND A
70   SEND M
80   SEND V
90   STOP
100  DELAY 500
120  REM IF V=0 THEN GOTO 150
121  IF V=0 THEN LET V=127
125  LET V=V/2
130  GOTO 50
150  END

Should have made a cylon, yeah.

Drum coffee roaster, complete

2012-07-27T00:00:00+03:00

We are almost out of coffee again, so the fixed roaster is going for a hot run. On a sunny day, we took our green beans, 4,5 kg this time, and went outside the workshop.

The setup consists of the roaster itself, a propane gas stove, an electricity extension cord for the motor, and a big pan to rapidly cool the beans when they’re done (to prevent overroasting).

One can spin the pan and submerge it in water, exactly what we did on our first attempt. This time, though, the pan is made of cast iron (heavy). So instead, we used a compressed air gun.

There was also a chess table and refreshments, so we could do something while we do nothing.

We started off by putting a batch of green beans in, 1,5 kg at a time. I’m sure it could take more, but we didn’t know the dynamics yet.

And the dynamics, I must tell you, are quite something.

The first batch took us something like 90 minutes – on a steady fire that was probably too low. The roast is moderate to medium light, according to this.

The second batch saw a lot more fiddling with the fire. A miniscule turn on the stove’s handle, and the beans go from moderate light to Spanish black in a matter of minutes. There was also a lot of smoke, but nothing a compressor-powered air gun can’t handle.

The third went a lot smoother. We had a handfull of roasted beans from our previous trials, a reference colour to aim for. It still took quite long, almost an hour, since we didn’t want to screw up the last batch. And it was an hour of playing chess, watching a drum spin, which beats anything.

After a batch is done in the roaster, we dump it in our pan and cool it.

Then it goes into an airtight container. In the image below, left to right: batches 1, 3, 2.

Here’s a short video of the process.

Washing machine drum coffee roaster (live run), on YouTube.

Upgrade boot process from BIOS+MBR+GRUB to UEFI+GPT+GRUB2 in Arch Linux

2012-07-23T00:00:00+03:00

I have a 64-bit system running Arch Linux. MBR and its extended partition is a PITA. I’ve been using GRUB-Legacy far too long to see its limitations. Official support was recently dropped. So now is a good time to update from both in one go.

This is my log of how I did it. It worked for me, it might not work for you. I omit the details and specific commands and provide source links instead. Have a general understanding of what you are doing. If you do not need/want UEFI, or GPT, or GRUB2, if you don’t see the benefits of either, or if you not know what modprobe does, this “guide” is not for you.

Read the entire post before you do anything.

Make full system backup.
Make rescue media. I have GParted Live, SystemRescueCD, Archboot, Linux Mint and Ubuntu. Get your own and learn to use it.
Edit partition table. Make space for a UEFISYS partition, leave space at the beginning and end of hard drive for the GPT.
Backup MBR. Also, copy this backup to external backup media.
Reboot, enable EFI and see if you can boot. If so, you’re good to go. If not, reboot in BIOS mode. Continue at your own risk. You will have to use GRUB rescue mode later.
modprobe efivars to enable efibootmgr operation. If /sys/firmware/efi is populated, you’re good to go. If not, continue at your own risk. You will have to use GRUB rescue mode later.
Convert from MBR to GPT.
Create the UEFISYS partition.
Backup GRUB-Legacy.
Install grub-efi-x86_64.
If 'modprobe efivars' worked previously, you’re more or less done.

If it didn’t work, 'grub-install' will fail with

Fatal: Couldn't open either sysfs or procfs directories for accessing EFI variables.

After all, it’s still booted in BIOS mode without UEFI.

Reboot, enter UEFI menu and boot through GRUB2 rescue mode.
Reinstall grub-uefi boot files.
Break open the champagne. If not, set yourself on fire and run in circles.

Drum coffee roaster, revisited

2012-07-14T00:00:00+03:00

Manual mode trials

My previous attempts at mechanising coffee bean roasting were unsuccessful, so I slapped on a handle to rotate the drum manually.

It worked pretty well until I noticed something odd: beans started falling out of the drum, like if there was a hole big enough. I know there weren’t any, at least until I hadn’t put a gas stove under the drum.

Turned out the doors of the drum were attached to its frame with plastic. Plastic! It wouldn’t melt at the measly 90°C inside a washing machine. But it did in my case.

So I took the doors out and continued with the operation, now rocking the handle back and forth at an appropriate speed, so the beans would keep roasting. I later used a propane torch to burn all the plastic out, then washed the drum with water to remove any residue.

It became evident at this point that the 2 RPM motor I intended to use previously would have been too slow, and my coffee would have burned. So fortunate it didn’t work.

Besides all that, it actually requires two people for this mode of operation: one rocking the handle, and one checking if the beans are done, taking a small batch of them out with a spoon and comparing color to the reference.

If I had to continue with the roaster like this, I would have turned those four big screws by the doors around, so they would act as stops, bumping into those “ribs” that hold the device together, preventing the hole which was previously a door from pointing downwards and dumping all the beans directly on top of the stove.

But really, for a lazy engineer like me, all of this was too much physical labour. I took it back to the workshop.

Doors

First thing first, I fixed the doors. That is, I put a 5 mm stainless steel rod and a few bushings in.

The spring that opens the door had to be cut, since ioch damaged half of it while trying to scrape the plastic out. I just burnt it out later, but the spring was already twisted.

Motor mounting

We also got a new motor: 4,0 W (although looks like 40), 975 RPM, with a reduction gearbox that brings it down to 10 RPM. Solid-core Soviet unobtanium, made in 1979. I cut and tapped a mounting bracket that attaches to the legs with two screws.

Mounted, it looks like so.

Motor coupling

What I forgot to photograph in the previous post and therefore couldn’t properly explain was how the drum was being rotated. So here’s the catch.

The shaft of the motor had a small steel gear attached to it.

I took it off and welded two thick strips of steel to it.

Why would I do that? Here’s why.

This is how the motor is coupled to the drum. A T-shape is screwed to the axis shaft of the drum, and the motor shaft’s head (modified gear in this case) has a “prong”. As the motor rotates, the prong pushes on the T-shape, forcing the drum to rotate.

This method has a lot of slack, an advantage in this case, since things aren’t perfectly centered. It’s probably been patented by some wanker, too.

The test

There were no coffee beans around this time, so I used a box of screws. It felt something like 1,5 kg. And it worked! The motor spins.

Washing machine drum coffee roaster (test run), on Youtube.

It is still to be tested with real beans, though.

Drum coffee roaster

2012-07-04T00:00:00+03:00

There are two reasons why this contraption came to be.

First, we like coffee. We like a lot of coffee, a lot. Ground coffee from the shop is crap, most of it. Unground beans are twice as expensive. What do you usually do in this case?

You buy it online.

Second, you eventually buy several bags of unground beans, and then realise you have no idea how to roast them.

There are a lot of simple and time-consuming methods. Roasting in a frying pan takes, say, 3 hours of non-stop work to make a kilo of the good stuff. You can’t stick a lot in the oven, too. One could even do it in a popcorn popper or between two meshes.

This last video got me thinking. A cross between that and an industrial drum would be nice. Perhaps a top-loaded washing machine drum, with an electric motor on the side and a gas stove beneath.

Drums and bearings

Consequently, I was much pleased when this appeared in the workshop.

Oh, the things that break and get thrown out!.. My heart sings as I wash them in acid.

This stainless steel drum has a bearing on either side of the axis. You can see one in the picture above. We got two precision circular mounts for the bearings, made by a professional machinist.

There was also a drawing somewhere on that table, but the whole project went artsy so early on the drawing is not relevant to anything.

I welded the mounts to strips of 4 mm metal, working it in small increments to prevent warping.

Legs

The roaster stands on four legs, two on either side, welded to the metal strips on the outside (so they don’t touch the rotating drum). Square pipe was used here.

Thickness is more or less arbitrary. As to length, I used the diameter of my drum as the dimension. Make it such that the legs and ground form an equilateral triangle. As you remember from school, it is then trivial to calculate their position on the side strips.

Motors

The above image also shows how a motor is to be attached. There are two brackets pointing outwards. A plate of some sort is attached to the motor, and that in turn attaches to the brackets. Why a proxy? Because there’s only so much space. And it’s good to be motor-agnostic in case a motor doesn’t work.

Anyway, the attachment plate has threaded taps to screw the motor on. There are also two threaded taps on the sides of the plate. Their centers are set apart as far as centers of the holes on the brackets. The latter are much bigger (10 mm against 6 mm), so that after the motor is mounted, it can be pushed around a little. This allows centering the motor along the drum’s center axis.

You can see now that our thinking here was quite center-centered. That’s for a reason: a motor will be spinning quite a load here. Speed is negligible enough as far as bearing alignment is concerned, but the motor’s grip alignment isn’t. Besides, it gives an angle at compensating misproper alignment in everything else.

This scheme is implemented on both sides of the drum. They are not identical: there are four brackets on the other side, which allows mounting a much heavier three-phase motor to be controlled with miceuz’ variable frequency drive and a foot pedal.

Of course, only one motor is to be mounted at any given time.

I forgot to take pictures of how the motor actually grips the drum to spin it. Maybe in a follow-up post.

Ribs and assembly

When the leg parts that go on the sides of the drum were all welded together and cooled down, I inserted the bearings and gently tapped them in using a round piece of wood and a hammer. I then assembled them on the drum and measured the distance between the legs on either side.

There were two holes on each leg, drilled prior to all the welding (for ease of manufacture). They are further away from the top end than the radius of the drum.

I measured the distance between the legs on opposite sides of the drum, and cut four pieces of the same square pipe I had. These are for stability, to disallow mischievous acts of falling apart and rolling away.

Accidentally, it allows taking the machine apart, and putting most of it inside the drum, for easy storage and transportation.

Turning beans

You might have also noticed the drum has largish holes along its outer surface. One could weld them over to prevent beans from falling out. But I screwed in some screws instead. They are, of course, stainless steel.

This helps in turning the beans while the drum rotates.

Tests

One thunderous rainy night, as soon as all the chores were done, we decided to have our share of fun and run a few tests.

And I hate to disappoint, but both motors failed and there are no videos of proof.

The smaller motor, 2 RPM, four puny watts of power in a reduction gearbox, failed to lift 1,5 kg of beans. Not enough torque, lever-arm distance too big.

The bigger one, too, couldn’t lift the weight all by itself: it doesn’t have a reduction gearbox, although it does have power (140 W). However, if the drum is first spun by hand, and the motor is then turned on, it picks up momentum and keeps spinning jolly. Except one thing: it spins too fast, like a centrifuge, and all the beans get stuck to the drum’s surface. If there was a burning stove beneath, the beans would get roasted mighty uneven.

Manual override

So I took both motors off, and welded a screw to one side instead, head inwards, and screwed a handle from a meat grinder to it.

We are yet to test this setup.

Push frame for Mercedes-Benz 207D

2012-06-26T00:00:00+03:00

Making one piece of custom supplementary hardware is never enough. I was talked into building this one, too, and it’s proven to be extremely useful.

Note that this is not a step-by-step how-to on building a push frame for your own MB 207D (or 307D, or any other). It’s more a description of the thinking and manufacturing process, with a few pitfalls mentioned. Same principles can be used for other vehicles. There are certainly other ways of achieving the same, better or worse.

And I can’t be held responsible if a ton of steel crushes someone because of something read online. Duh!

Grand plan

The issue is as follows: I need to move the van body. Sideways. Then turn it around 180° in a 6x6 meter area. Over and over again.

We first thought putting frames under each wheel, but decided against it for two reasons. First, I wouldn’t be able to remove neither the van’s wheels, nor the axles. Second, the small frame wheels, 16 of them, would cost too much. No, really. Their price is not proportional to size.

We reckoned there’s another approach: a frame for the entire body. It goes like this.

At the front, the radiator is mounted on a cross bar, which is attached to the chassis by eight M10 bolts. I have already removed the entire engine, so anything can be mounted using these screw holes. But here’s a picture from a long time ago, so you can understand what I’m writing about.

At the back, the tow bar can be removed, giving another eight holes, also M10.

Therefore, there are four stable mount points, where plates can be attached to the chassis. Weld four vertical “legs” to these plates – two at the front, two at the back. Weld these legs to cross bars with wheels at both ends. You’ve got yourself a minimal frame.

I started off by mocking up a drawing, then taking measurements. I kept revising as I progressed, and here’s the final version (rear at the top, front at the bottom, dimensions not to scale):

Notice there’s a few dimensions missing – most importantly, everything around the mount points. I’ve written them down on the plates themselves and forgot to put them in the drawing. Anyway, the spacing between bolts’ center-points are: 97x82 mm at the front, 69x46 mm at the back. Don’t trust me on this one, though, I’m from the Internet.

The spacing for wheel mount plates depends solely on the wheels you’ve got.

Attaching the frame to the chassis

I first manufactured these 4 plates. They’re made out of a steel strip 8 mm thick, 100 mm wide, 180/140 mm long for the front/back respectively. Nothing too precise here. What has to be precise is where you drill the holes. I went and checked immediately after.

The bolts are 30 mm long, but that’s not critical. They can be unnecessarily long and give one a pain in the ass when tightening the nuts, if such is the desired effect.

Here the bolts should be at least 80 mm long (not counting the head, of course). Note that there’s only about 5 cm of space on the other side, so the bolts can’t be inserted the other way around.

Wheel assembly

I then built two lower cross bars that the wheels attach to.

As mentioned, this depends mainly on the wheels on hand. I had four big ones, the specs say they can hold up to 500 kg each. The van’s body weighs about 500-700 kg, plus 100-200 kg for each axle – a total of 700-1100 kg, unevenly distributed.

We decided it would hold.

For the cross bar, I used 60x60x4 mm square pipe, because it felt solid enough. The van is about 1820 mm wide, so I cut my two pipe segments to that length, then cut two pieces of 40x6 mm strip for each wheel (a total of 8 strips).

40x4 mm would have worked just as well – the cross bar is 4 mm thick, after all, and if something broke under the weight, it would be the cross bar. But pwf, who went to the metal depot, wanted to prove they’ve got stuff that’s not available if you’re ordering online. So 40x6 mm it is.

Anyway, here’s a bottom view of the wheel mount. It’s pre-drilled and TIG-welded for alignment.

In cases like this, I would now rather weld it on with the wheels attached – less toying around with precise positioning.

Here’s the wheel assembly.

From 10 o’clock, clockwise: mount plates, rear and front; assembled wheel mounts, top and bottom views; disassembled wheel mount, exploded view.

Notice that the holes I drilled are not center-aligned. This, again, is solely due to the wheels I’m using.

To make these strips identical, I first drilled 4 mm center-holes in one piece, then used it as a template for the rest. This is standard practice. If the template is screwed, then everything is screwed, then I am screwed. So I was vewy-vewy-caweful.

After TIG-welding the strips to the cross bar, I stick-welded them, since this is faster and cheaper.

Legs

At this point, I had two fully assembled cross bars with wheels. Really dangerous to ride around the workshop.

I could measure their height, and how much the chassis mount plates protruded, so I could now decide how long my legs should be.

I jacked the van up and did that, then cut appropriate lengths off a 50x50x2 mm square pipe. This can be a lot thinner than the cross bar, since the main force applied is compression, not bending. Also, we had that as a leftover. And it doesn’t weigh too much, which at this point was starting to become an issue.

I also put in square pipes diagonally, to prevent the legs breaking off sideways.

Long story short, here’s how it looked at the back before I screwed it to the chassis.

I don’t particularly like how the legs are welded to the mount plates. I’d now rather have spent a lot of time cutting away slots, so one inserts into the other. Too late, Captain Hindsight.

Final touches

At the front, I had to put in some spacers for better vertical alignment.

At the back, it fit as planned.

The whole thing didn’t feel stable enough when I tried to push the van, so I screwed a segment of metal stairs to both parts of the frame lengthhwise, underneath the van. Call it a spine. You can see a part of it in the picture below.

The spine is removable and can be attached whether or not the axles are still in place. When I was sure the whole thing wouldn’t collapse, I removed the axles.

One day, I will gimp the frame out, and the van will levitate.

Plant watering alarm FIAL

2012-06-21T00:00:00+03:00

Update 2012-11-30 A new working vesion of plant watering alarm is available for sale! It’s open source and it goes Chirp!

Well, living together with a person comes with some responsibilities that are to be tackled. Like watering plants. My friend I’m sharing an apartment with was leaving for a couple of weeks and has burdened me with a task to take care of several pots with alien life forms. After i was finished with my pot-growing experiments long time ago, i didn’t care enough about plants and i didn’t expect myself to be out of nerd zone enough to be aware of this task as it’s not cyclic and depends on different external factors such as ambient humidity and temperature. So, i came up with a hi-tech solution: Plant watering alarm that would notice me in non-too-much-intrusive way that it’s time to take care of other species. After some simulation i was quick with a fully working prototype in the first go!

As currently I’m very much in analog electronics and i had heaps of free op amp samples lying around, i went with a fully analog solution as i like things to be as basic as possible.

The circuit works as follows:

Electrodes in earth act as a variable resistor, resistance of which depends on amount of water in soil, it forms a voltage divider with R5. While this voltage is above a voltage on non inverting input of op amp, created by R3, R2 and R1, nothing happens. When soil dries out, it’s resistance increases and voltage on inverting input falls below the threshold. Output of op amp swings to positive rail, lighting up a LED and making click in piezo beeper. Voltage on inverting input changes to another value, and C1 is charging up through R4 until it reaches that value. Then output of op amp goes low clicking a piezo buzzer once more, C1 discharges thruough R5 and the cycle repeats. In general it’s a relaxation oscillator with hysteresis set by R2 and R1.

Two days later after i woke up, I’ve heard a silent clicking, it’s time to water plants! Win!

As i have no job and still have no intentions to get one, i instantly saw dollar bills in it. I could make a product out of this and sell it to fellow geeks and whomever else, all i need is to make it battery operated and low on power consumption! I got these extremely low power op amps from TI - OPA379, with input high, the device was consuming 6 micro amps, it could work years on 3V lithium button cell battery!

Well, the devil was hiding not far away. The resistance of the soil in kilo-ohm range, i measured about 500K in extremely dry pot and 10K in freshly watered plant, this means, the main resistive divider would draw 60uA alone, it would drain the battery in 4 months and it’s unacceptable. I’ve had an idea about inverting input by putting a mega ohm resistor from VCC and connecting the plant to ground, buffering and amplifying the voltage by another op amp, but the electrodes in soil act as a battery too, producing ~40mV of voltage, which varies wildly on the type of soil, fertilizers and bunch of random stuff, so i had to scrap the idea. Maybe I’ll try it by measuring capacitance between electrodes. Well, back to microcontrollers…

Engine hoist boom extension for Mercedes-Benz 207D

2012-05-17T00:00:00+03:00

I’d like to work on the body of this van without fretting too much about getting sand in her… well, important places. Which means stripping everything, including the engine.

Taking it out on this model is pretty straightforward. Literally: unless the van is lifted and the front axle removed, the engine and transmission can only be removed in a straight horizontal trajectory.

The engine hoist we’ve got is made for light vehicles, where the engine is lifted out vertically. The hoist boom, when horizontal, is 20-30 cm too high in my case, and cannot be adjusted.

One could, of course, modify the hoist itself to be adjustable, but there’s a simpler solution: a purpose-built angled boom extension for a given van.

I started off by measuring the cross section of the original extension, which happened to be 60x60x4 mm. Got a meter of that.

Then took the hoist to the van, removed the original extension, lifted the boom slightly over the engine’s top line, and marked an angle. Inside the boom, this extension wanna-be o’ mine went slightly over the hydraulic jack.

Took the square pipe to the bench and cut at the marked line, then squared off the remainder by cutting out a triangle.

This piece came very handy for reinforcement.

The smaller square pipe is 30x30x4 mm, and there are two of them stacked in this side view. We reckoned smaller pipe would give more operating space in the engine bay. Two sections of approx. 60 cm were needed, and exactly two sections of approx. 60 cm were available (after I cut them off from longer pieces).

The engine here is an OM616, which has three suspension points. I took three big nuts and dropped them in an acid bath. Took ‘em out, dropped them in a lye bath. Took ‘em out, rinsed with water. These are improvised lugs.

After gathering the puzzle pieces, I handed them off to a professional welder friend (who happened to be procrastinating with a bottle of JD). Here’s what came back (this is not a shotgun):

Here’s how it looks attached to the boom:

A comparison of boom extensions, original and custom:

Notice how the new one looks a lot more sinister than the original. And no, that is not piss in the corner.

Finally, here it is engaged, doing what it does well:

Used carabiners for suspension here – chains would have been too constricting.

Ball joint separator, part two

2012-05-04T00:00:00+03:00

The very next day after this, I went and got myself a “proper” ball joint separator. It was the right thing – did the job in a matter of minutes. Didn’t even have the time to make tea.

The other end of the rod had a torn boot, so I took that off, too. Again, without tea.

Here’s how it looks.

The separator is made of pretty good steel, and the pushing screw has a ball joint of its own, to reduce friction while turning. If you intend to make one, take these factors into consideration.

Ball joint separator

2012-05-02T00:00:00+03:00

I’ve got this old Mercedes-Benz 207D camper minivan. It’s a proper minivan, owned in its better days by a bourgeois deutchlander. Which means it’s fit out for short summer trips, with crammed living quarters and half the back taken by a toilet room. The toilet itself, of course, is missing. No heater, no insulation.

Or at least it was like that, before I decided to tear it all up and re-purpose it for year-round van dwelling.

Removing everything down to the panels revealed some rust. so I decided to get to the metal frame, which revealed considerable rust, especially around aluminum rivets. Before you know it, the van has no windows, no dashboard, half the engine bay is stashed in boxes, and I’m struggling to separate the pitman arm from the tie rod. Not that there’s something wrong with the steering – I just need an empty metal shell to work with.

A few words on what I’m trying to do. Have you seen Sylvester Stallone in “Over the Top”? Then you’ve seen nothing. One can not just wrestle with a pitman arm. It is tough and made of steel. It is wedged in beyond any specs by righteous muffins. It is hammered in even more by every rock rolling on the road.

Therefore, one needs a ball joint separator.

And I could have gone and bought one, but decided to practice some TIG welding instead. I’ll need this skill anyway by the time I replace every rotten bit of the van.

The results, sadly, are negative. Maybe since it’s all made of scrap metal I found under the table. Here’s the first version:

The middle screw is the pusher rod. Two screws on the sides have flimsy grips. Turning the middle screw pushes on the ball joint finger, grips pull the pitman, and it comes off. Or such was my idea.

In reality, the grip screws bent sideways, their grabbing plates had bent, too, and nearly slipped off.

No biggie, replaced it with a single piece of 5 mm plate, cut out in a suitable shape, that attaches like so:

Looks a lot more solid, eh? It had bent, too. A little. I kept on pushing with a hand wrench, since the pneumatic would only hiss at this point, until the screw would turn no more, and the head snapped off:

Oh well. Pitman is strong. I’ll either have to further refine this thing – shorter, stronger screws, a metal ball from a bearing to reduce friction, and so on – or just scrap it and buy a “real” one.

Or maybe cover it all with a black bag and pretend it’s not there while I’m working on the body.

Volkswagen Passat B2 water pump pulley holder

2012-04-30T00:00:00+03:00

We all know the importance of changing engine belts regularly. The knowledge by itself, though, does not prevent them from evaporating on the highway.

This happened to a certain folks’ wagon we are acquainted with. Given the opportunity, we decided to change the whole lot: the power steering belt, the alternator belt, and the water pump belt.

The first one was easy, the second required some yoga, and the third seemed down right impossible to access without disassembling the front of the vehicle.

Or at least the water pump pulley. Which was held tight by three allen screws, which could not be unscrewed, because the pulley would rotate instead. It is, after all, a pulley – that’s what they do.

You know what our fathers would have done in this case. We surely didn’t, so we went online.

Long story short, we found special tools similar to this. Paying 30$, waiting for a week and using it twice didn’t sound exactly right. So various artists (who did most of what I’m describing) cut a similar shape from a piece of 2.5 mm sheet metal.

I can’t give the exact measurements, they’re somewhere in adude’s notebook, but the 3 holes are approx. 14 mm in diameter, set out about 22 mm from the center point. The middle has to be cut out for a firm grip on the pulley.

If you intend to make one, have 6 holes instead of 3. The reason here is the tool can only be turned 60° freely inside the engine compartment. The blueprints, though, might look like a zionist conspiracy.

dmx-dimmer ready for testing

2012-04-09T00:00:00+03:00

I’ll document the developments that happened since the previous post, mainly for historical purposes.

Power safety during prototyping

The power connector (screw terminals) on the slave board weren’t sturdy enough and would jiggle if wiggled. Then the prototype board got burned – for a whole different reason, though.

Lesson: power safety isn’t something to “implement later”.

Tips:

use terminals with paired pins for each connection, or connectors with metal casing that can be grounded;
if using stranded wires, at least tin them to prevent shorts;
have a fuse for each power user.

What’s 3D rendering good for?

If you’re wondering why would anyone want 3D rendering functionality in their EDA, just look an the lower side of the photo above. See that huge grey bulb? It’s a 1 mF electrolytic capacitor. I thought the SMD version was going to be small. And it was, compared to a through-hole. Still, a few millimeters too tall for this application.

Soldered it out, drilled a few holes, bent the pads into pins, and soldered it in on the other side.

Then, there were a few spacing issues, mainly with mount screw holes. I was too lazy to go looking for a footprint as trivial as this, and used vias with fat copper rings instead. The tolerances were too small, though, so screwheads ended up getting over tracks, connectors, everything.

Lesson: think about physical design, use 3D if available (KiCAD and EAGLE have it).

Stable dimming

I’ve previously had some issues with lamp flicker. Weirdly enough, it would disappear after connecting an oscilloscope. I still haven’t figured this out, by the way. Thought it was noise in power, ground or zero crossing, but debugging led nowhere. Frustrated, I decided to do some meditative code cleanup.

Which turned out to be a great idea. It showed that timer resetting was still being done in a software interrupt routine. This creates delays, since processor state has to be pushed onto the stack first. Resetting the timer in hardware (which I assumed I had been doing all along) fixed the issue and gave a nice homogeneous glow.

Lesson: don’t assume you’ve got things right, and check; also, don’t assume you’ve already checked; avoid infinite recursion.

Real men wind their own chokes

… mainly because they’re too expensive. The chokes, of course, not men.

Here’s one used in a dimmer module. It’s a ferrite toroid core with 2 mm wire wrapped around it. 2 mm diameter gives a 3.14 mm² cross section, which is slightly overkill, and definitely too tough to wind. I’d aim for 1 mm² per 10 A. Double-wound with thinner wire, perhaps, to ease the chore.

Module overview

Here lies dmx-dimmer, with one of each modules.

I’ve made two revisions of the power dimmer board, with different triacs. r0 was used during initial prototyping, to avoid running high currents through the breadboard. It doesn’t have a choke. r1 had some layout quirks, which made running a proper test (with a 2 kW fixture) impossible.

It also looks like a rat’s nest due to all the wires. Some were simply soldered to the board. Bad idea! Move the boards around too much – and they break. Leave them by the table’s edge – and they fall. A remarkable annoyance.

Lesson: don’t make a board unless you intend to test it any time soon.

Tips:

a triac is not symmetric, if it doesn’t trigger, you might have to swap its MT1 and MT2 connections;
soldered wire connections are not OK for prototyping.

Last notes

I have yet to measure power usage. And many other things. This will have to collect dust for a while, though – safely, inside a box. I packed it all up and went to do something entirely different. The updated designs are available at GitHub.

Strangely enough, I also stumbled upon Semitone Lighting Controllers, an open hardware project that’s been running since 2003. Somehow Google missed this last year. I would have just built a Semitone Diamond instead of doing all this!..

Lesson: don’t trust a search engine.

Cat heating pad

2012-04-01T00:00:00+03:00

Every human associated with a feline knows that these domestic animals find laptop computers highly valuable. Why do they find these machines so fascinating? Is it because of their intristic property to produce heat? Or is it because it appears to be a highly important asset as humans tend to spend a reasonable amount of time attached to these devices every day? We couldn’t simply ask our feline friend, as she was quite busy tending herself, we could only guess…

Well, fortunately we had some 0.2mm nichrome wire so we were able to make a quick prototype. By dropping 25 volts and having 130 Ohm resistance it was able to put out about 5W of heat. Well, actually our crappy power supply made from trash found on a street was not able to put out more.

We had some cardboard saved from some free samples of semiconductor devices sent to us by one nice company so we used that as a base for our device.

Alpha was not very impressed with our invention

You know the saying, cats don’t really give a fuck…

But maybe it’s not that bad after all…

Two days later - a WIN!

Copper plating

2012-03-26T00:00:00+03:00

Here’s what ioch was toying with last week.

It’s a copper-plated hard drive disc, still in the bath. It didn’t go particularly well, the thin copper film peeled off.

I have no interest in blogging other people’s stuff, so I’ll leave you with that: pretty pictures.

Control a motor from a lighting console

2012-03-04T00:00:00+02:00

A few months ago I was asked what it would take to drive a 3-phase AC induction motor from a lighting console. A specific variable frequency drive by Delta Electronics (VFD-L series) was provided. Coincidentally, miceuz was working on a variable frequency drive of his own, so a motor that fit the purpose just happened to be lying around.

So everything that had to be done was a translation from DMX512 (the console) to Modbus (the VFD).

I took my trusty Metaboard and meditated. Quite conveniently, both DMX512 and Modbus are RS485 protocols, so a 75176 interface chip for each is all the hardware that is needed. Here’s the schematic I drew then and fished out from under the desk now. The table on the left is for bookbinding signatures and absolutely unrelated.

Writing the code was pretty simple, since I took most of it from the DMX dimmer project of mine. Which is going slow and steady, thank you.

The rest, dealing with Modbus, required a skim through the VFD’s manual, and is pretty much hard-coded. I let myself do this, since the goal was to see if it can be done at all, and the finished thing needed only to have speed control, nothing else. A lot more is possible, though, with the mentioned VFD. If I had to do that, I’d probably go with FreeMODBUS, a library for a number of embedded architectures.

To simulate a lighting console, I used QLC (software) and ENTTEC’s DMX USB Pro (hardware). Keep in mind that if you want to use this setup on GNU/Linux, the former uses a not-invented-here approach to communicate with the latter, and you might need to blacklist the ftdi_sio kernel module.

Keeping the story short, after 6 hours of copying code around, I came up with this slackjob proof-of-concept to control an AC induction motor using DMX, taking a few givens for granted. Mind you, a VFD for industrial automation is quite more common (and, therefore, cheaper) than professional theatre special effects equipment that does the same thing.

The last move I made was film it all, once, on the first camera that happened about. Here it is, in all its pixelated, shaky, moory glory.

3-phase AC Induction otor Controlled Using DMX, on Youtube.

And yes, I do call that a workshop.

Repairing a Martin Atomic 3000 DMX strobe

2012-02-14T00:00:00+02:00

Fuse blows repeatedly

I got my dirty hands on this nice fixture, a Martin Atomic 3000 DMX stroboscope. What exactly happened to it is shrouded by mystery, since it happened too long ago for anyone to remember. Some facts, though, were relayed as follows:

something blew on the board, and high currents destroyed the original fuse;
there was no time to wait for a “replacement” or “inspection by a qualified technician” (as is quite often the case with important equipment);
someone obtained the relevant components, soldered them in and changed the fuse;
the strobe, however, kept misbehaving, blowing the fuse repeatedly;
as such, it was eventually shelved.

Here’s the part of PCB that took the damage:

It’s a spark gap!

Notice a few things, Dr. Watson:

how a few caps are molded on the top, a sign that someone was in a hurry or just didn’t bother to flatten the playing field;
how it is all centered around two resistors, R127 and R136.

A short browse gave a few threads with similar issues: one looking for a schematic and another asking for advice.

A schematic, indeed, is only available from Martin if you’ve passed some sort of ritualistic initiation. So I went on the internets’ underside and found it, and here’s the relevant part:

And oh Abyss, those two resistors, put butt-to-butt, form a spark gap between LINE and NEUTRAL!

The thing about light fixtures is that they’re often used indoors. Indoors is often poorly ventilated. There is a lot of dust, which gets everywhere, especially into spark gaps. I’ve seen dust inside stepper motors, too, between the bearings of ventilators, covering radiators and integrated circuits to the point they can’t be seen!.. The horror, the horror…

Anyway, there’s not a lot that can be done except for regular cleaning (yeah, right). I’m sure Martin has also fixed this in their later revisions of the PCB. After all, the one in question is way back from 2001.

I couldn’t have not indulged myself, though, in the following way:

Correct, it’s a bigger spark gap. I also changed the caps. And wiped off the rosin residue. The solderwork looks sloppier than it was before.

Ehm… Fuse?

Back to the issue at hand: why does it keep blowing the fuse? Well, it’s because not every fuse will do. You need a slow-blow fuse, says so in the manual. Martin can supply those for you, catalog number 05020040.

This is because the strobe draws up to 33 amperes at peaks, which happens when you run it in full-power mode with the blinder effect.

We’ve measured it with this:

It’s a current transformer and a meter. The good thing about this is it shows effective current through the wires, not some derivative. When the strobe runs in normal mode, it draws current in bursts, and modern meters that measure magnetic flux would show all kinds of weird, like jumping fast from -50mA to 50mA, with the amplitude ramping up, eventually to 150A. Which can’t be true.

Anyway, with this setup, we’ve measured that the device draws very little on average in normal mode, around 18A in half-power blinder mode and well over 30A in full-power blinder. Mind, though, that this doesn’t last for long, since thermal protection kicks in and decreases lamp glow intensity – by limiting current.

The ultra-high power mode, though, lasts for a few seconds, which is enough to blow a glass fuse, even if it’s slow-blow. But a ceramic one can tolerate this. According to the datasheet of the one we bought, at 200% of the ampere rating, minimum “opening time” is 5 seconds. Which is probably enough.

So much for this “failure mode”.

LPC1343 devboard, continued

2012-02-02T00:00:00+02:00

A few weeks passed, and the PCBs came. We went for minimum price, which means no electric testing and no masks. Therefore, no outlines for what to place where, or how to orient things; and a few misaligned vias – but they’re metalized properly, so what the heck.

Adafruit still quotes 15-20 days till stock.

By now, miceuz has noticed a few more things we could’ve changed. Like replacing the 3.15V supervisor (U3) and EEPROM (U4) with more common chips. Oh well.

Powering LEDs from mains

2012-01-29T00:00:00+02:00

…with as few components as possible. Sorry for the blur, it was dark.

Here’s a box ioch made. It has eight quality thumb switches for their reliable “clunk!” and four backlight LEDs, mainly for the flare. To power LEDs from the mains, though, you’d need a transformer. That’s bulky, expensive and unimaginative.

So what’s the smallest schematic one could have, if 50 Hz flicker was not a problem? John remembered seeing something like this on the internet (and I zoomed out as much as I possible to make it even smaller):

The components’ values were selected using an online circuit simulator. The resistor has to be rated for high power, and the capacitor for mains voltage.

dmx-dimmer introduction

2012-01-24T00:00:00+02:00

What’s this about?

I’ve started working on this project slightly more than a year ago, during winter. Why is a rather lengthy story. By June development was finished (almost), I shelved the thing, made a backup, picked up my backpack and headed outdoors, where fun was to be had.

What I’ve been doing all this time until now is another long story. Among other things, it involved working as an apprentice light engineer at a theatre. The dimmers there were 30 years old and took up a room ten times the size of our workshop. If I showed you the photos, you’d say it was fake, or at least crazy. The reason it’s still there after all these years is the upgrade cost.

Anyway, a few weeks ago I registered at GitHub and pushed the project there. Be warned, there’s a lot of turbulence. For example, at the time of writing, the firmware is a few commits behind the hardware – pinouts had to be changed on the Master board to keep things simple and allow homebrew manufacture. But I’m getting ahead of myself.

Wasn’t it already available?

Of course, I looked around before engaging in a project as big as this. And there’s a lot of schematics and open-source stuff available. Some are based on, you guessed it, Arduino. The closest to what I needed, though, was Hendrik Hölscher’s DMX dimmer.

But it uses a rather old AVR microcontroller, runs off single-phase, and can have no more than 8 channels. I need something with components that won’t disappear from the market too soon, something that uses three-phase mains power (but can use one or two if that’s desirable), and allows 12 channels, more if feasible.

Or so I thought up a year ago. Of course, now I see other, better ways of achieving the same. Yet, I’m too anxious to re-design, so this will have to go.

What will be inside?

All of it is organised in four types of modules.

A couple of status LEDs and an address switch are on the panel, available to the end-user. These settings and DMX512 data are received by a Master microcontroller, ATMega168, using SPI for the former and USART for the latter. The data is then distributed to three Slaves using SPI and a wacky scheme of SELECT/READY lines. These ensure the data goes where it has to, when it has to, and doesn’t get lost during time-critical interrupts. A Slave, ATTiny2313, receives its set of channel data, determines its controlled phase’s zero-crossing, and fires signals to actual dimmers, up to four of them. A dimmer opens a thyristor, which allows current to flow to the light fixture; a heavy-duty choke is involved, how heavy depends on the money or time one’s willing to spend.

At least that’s how it works right now. Tests were carried out using protoboards, and everything seemed fine. How well this scheme performs in real life, under the strain of real loads, is yet to be seen.

When will this be available?

I don’t know.

Currently, I have two other consuming projects. One of these I expect to post some time soon, too.

As mentioned before, the current state of affairs is always available on GitHub. So if anything goes wrong, at least it’s not lost forever.

Today, I’ve etched the Master board and started populating it. Then it turned out I didn’t have a 16 MHz crystal on hand – luckily, one could be easily raised from an old computer extension board. I didn’t have an 0805 120 Ohm resistor, too – and it seems these weren’t so widely used in the days of ISA. Oh well, off to the shop tomorrow. For now, enjoy this image:

By the way, I’ve used SMD soldering paste here. The expiration date says August, 2010. Works pretty fine, though. Only had to leak off water that separated.

Retarded power supply

2012-01-19T00:00:00+02:00

It was January 18th, 2012, the worldwide SOPA/PIPA protest day. We really wanted to watch a movie. A zombie apocalypse movie. But our test tweeters didn’t have a power adapter, which is probably the reason they ended up in a trashbin. It did have a power connector, but none of our adaptors fit.

Not quite an apocalyptic scenario, but still a distress.

We decided to make a brave dash and solder a pair of wires to where the battery holder is connected (because, believe me, in the face of overwhelming circumstances one never has batteries). Which, of course, didn’t work with a universal switched-mode power supply on the other end, since battery power wasn’t filtered on the PCB.

So we had to bring in another soundsystem. A couple of bigger speakers and an amp. Desperate times call for et cetera.

Next day, though, ioch took a NOKAI phone charger, soldered it to the board, and added a big cap for good measure. I’d post a video of how well it works, but I’d have to put in on YouTube, and doing so might become verboten.

Next week: microwave popcorn and beer in Coca-Cola bottles.

Modifying the LPC1343 devboard

2012-01-17T00:00:00+02:00

We’ve been working with Atmel AVRs for quite some time now. All in all, it’s a nice architecture, and I can’t really remember why we decided to try out ARMs, and specifically this Cortex-M3 chip. Maybe it’s their built-in USB bootloader. Or their lower price. Or higher processing power.

Anyway, microBuilder’s LPC1343 devboard looked like just the thing, jumped to Adafruit to order some, and… it was out of stock! And wouldn’t be available for some time.

Luckily, a few of these chips just happened to be lying around, and the board designs are available. Not so for all the components, though – specifically, the 12 MHz crystal. Which wasn’t hard to replace. Yet, after a few tries to re-route for homebrew manufacture, it became evident there’d be one via too many if one wanted to keep the nice GPIO layout. So it had to be shipped to a PCB manufacturer.

Perhaps this won’t be faster than Adafruit, but at least it’ll be cheaper. Thanks to the fact it’s all open-source (or whatchamacallit). In case you’re interested, here’s the modified version at GitHub.