Arduino Programming: Cycle timer

Sometimes you want an operation to repeat periodically. Say you are building a parts washer that circulates cleaning fluid around the dirty parts. The cleaning cycle might run for an hour and in that time you want the circulation pump to run for 10 seconds, stop for 5 seconds for particles to settle, then run for 10 seconds and repeat for an hour.

We need a timer. The type of timer that does this is called a Cycle Timer because it repeats a specific timing cycle and it’s pretty easy to build a cycle timer with an Arduino and a little bit of software programming. We’ll need an Arduino (any kind, from any manufacturer will work), a power supply, the power driver circuit, and the “load” which in this case is our pump.

Let’s get started.

// Which pin to use to control the load const int OUTPUT_PIN = 1; 
// Total number of cycles 
const int NUMBER_OF_CYCLES = 10; 
// On time per cycle in milliseconds 
const int CYCLE_TIME_ON = 500; 
// Off time per cycle in milliseconds 
const int CYCLE_TIME_OFF = 200; 

void setup() 
{
 pinMode(OUTPUT_PIN, OUTPUT);
 digitalWrite(OUTPUT_PIN, LOW);
} 

// Run the timer 
void loop() 
{
 int cycles = NUMBER_OF_CYCLES;
 while(cycles-- > 0)
 {
    // Turned timed output on
   digitalWrite(OUTPUT_PIN, HIGH);
   delay(CYCLE_TIME_ON);
   // Turn timed output off
   digitalWrite(OUTPUT_PIN, LOW);
   delay(CYCLE_TIME_OFF);
 }
 // Hold forever
 while(1);
}

Measuring water flow

A flow meter is the sensor that is used to measure water flow, or the flow of a low-viscosity fluid. There are many different types of flowmeters, but perhaps the most common are turbine or paddlewheel types. In these types of flow meters, a blade spins from the force of the moving fluid. The rotation is detected by a sensor that generates pulses that can be counted by a reader interface.

Older flow meters such as fuel pulsers used a rotating magnet that pulled a tiny reed switch causing the switch contacts to close. Every contact closure results in a pulse at the input of the reader, leading to these flowmeters being called pulsers. There are still thousands of these devices in use.

More modern pulsers and flow meters of all types like the one shown below generate their pulses electronically, often using Hall-Effect sensors that, again, respond to a moving magnet that is spun by a turbine or a paddlewheel.

flow

Now that we have a flowmeter device that can give a pulse output rate that is proportional to the rate that the water or other liquid is flowing at, we need to measure it. The reading device is basically a counter that is calibrated to the pulse rate.

For example, a fuel flowmeter may output 10 pulses per gallon of fuel dispensed, or a flowmeter used for water provides 100 pulses per liter. The reader must understand this calibration so it can display the correct value.

In many cases, the need is to read the flow and record or process the data on a desktop computer. Serial interfaces, RS232 or RS485 and USB are common here. By using a serial port flow meter interface, getting the data into the PC for software processing is a simple task since all modern programming platforms provide some form of serial data communication. Once the data can be received by your software, then you may record it, create graphs, log flow over time, etc.

Cedar Lake Instruments’s PRT232 flow meter interface is a serial port counter flowmeter reader that can measure and record flow. It reads pulser type flow meters, and can switch solenoid valves or pumps to control fluid flow.

Arduino Programming: Turn water on with Arduino and solenoid valve

Arduinos are popular small microcontroller boards that have many applications. However, they’re not designed to switch loads above a few milliamps: say a couple LEDs or so. While power-driver shields do provide this capability, they also can consume more resources than you may be able to give up.

We developed a high current driver to make it easy to control a solenoid valves with Arduino. It will also control pumps and motors. With an adapter cable, it can easily connect to your Arduino, BeagleBone, Raspberry Pi or other digital controller without soldering or crimping any connections. Doesn’t get any easier than that.

PwrDrvr1

