Wednesday, 10 December 2014

Python Plots from Serial Input

The Arduino IDE doesn't do much with serial data returned from the board, other than display it on the serial console. Python provides a platform independent way to listen to your Arduino and draw graphs of analog data, or whatever you want. The code below provides a stripchart display based on the assumption that lines of

millis(), A0, A1, A2, A3, A4, A5

format are coming back from the Arduino on the serial port. It's hardcoded with port and speed, but easy to edit. I think the indents are OK, but this blog platform strips out the tabs on pasting...

Update: I did all of this with an arduino micro. Like the Leonardo, it doesn't reboot when you re-initialize the USB. When I switched to the UNO with the same code, I had to adjust it so it waited and read a few more lines before acting on the data. If you don't want to disrupt the UNO, you probably need to make a direct RS232 connection through an FTDI cable, rather than the onboard USB.

import matplotlib.pyplot as plt
import time
import serial

ser = serial.Serial('/dev/tty.usbmodemfd1471',57600,timeout=1)
line = ser.readline() # throw away any part lines
while(ser.inWaiting() < 100): # make sure something is coming
  now = 0.0
t=[] # initialize the data lists
while (ser.isOpen()):
  line = ser.readline() # read a line of text
  mylist = line.split(",") # parse it into CSV tokens
  #print mylist
  now = float(mylist[0])/1000 # time now in seconds
  t.append(float(mylist[0])/1000) # from first element as milliseconds
  d1.append(float(mylist[1])) # six data elements added to lists
  if(ser.inWaiting() < 100): # redraw only if you are caught up
    plt.clf() # clear the figure
    plt.plot(t,d1) # plot a line for each set of data
    plt.xlabel("Time Since Boot [s]")

By request, here's the arduino code I was running, which does a bunch more than just print analog values

//// AvgDAQ
// Makes the potentially dangerous assumption that the analog pins are numbered in sequence, starting at A0

//// Constants
int d = 1;
int navg = 10;
int nan = 6;
int nrpt = 500;
int ndisp = 20000;

