Category: Uncategorized

Step 2:

---

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

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.

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.

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.

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.

Here is an easy way to start a program for a Raspberry Pi with a Graphical User Interface automatically on boot up.

We’re assuming you are using a recent distro like Raspbian Buster. The autostart folder under ~/.config is where the file goes. The command file format to start your program is:

[Desktop Entry]
Type=Application
Name=HelloWorld
Exec=/usr/bin/python ~/hello.py

Save this file in the autostart folder and call it hello.desktop. This will start a simple “HelloWorld” type program (hello.py) written in Python with a Tkinter GUI framework. It’s probably as simple as it can get.

If you need to run Python under lighttpd, there’s a good tutorial over here.

---

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

OK, so this wasn’t the first experiment but it was the first one I recorded. I’ve wanted to build a stable platform for years, but finally had a reason to do so. The design uses the common MPU-6050 in DMP mode so its internal CPU handles all sensor fusion. I used an excellent MPU6050 library to handle all the interfacing and a small gear motor to move the platform. The whole thing now runs on a basic proportional control and it’s amazingly responsive.Here’s a quick look: https://www.youtube.com/watch?v=Ezwf3kFpk7c

---

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