All posts by laker

Why am I still doing this?

I get asked sometimes why I do this. I’ve been an engineer for 30 years and programming embedded systems for most of that time. Sure, I’ve taken occasional side-treks into building a mobile app here and there. I’ve built a couple of web applications, including a pretty complex one for managing gym workouts, but I keep coming back to Embedded.

Why?

It’s FUN, that’s why. I love writing code that makes things move, or turning little (or huge) blinky lights on and off. I like to regale people with the stories of the times something caught fire, or the weird bug where the machine would “fix” itself, or how we almost had a massive recall due to some obscure failure that only raised its head years after a machine was in the field.

Embedded systems are fun to write (yeah, I’m deliberately ignoring the nights of frustration searching for some apparently random failure) and the end results are usually something you can actually put your hands on.

Try that with your React frontend!




If you'd like to subscribe to this blog, please click here.

Basic wire crimping for arduino users

I keep posting information on crimpers and crimping, so I’m just going to put this here so I can refer to it without having to type it all in again 🙂

Crimping is a far more specialized and precise operation than it appears at first glance.

First, you need good quality tooling. Crimp dies have to be made specifically for the terminal to work ideally and wire length and wire insulation thickness are critical. That said, I have had fairly good luck with some cheap crimpers, but it’s hit and miss.

If you find that you’re having to “pre-crimp” anything before you can get the terminal into the die, then that’s a problem. That suggests that the die you have is not made for that terminal. Likewise, if the wires are slipping out. A good crimp cold welds the wire to the terminal and should require pounds of force (at least a firm pull) before the wire pulls out.

The basic technique is to put the terminal into the die and squeeze the crimper just enough to hold it in place. Next, put the stripped wire into the terminal, making sure it’s at the right depth and that the insulation ends at the right spot.

Then squeeze until the crimper completely closes and the ratchet releases so you can open it again. Inspect the crimp (the book I link below shows what various crimps should look like), and pull gently on the wire, holding the terminal in your other hand. A crimp for wire around 26-22gage should withstand at least a 5-lb pull, ideally a lot more, before it separates.

This book has everything you need to know about crimping and more.
Molex/TE Connectivity actually has a shorter book with good tips about crimping, but I can’t find it online at the moment.




If you'd like to subscribe to this blog, please click here.

Single Slope Integration ADC for Arduino

Occasionally you might end up in a situation where your Arduino project need to measure an analog voltage such as a thermistor or a resistance change, but all your analog inputs are in use.

Now, in this situation I would pretty much always suggest you purchase an external Analog to Digital (A/D) breakout board because they are so cheap and precise these days. But what if for some reason you can’t? Maybe you have to get this project done before one can arrive or you hit your budget limit, or, or… whatever.

There’s a very simple technique to read some analog values that you can use when all you have available are digital inputs. I won’t go into the general theory behind analog to digital conversion since there are many good ones online already. However, I will briefly talk about Single Slope Integration.

Single slope integration is a method of measuring a voltage by timing how long it takes that voltage to charge a capacitor in an R-C circuit. An R-C circuit is basically a circuit consisting of a single resistor and a single capacitor. You might remember that the voltage across the terminals of a capacitor takes time to build up. That instantaneous voltage is a function of the incoming voltage, the amount of capacitance, the resistance of the circuit and how long it’s been since the incoming voltage was applied. This last part is the bit we most care about. If we know that the capacitor is fully discharged, and we apply a fixed voltage to the input of the circuit, then the amount of time it takes that voltage to get to a specific threshold at the circuit output is a measure of the resistance value. In other words, if we keep the applied voltage constant, the capacitor value constant and the threshold constant, then the only variables are Time and the Resistance. So by measuring Time, we know resistance.

We’re going to look at an application of this technique as it was used years ago. For reference, this is how the joysticks on the original IBM PC (vintage early 80’s) worked. That should tell you how long it’s been around.

Now, before I go any further, I want to emphasize that the way we’re approaching this is not a precision measurement by any means. There are methods to make this measurement very accurate, but they generally will incur more cost than, you know, just buying an A/D breakout!

This is our circuit:

R1 is the resistance we want to get a relative value for, R2 is there to prevent damage to the Arduino pin when it tries to either charge or discharge the capacitor (a discharged capacitor looks like a dead short, so we want to limit the current going out the pin), and C1 is our capacitor. With the values shown, we should get roughly 10-bit resolution measuring a 10k ohm variable resistor.

// Simple program to illustrate reading a resistor by using a single-slope
// integration method

// Pin 2 is used as our "analog input"
// Connect R2 here
#define ANALOG_PIN 2

void setup() 
{
  Serial.begin(115200);
  Serial.println("Ready");
}