The power driver board was born out of a need for controlling a 1 amp solenoid valve using an Arduino.  The solenoid valve was being used to control the water flow to fill a tank automatically. Now there’s a simple way to use your Arduino or compatible to switch up to 3A at 24VDC. Two output connections (the white wires shown above) connect directly the load (your solenoid, relay, motor, etc) and the power (red, black) go to the power supply (5 -24 volts). The orange lead is used to switch on and off. This is a low-voltage (5V) control that can connect directly to a microcontroller, or development board. An onboard LED indicates when the load is switched on.

Here’s some sample code that implements a timer with an Arduino. When the pushbutton is pressed, it turns on water flow for 3 seconds

// This sketch demonstrates a simple timer
// A load (motor, solenoid, relay, solenoid valve is on Pin 1
// A pushbutton to trigger the timer start is on pin 2
//
// When the pushbutton is held down for more than 0.1 second 
// then released, the timer starts
// and times out after 3 seconds
//
// Timer is retriggerable: if pushbutton pressed 
// during the timeout period, timer restarts
//
// Constant definitions
#define LOOP_INTERVAL 10
#define TIMEOUT 300 * LOOP_INTERVAL
#define TRIGGER_INTERVALS 10
#define TIMER_INACTIVE -1
#define TRIGGER_PIN 0
#define OUTPUT_PIN 1

void setup()
{
  pinMode(OUTPUT_PIN, OUTPUT);
  pinMode(TRIGGER_PIN, INPUT_PULLUP);
}

void loop()
{
  static int count = 0;
  static int timer = TIMER_INACTIVE;
  // Process loop periodically
  delay(LOOP_INTERVAL);
  
  // Check trigger input
  if (digitalRead(TRIGGER_PIN) == LOW)
  {
    // Must hold down pushbutton for the entire interval and 
    // then release to trigger
    count++;
  }
  else
  {
    // push button released. Check if we should start timing
    if (count >= TRIGGER_INTERVALS)
    {
      // Turn output ON (timeout is retriggerable)
      digitalWrite(OUTPUT_PIN, HIGH);
      timer = TIMEOUT;
    }
    count = 0;
  }
  
  // If timer active, count down
  if (timer != TIMER_INACTIVE)
  {
    timer -= LOOP_INTERVAL;
    if (timer == 0)
    {
      // Turn output OFF
      digitalWrite(OUTPUT_PIN, LOW);
      timer = TIMER_INACTIVE;
    }
  }
}      

Let’s find out what new applications you can come up with.

Power Driver ($11.95 shipping included)




Reading temperature on BeagleBone with AD592

A very common task is to measure temperature at various points. In fact, temperature is the most commonly measured and controlled variable in Process Control. The BeagleBone single-board computer is becoming more popular because of its low cost and sophisticated capabilities. It’s one of the easiest ways to serve up a web page that allows the operator to monitor data and control devices.

Temperature can be measured with a variety of sensors. Here we are concerned with the range of liquids from around 0C to 80C. A straightforward way to measure temperatures in this range is with a semiconductor analog-output sensor. They are easy to use, accurate, and low cost.

I happened to have a number of AD592 temperature to current sensors on hand. These have been traditionally used for process control because their current output makes them very noise resistant when long cable are used. We convert the current (1 microvolt/Kelvin) to a voltage by using a resistor. In this case, we use a 3.3kohm resistor to produce a voltage of around 1V at room temperature. The 3.3k resistor gives a resolution of .003V/Kelvin which with the 273.15K offset gives 0.003V/degree Celsius.

Using the sensor connected to 5V, AGND and the analog input on P9, pin 36, we use this code snippet to read the sensor:

// Read an AD592 temp sensor and return degF
function readTemp()
{
   var volts = 1.8 * trap.analogRead("P9_36");
   // Convert to Kelvin. AD592 outputs 1uV/K
   var k = volts / 3300 / 0.000001;
   // Convert to Fahrenheit
   var f= (k - 273.15) * 9 / 5 + 32;
   // Log the measured values
   console.log("V,k,F: " + volts,k,f);
   return f;
}

For improved accuracy we can measure the actual resistance of the 3.3k resistor and use that measured value in the program.

This concept is easily extended to remote reading. Since the BeagleBone is a powerful little Linux computer, it can be used to serve web pages. We have a simple node.js webserver and sensor data reader program available at this download link