void setup() {
  for(int i = 0; i < nan; i++) pinMode(A0 + i, INPUT);
  analogReference(INTERNAL);  // 2.56 volts on the YUN, 1.1 on UNO
  //analogReference(EXTERNAL);  // based on the input to AREF

void loop() {
  static int linesShown = 0;
  unsigned long sums[10];    // doesn't want to work with NAN as a dimension
  if(linesShown < ndisp){ 

void getAvgDAQ(unsigned long *sums) {
  sums[nan] = (unsigned long) millis();
  for(int i = 0;i < nan;i++) sums[i] = 0;
  for(int i = 0;i < navg;i++) for(int j = 0;j < nan;j++){ 
    sums[j] += analogRead(A0+j); 
  for(int i=0;i < nan;i++){ 
    //sums[i] *= 1404;  //convert to mv for 1.404 V AREF
    //sums[i] *= 2560;  //convert to mv for 2.56 V internal ref
    sums[i] *= 1100;    //convert to mv for 1.10 V internal ref
    sums[i] /= 1024;
    sums[i] /= navg;    // average over NAVG samples

void showSums(unsigned long *sums) {
  char scratch[80];
  scratch[0]=0;    // when in doubt code dangerously, writing a string over itself ;-)
  for(int i = 0;i < nan;i++) sprintf(scratch,"%s, %5d",scratch,(int) sums[i]);
  sprintf(scratch,"%s,   *",scratch);
  for(int i=0;i<80;i++) scratch[i] = '.';
  scratch[79] = 0;
  for(int i=0;i<nan;i++){
    long j = sums[i] / 20;
    if(j > 78) j = 78;
    scratch[j] = '0'+i;

and of course to get all of this to run, you need to have pyserial and matplotlib installed. On a mac you can try

sudo easy_install pip
sudo pip install pyserial
sudo pip install matplotlib

Saturday, 15 November 2014

Bigger Hammer!

I read a couple of things online that made oblique references to inverting signals, then decided I wanted to invert a TTL signal, despite having no inverter chips lying around, so... this code allows an Arduino to emulate an inverter that could be made from a couple of resistors and a transistor:

void setup(){

void loop(){
  if(digitalRead(7) == HIGH) digitalWrite(8, LOW);
  else digitalWrite(8,HIGH);

which in turn allowed me to successfully read the NMEA data from my antique Standard Horizon CP150C chart plotter. The plotter provides 2 wire connection for the serial NMEA sentences it shares with the world, but for some unknown reason related to RS232 and RS 422 and NMEA, the data is inverted, 5 volts when the listener expects 0 and 0 when the listener expects 5. Suddenly, by magic, I get


instead of


and that GLL sentence would have a whole lot more position data between those commas if the antenna could just see a few satellites from here in the workshop.
I hope the next person who googles for

CP150C NMEA to RS232 serial

finds this page to answer their question quickly.

Tuesday, 11 February 2014

Sleepy Wireless Temperature Sender

It would be nice to know the temperature in the greenhouses at Made in the Shade without having to be there. The obvious first solution step is a commercial remote monitor, good enough to read 300 ft away, which just manages to display temperatures from 3 different greenhouses on an LCD display if the base station is by the back window of the house. It doesn't do much good if you are off the property, and doesn't have an obvious way to hijack the readings from the base station. To get them off the property, we'll have to reacquire the temperature signals, preferably with a battery powered wireless gadget. The obvious solution is some kind of Arduino / XBee combination, except an UNO with an XBee attached consumes about 100 mA and would burn through an AA battery pack in a day or less.

Low Power Means Putting Things to Sleep!

Plugged in a new XBee on the FTDI cable and couldn't remember the right terminal settings (9600, Raw, Echo,  then +++ with no return should get an OK.) I used ATID2711, ATMY0, ATDL1, ATBD6 to match the one at the sailboat end of the IOM controller so the TX can listen to either one at 57600 baud. Don't forget the ATWR to write it all out! Upgraded the IOM TX program to echo any serial it gets back on the XBee to the console.

Now to get a trinket talking to the XBee... I couldn't get software serial to work reliably on the trinket at 57600, so backed all the XBees down to 19200. I created SleepyTrinket based on the code from Nathan Seidle at That code uses pins 3 and 4 for the software serial, but I switched it to 0 and 1, then used pin 2 for the XBee sleep line, which leaves 3 (A3) and 4 (A2) for something analog useful. I cut the current draw on the trinket by 3 mA by breaking off the green power LED. The XBee sleeps when pin 9 is set high if sleep mode is enabled (ATSM1 for hibernate or ATSM2 for doze, plus ATWR).

I first powered the Trinket and the XBee directly on the 3V line from a 3.7 V 100 mAh LiPo, hoping to bypass any regulator losse, but that worried me a little so I switched to the regulated battery input. Either way, with everything awake it used about 60 mA and with everything asleep that fell to about 40 uA! That's about 1 mAh per day while sleeping and 1 mAh per minute while awake.

How quickly can I wake everything up, spit out a serial burst and go back to sleep? It works with delays in the code of 1 s, 500 ms, 100 ms, so 50 ms is probably fast enough with a total time around 200 ms per burst. To split the power consumption between awake and asleep would mean reporting about 300 times a day or about once every 5 seconds.

When I enabled the ADC and started reading a TMP 36 the sleep load came up to about 270 uA, or about 6 mAh per day, which would still get months on a 1300 mAh battery. Still, enabling and disabling the ADC each cycle brings the sleep load back down to about 60 uA. Better stability for the TMP 36 comes from a 2 M resistor and a 104 ceramic cap bridging the signal pin to ground. Based on these measurements, the little 500 mAh LiPo in the background should be good for more than 6 months between recharges. The next step is a little tidier packaging and something at the house end that will listen, repeat the data out to the world, and maybe send an SMS if alarm conditions come up.

A little more testing shows that the accuracy of the temperature measurements from this combo are a little dodgy, so time to track down where the error comes from. (Yes I know that the TMP36 spec says +-2C, but I want better ;-) )

Use with Adafruit Trinket 3V - remove green power LED - compile as trinket 8MHz

about 6 mA awake and 25 uA asleep, 10 mA if the LED is turned on for just the trinket

sleep current goes up to about 1 mA if connected to FTDI cable

Rick Sellens adapted from:

 Spark Fun Electronics
 Nathan Seidle

 This code is public domain but you buy me a beer if you use this and we meet someday (Beerware license).
#define TRX 1      // Trinket RX pin
#define TTX 0      // Trinket TX pin
#define XBS 2      // XBee sleep pin
#define BLNK 1     // Blinking LED pin
#define TMP 2      // Analog pin number for TMP 36

#define WT 50

#include <avr/sleep.h> //Needed for sleep_mode

#include <SoftwareSerial.h>

SoftwareSerial mySerial(1, 0); // RX, TX

volatile int watchdog_counter;

//This runs each time the watch dog wakes us up from sleep
ISR(WDT_vect) {

void setup()
  digitalWrite(XBS,LOW);  // start with the XBee awake
  mySerial.begin(19200);    // flaky at 57600, but seems OK at 9600, 19200, 38400
  mySerial.println("\n\nRWS Sleeper");
  watchdog_counter = 0;

  //Power down various bits of hardware to lower power usage  
  set_sleep_mode(SLEEP_MODE_PWR_DOWN); //Power down everything, wake up from WDT
  ADCSRA |= (1<<ADEN);    //Enable ADC, costs ~230uA
  ADCSRA &= ~(1<<ADEN);   //Disable ADC, saves ~230uA
  setup_watchdog(6); //Wake up after 1 sec (6)

void loop() {
  static int rdg = 0;
  static int n = 0;
  digitalWrite(XBS,HIGH);  // sleep the XBee
  sleep_mode();            // sleep the trinket

  if(watchdog_counter > 0){
    // trinket awake, so take a reading
    ADCSRA |= (1<<ADEN);    //Enable ADC, costs ~230uA
    rdg += analogRead(TMP);
    ADCSRA &= ~(1<<ADEN);   //Disable ADC, saves ~230uA

    if(watchdog_counter > 9){         // wake the XBee every 10 counts
      digitalWrite(BLNK,HIGH);        // LED on  
      digitalWrite(XBS,LOW);          // wake the XBee
      mySerial.print("Awakened... ");
      digitalWrite(BLNK,LOW);        // LED off
      long int itemp = rdg;          // temperature in tenths of a degree C
      itemp = (itemp * 3300 / 1024) / n - 500;
      mySerial.println(" tenths of a degree C.     ZZZ...");
      // rest the accumulator and counters
      watchdog_counter = 0;
      rdg = 0;
      n = 0;

// 0=16ms, 1=32ms, 2=64ms, 3=128ms, 4=250ms, 5=500ms
// 6=1sec, 7=2sec, 8=4sec, 9=8sec
// From:
void setup_watchdog(int timerPrescaler) {
  if (timerPrescaler > 9 ) timerPrescaler = 9; //Correct incoming amount if need be
  byte bb = timerPrescaler & 7; 
  if (timerPrescaler > 7) bb |= (1<<5);        //Set the special 5th bit if necessary

  //This order of commands is important and cannot be combined
  MCUSR &= ~(1<<WDRF);                   //Clear the watch dog reset
  WDTCR |= (1<<WDCE) | (1<<WDE);         //Set WD_change enable, set WD enable
  WDTCR = bb;                            //Set new watchdog timeout value
  WDTCR |= _BV(WDIE);                    //Set the interrupt enable, this will keep unit from resetting after each int

Thursday, 6 February 2014

Next Steps: Arduino Workshop 2

In this second workshop you will: 
  • select a transducer to measure something physical like temperature or illumination
  • download and install libraries to support components
  • connect neopixel smart RGB LEDs to your Arduino and change their colour and intensity under program control (some soldering required)
  • Use the neopixels to respond to the measured quantity, and more as time permits

or so I promised in the advertising. The simplest way to get some data would be following this lesson with a photocell. (Ignore all the parts about the LEDs for now and just make sure you can read an analog value that changes with the light. Take note of the extremes values for bright and dark. You can adapt the code at the bottom of this post.)

Adafruit NeoPixels are smart RGB LEDs that let you control a whole lot of LEDs with a single data line from the Arduino, and you don't have to worry about all those little current limiting resistors (although, if you are playing with more than a couple of neopixels, you should pay close attention to the capacitor and power supply comments in the uberguide). The complicated part is you need to control that one data line in a fairly complicated way. Fortunately somebody else has already done the work and there is a software library to make it easy. Download the zip file of the library and expand it, then install it in the libraries folder of the Arduino IDE. (You may have to create the libraries folder -- it goes in the same place as your Arduino sketchbook folder.) 

Be sure to remove the "-master" from the library folder name so it matches the name of the library. Then restart the Arduino IDE so it can find the library.

Put together a string of 2 or more NeoPixels (this will probably involve some soldering, either for the Flora or Breadboard versions), then hook them up to +5, Ground and pin 6 for a signal. Open the "strandtest" example in the NeoPixel library and set the number of NeoPixels you have in this line:
Adafruit_NeoPixel strip = Adafruit_NeoPixel(2, PIN, NEO_GRB + NEO_KHZ800);
When you run it you should see the pixels continuously changing colour and intensity independently of each other.

Modify the code to have the pixels respond to the analog input reading from from the photocell.

Other Sensors and Responses

You could measure temperature, or temperature and humidity, or colour, or orientation, with one of these sensors and use that measurement to control the colours and intensity of the NeoPixels. Download and install the library for your sensor, test that you can read it with the example programs, then combine the code from multiple examples to read the sensor, then control the NeoPixels based on what you read.

Take it further and get your sensor inputs to control a servo-motor, maybe opening and closing a greenhouse vent in response to changes in temperature or humidity.

Coding Hints

Pick one of the examples as your starting place and save it with a new name so you don't break the example.

Copy the header code from the top of all the files with the #include and variable declarations.

Copy any functions other than setup() and loop()

Copy and paste code from each of the setup() functions to make sure everything gets started properly.

Copy and paste code from the loop() functions to do the individual things you want.

This code will read analog values and report them:

//// ArduinoDAQ
// Kevin Hughes 2012
// Modified Rick Sellens July 2013

//// Constants
int d = 1;

void setup() {
  // All pins to input
  pinMode(A0, INPUT);
  pinMode(A1, INPUT);
  pinMode(A2, INPUT);
  pinMode(A3, INPUT);
  pinMode(A4, INPUT);
  pinMode(A5, INPUT);
  // Init Serial
  Serial.begin(57600);      // 57600 is highest I can sustain over X-Bee and FTDI
}// end setup

void loop() {
      //start line with time in ms, number of channels, full scale, then the values 
      Serial.print( millis() );          Serial.print(", 6, 1023, ");
      Serial.print( analogRead(A0) );    Serial.print(", ");
      Serial.print( analogRead(A0) );    Serial.print(", ");
      Serial.print( analogRead(A1) );    Serial.print(", ");
      Serial.print( analogRead(A2) );    Serial.print(", ");
      Serial.print( analogRead(A3) );    Serial.print(", ");
      Serial.print( analogRead(A4) );    Serial.print(", ");
      Serial.println( analogRead(A5) );
      while(millis()%100 != 0);            // repeat every 100 ms