void loop() 
{
    // Start a reading
    pinMode(ANALOG_PIN, OUTPUT);
	// Discharge capacitor
    digitalWrite(ANALOG_PIN, LOW);
	// Wait for it to discharge
    delay(500);
    
	// Snapshot the start of charging
    unsigned long start = micros();

	// Use 500,000us as our timeout so this 
	// doesn't hang if the resistor is disconnected
    unsigned long timeout = start + 500000;
    unsigned convEnd = 0;
	
	// Switch the pin to input so we can look for the
	// transition from LOW to HIGH
    pinMode(ANALOG_PIN, INPUT);
	
    while (convEnd = micros() < timeout)
    {
      if (digitalRead(ANALOG_PIN) == HIGH)
      {
		  // Threshold reached, exit
          break;
      }
    }
    
	// Resistance value is a function of the time it took
	Serial.print("Value read: ");
	// Print value read or timeout
	convEnd != timeout ? Serial.println(convEnd - start) : Serial.println("TIMED OUT");
}

So the way this works is first we discharge the capacitor through the 100 ohm resistor on pin 2. The resistor is there to limit the current and not damage the arduino. After giving it 500mS to discharge, which is plenty, now we switch the pin configuration to Input and monitor it waiting for it to transition from LOW to HIGH. At this time, we break out of the loop and report the time difference between start and conversion end. This is proportional to resistance.

For better performance, you can calibrate the software by using two known-value resistors in place of R1 to measure a min and max conversion time. Once you have that, you can interpolate between those values to measure any unknown resistor value.




If you'd like to subscribe to this blog, please click here.

connect NV9 bill acceptor to your pc

Bill acceptors and coin acceptors are used to take cash payments. They work by detecting certain denominations of bills or coins and provide an output signal that can be read by a computer. This allows your software to take cash payments. We’ve had a few inquiries from owners of the popular NV9 bill acceptor and how it can be interfaces using our counter systems.

This is a quick note for those using the NV9 bill acceptor. As we mentioned in an earlier post, our PRT232 or IOCTL counters can give your PC the ability to record the cash value of bills inserted into a bill validator. Recall that the IOCTL232 is the same as the PRT232 but without an enclosure and at a lower cost. With the NV9 bill validator specifically, pins 1 & 16 on the main interface connector are used for the connection to the PRT232 “sensor” connector. Pin 16 is ground and pin 1 is the open-collector pulse output.

The pulses are delivered at a rate of about 10 per second, which is well within the counting speed we support. The dollar values are sent as 1 pulse per dollar, e.g., a $1 bill produces one pulse, a $50 produces 50 pulses and so on.




If you'd like to subscribe to this blog, please click here.

High speed counter and Encoder reader

We are getting ready to release a new high speed counter that greatly simplifies machine to PC connections. 

Feature set:

  • Read quadrature encoder pulses at up to a 20MHz rate.
  • Single-ended or differential pulse inputs.
  • USB data output provides count to USB or encoder to USB output.
  • USB connection for configuration.

The device implements USB counter that is significantly faster than our existing ones and it is still compatible with the existing software interface.
This counter has a maximum input pulse rate of 20MHz and will accept either a “standard” or Gray-code mode used for interfacing with quadrature encoders. You can now get a high speed quadrature encoder input read from your PC’s USB port. This new high speed interface is available in a choice of DIN-rail mount or standard wall/desktop mounting enclosure.

Click the link below to be notified when the interface is available for the introductory $125 pricing. This price is only available for pre-orders.




If you'd like to subscribe to this blog, please click here.

Arduino flickering LED

I wrote this a long time ago for someone who disappeared. Hope it’s useful to you.

int ledPin1 = 9;
int ledPin2 = 10;
int ledPin3 = 11;

#define THRESHOLD 90
#define FLICKER 250
#define OFFSET 5;
#define DLY 100

int _levels[] = {0,0,15,10,15,20,25,30,50,75,100,500,700,1000};

void setup()
{
}

void loop() 
{
    int len = sizeof(_levels)/sizeof(int);
    int level1 = _levels[random(len-1)];
    
    analogWrite(ledPin1, level1);
    if (level1 > THRESHOLD)
    {
 //      analogWrite(ledPin2, random(FLICKER));
    }
    else
    {
  //      analogWrite(ledPin2, 5);
    }
    
    //analogWrite(ledPin3, random(FLICKER)+OFFSET);
    delay(random(DLY));
}



If you'd like to subscribe to this blog, please click here.

Sensor for detecting thin lines

A few months ago I was asked to build a custom counter. I get that request fairly often, but this one was different. The thing that needed to be counted was the transition of a thin line past the sensor. The feature to be counted was about 0.5mm thick. It was a black line on a yellow background so at least the contrast was pretty good. Since the counter needed to be portable and could not be attached to the equipment containing the feature to be counted, we figured that a way to visually align the sensor to the line was best. This meant that the sensor would emit visible light, so it would be possible to see when the light was in the right spot.

Since a 0.5 thin line is in the realm of barcode line decoding, I looked for sensors used in barcode readers. Problem is, that they are rarely specified that way. All I could find were 2D barcode sensors/cameras and those were overkill for my purpose. Oh, well!

So I figured that what made the most sense was a sensor with a small field of view. That way it could provide the highest signal to noise ratio (SNR).