Arduino Programming: hydraulic shock control from pushbutton

This was a response to an online request for help with code. A single  pushbutton cycles through three hydraulic damper valve settings. The code was too long to post on the site, so I’m showing it here.

As of today, I don’t know if it will work, but it explains the concept. I will get it working as time permits

// Digital output definitions
#define RED_OUTPUT 0
#define BLUE_OUTPUT 1
#define GREEN_OUTPUT 2

// Digital input definitions
#define SWITCH_INPUT 3

// Define states
#define RED 800
#define BLUE 801
#define GREEN 802

// Define message types
#define NONE 901
#define CLICK 902
#define PRESS 903
   
// Global state
int _state = GREEN;

// One-time call to initialize system
void setup()
{
   pinMode(SWITCH_INPUT, INPUT_PULLUP);
   pinMode(RED_OUTPUT, OUTPUT);
   pinMode(BLUE_OUTPUT, OUTPUT);
   pinMode(GREEN_OUTPUT, OUTPUT);
   // Enable GREEN state
   digitalWrite(GREEN_OUTPUT, HIGH);
}

// Continuously called by Arduino runtime
void loop()
{
   // Read pushbutton
   int message = readSwitch();
   // Update LEDs and hydraulic valve if state changed
   if (processState(message))
   {
      activateOutput(_state);
   }
}

// Read pushbutton and return the result
int readSwitch()
{
   const int CLICK_UPPER_LIMIT = 200;
   const int CLICK_LOWER_LIMIT = 25;
   const int PRESS_LOWER_LIMIT = 1000;
   const int PRESS_UPPER_LIMIT = 2000;

   int switchMessage = NONE;
   unsigned long start = micros();
   while (digitalRead(SWITCH_INPUT) == LOW);
   unsigned long duration = micros() - start;
   if (duration < CLICK_UPPER_LIMIT && duration > CLICK_LOWER_LIMIT)
   {
      switchMessage = CLICK;
   }
   else if (duration > PRESS_LOWER_LIMIT && duration < PRESS_UPPER_LIMIT)
   {
      switchMessage = PRESS;
   }
   return switchMessage;
}

bool processState(int message)
{
   static int lastState = GREEN;
   int retVal = 0;

   // PRESS overrides CLICK in all states
   if (message == PRESS)
   {
      _state = GREEN;
   }
   else
   {
      // Process states
      switch (_state)
      {
         case RED:
            if (message == CLICK)
            {
               _state = BLUE;
            }
         break;
            
         case BLUE:
            if (message == CLICK)
            {
               _state = RED;
            }
         break;
            
         case GREEN:
            if (message == CLICK)
            {
               _state = RED;
            }
         break;
            
         default:
         break;
      }
   }
   // Did state change?
   retVal = (lastState == _state);
   // Remember this state
   lastState = _state;
   // Return state changed information
   return retVal;
}

void activateOutput(int thisState)
{
   // Since this is only called on state change, OK to turn everything off first
   digitalWrite(RED_OUTPUT, LOW);
   digitalWrite(GREEN_OUTPUT, LOW);
   digitalWrite(BLUE_OUTPUT, LOW);
   // Turn on only the output corresponding to the state
   switch (thisState)
   {
       case RED:
         digitalWrite(RED_OUTPUT, HIGH);
         break;         
       case BLUE:
         digitalWrite(BLUE_OUTPUT, HIGH);
         break;      
       case GREEN:
         digitalWrite(GREEN_OUTPUT, HIGH);
         break;
      default:
         break;
   }   
}

Control a small DC pump

In an earlier post I showed how to wire a small DC pump to a power supply and a switch to turn it on and off. Even with simple manual control, there are still things to be aware of. Let’s say that you are building a small aquaponic or hydroponic system and you need a pump to circulate nutrient fluid to the plant roots. This is a situation where the pump only needs simple on/off control and can be left to run continuously.

There is a danger that over time the liquid will evaporate and its level will drop too low. Many liquid pumps cannot safely be run dry. This is because they are designed to use the liquid flowing through to cool them to a normal operating temperature. Without a continuous fluid flow, the motor will overheat.

This means we have to be aware of the liquid level. A float switch level sensor can be used in the control circuit to make sure that the pump does not run when the liquid is below a certain level. Most liquid level switches can’t control the current needed to run a pump so we use the switch to control a relay that has this needed current capacity.

It’s also important to remember that some pumps also have a maximum on-time rating. The pump may be able to run only (e.g.,) one minute continuously before it needs to be turned off to cool for three minutes. This proportional on/off time is referred to as its duty cycle.

Wiring a small DC pump

Using low voltage DC pumps is a safer way to become involved in flow control. Direct Current (DC) is generally simpler to control than Alternating Current (AC) and the low voltages are much safer than the 120 volts AC coming out of a wall outlet.

Your DC pump will have two leads and the proper polarity must be observed. That means that the positive and negative connections must not be swapped. DC pumps come in two styles: brushed and brushless. Most newer pumps are brushless. A primary advantage of a brushless motor is that it is normally quieter and generates less electrical interference. However, because the motor generally incorporates an electronic controller, it can be damaged if the power leads are reversed. So be careful. By contrast, reversing the power leads on a brushed motor pump will usually only cause the pump to not run properly (the motor will run backwards), but not cause damage.

To power the motor a source of DC at the proper voltage and supplying enough current is needed. Often this can be as simple as a “wall wart.”

wart-smallMore reliable industrial power supplies are also available. Use a power supply that can provide at least as much current as your pump needs. A greater current capacity is not a problem. This means that if, for example, your pump is rated 12VDC @ 0.5A, a 12VDC power supply with 10A capacity is perfectly safe. However a 24VDC supply rated for 0.5A may cause the motor to run too hot and eventually burn up.

You will also need a method to turn the motor on and off. Most small low voltage DC pumps can be controlled directly from a switch.

toggle-small    It is a good idea to use a fuse inline with larger pumps (2A+). This way, if the pump jams due to debris, etc. in the line, it will blow the fuse instead of damaging itself due to overheating

Why RS-232 serial?

Why do we use RS232 serial ports to communicate with our hardware? Well, first and foremost, it is probably the least-common-denominator communication method in the industrial and embedded physical computing arena. If a computer has just one port, odds are it’s a serial port. This is mainly because serial ports are so easy to implement.

Those computers that don’t have RS232 serial ports, will usually have USB (another serial bus) ports. Because of the decades-long history of RS232, USB to RS232 ports are easy to find. Nothing wrong with USB, but it has more complexity and is limited to fairly short distances.

So, in a nutshell, RS232 serial ports are easy to work with, ubiquitous and reliable.

Detecting when water flow stops

Flowmeters are used to measure liquid flow. However, if you only need a notification that flow is present or not and don’t need to know the quantity of liquid, there are simpler methods.

A flow switch is an on/off device that will indicate whether or not a liquid is moving. They can be either Normally Open (NO), meaning that the switch is not conducting when there is no flow, or Normally Closed (NC) meaning that the switch is conducting when there is no flow. Having both types available offers flexibility to a design. One of the nice things about a flow switch is that is is very simple to build a visual indicator of whether the liquid is flowing or not. By using a light (bulb or LED) or a buzzer and a flow switch you can build a simple low flow alarm.

They are available in various pressure ratings that set the threshold of flow/no flow.

Flow switches generally present less resistance to flow than a flow meter, so there is less pressure loss across the switch.

As with flowmeters, our PRT232 is an easy way to read a flow switch and get an indication of fluid flow into your PC via an RS232 serial connection.

More on LEDs

The post on how to (light an LED from an RS232 serial port) got more interest than I expected. There is an old design that I played around with a couple years ago for a high-power RS232 serial port LED light that I am thinking of resurrecting. It’s so bright, it hurts to look directly into it! A USB version might also be nice, but RS232 has a great advantage in distance and most of the people we talk with need something more rugged than USB. You can run serial lines to the LED controller for over 100 feet under good conditions. The only thing that really competes with that is wireless or Ethernet.

Note to self: Ethernet LED controller? Hmmm.