I tried a number of sensors but the one that offered the best performance was the Optek OPB70DWZ. Having a red LED meant it was easy to tell when it was correctly positioned to “see” the feature. We found that the optimal distance from sensor to object was about 4mm. At that distance it worked quite reliably. The sensor was biased with a 4.7k ohm resistor to +5V. I found that by varying the bias, I could affect the sensitivity and adjust it for best SNR.

The counter itself had some logic to control the machine whose behavior was being counted, and it also required a display to show the count and to indicate what the current machine state was, so I did not use one of our existing RS232 counters. Instead I created a custom application based on an Arduino Nano and it’s worked quite well. The customer appears quite pleased with its performance.

The usual disclaimer: we’re not affiliated with Optek, but very happy with the performance. I’m posting this here because when looking for an optical sensor that could detect very small features or lines, nothing useful was returned from my searches. Hopefully this helps someone in the future.




If you'd like to subscribe to this blog, please click here.

Make your prop move

You build this really cool prop. After days, weeks, months of work, it’s done. Just one more thing: it would be so cool if that little bit on top could rotate. But how do you do that? You know motors make things move but you don’t know the first thing about motors. That’s where I come in: I know a fair amount of motors (but I don’t know a whole lot about building great-looking props…).

OK, now what?

To make something move, we need a motor. Here’s a simple one to get started with.

OK, that’s actually two motors. They’re pretty cheap, so why just get one? I’m not going to post links since they’ll be outdated in seconds, but you can generally find these motors for under $5.00 each all over the web. Search “small gearmotor” and you’ll get tons of hits. These are DC gearmotors. “DC” refers to the fact that they run on Direct Current, such as what you get from a battery, as opposed to AC which is what comes from a wall outlet. A gearmotor is a type of motor that contains a gearbox. Normally, motors spin at pretty high speeds: thousands of rotations per minute(RPMs). With the embedded gearbox, we get a more useful rotation rate that’s generally between 15-100 RPM. Slower or faster speeds are available. The ones above has two output shafts that provide around 140 RPM.

OK. I’ll post one link: these guys will probably be selling them for a while

Now, any motor needs a power source. The sample ones above are small enough that they can be battery powered. Three AA’s will run them for quite a while.

An important feature of DC motors is that their speed depends on the voltage you give them. If you run these from four AA’s they will run faster than if you ran them from two. Normally, they take 4.5 Volts, which is what you would get from the three AA’s mentioned above. If you want them to run all the time, or just don’t want to be bothered replacing batteries, you can also run them from a 5V “wall wart” power supply.

Once we have the motor and a power source, it might be nice to have an easy way to control it. This is where a switch comes in. It completes or breaks the circuit between motor and power and so turns the motor on or off.

So let’s put this all together. You know what this needs? A drawing. Drawings that electrical engineers use to show connections are called schematic diagrams. Here’s what it looks like.

As you can see there are the three elements we talked about: the battery for power supply, a motor, and a switch to turn it on and off. Look at the symbol for a switch: it shows that the contacts (1&2) are not touching. This means that the circuit is incomplete and current will not flow. When the switch is closed by pushing the shiny arm on top, those contacts will touch and complete the circuit, causing current to flow through the motor and making it move.

Enough for now? Next time we’ll wire up actual components and see how that goes.




If you'd like to subscribe to this blog, please click here.

PCB Assembly Tips

I recently posted this on Reddit, but after feedback I figured it would be useful here also. Over the years, I’ve accumulated some knowledge about assembling Printed Circuit Boards (PCBs) and it never occurred to me that everyone hasn’t gone through the same school of hard knocks that I have. So here are a few tips when assembling boards.

Here are some of the things I learned over time:

  • Use a stencil if you aren’t already. OSH Stencils makes good quality Mylar stencils at pretty low cost. The time saving versus dispensing solder paste with a syringe is huge.
  • As much as possible, simplify access to the bare components. By this I mean, adjust for how you pick them up. I pick up ICs with a basic vacuum tool, so I keep them in the trays they came in. The resistors/capacitors I pick up with tweezers (my cheapo vacuum pickup doesn’t do so well with small parts), so those are in bulk containers. LEDs are in their tapes, with the polarity clearly marked. The little time-saving details add up.
  • Through-hole components: insert/solder them based on height. Place the lowest-height parts first, otherwise it’s too hard to hold them in place upside down. I use a piece of foam to hold them in place while I solder.
  • It helps to put down extra flux before you place an IC with very close pin spacing like a TQFP part. The flux will help it self-align during reflow and makes solder bridges less likely.
  • If you’re doing multiple boards, it’s faster to place the same part on all boards at once. i.e., making 10 boards: place U1 on all of them, then U2, then R1, R2, then R3, etc. The repetitive motion saves time because muscle memory sets in.
  • Make sure you have assembly costs built into your product before farming out the assembly. I know this sounds obvious, but it’s amazing how many people forget about details like this and end up losing money overall. A good rule of thumb is that your product should sell for 3-5x the Cost of Goods Sold (COGS), which includes assembly cost.



If you'd like to subscribe to this blog, please click here.