PlastiBots

Red Light Camera Alerter

Dave — Wed, 11 Apr 2012 01:08:58 +0000

I had the chance to play with some new components – namely the Adafruit Monochrome 128×32 OLED display and the Adafruit UP501 66 channel GPS receiver. As I was pondering ideas of what to build, I thought that it would be neat to be alerted when approaching a red light camera. In my local area (Southern Ontario), there are currently about a hundred or so of these cameras around the GTA. However, it appears that new legislation may see this number grow much larger. This is more of a proof of concept project to me than it is useful as, a) I don’t intend on trying to run any red lights, and b) there are only about 1 or 2 of them within the area. However, it was fun to build and tweak to make it useful. Read on…

The general idea is that the GPS tracks the coordinates while driving, the Arduino sketch has an array of red light camera location coordinates that it compares against the current reading. On a regular basis, it checks the current position of the car against the array of red light camera locations. With each check, it finds the closest red light camera location. If that location is less than a pre-determined buffer distance (e.g. 3 km away), it will begin reporting on it via the OLED as well as the Status LED.

The Status LED flashes with 4 modes:

green – indicates that the system is functional and GPS is returning results.
blue – early warning of approaching red light camera location less than 600 metres away.
yellow -warning of red light camera less than 200 metres away.
red – red light camera intersection less than 50 metres away.

The Parts:

Adafruit Monochrome 128×32 OLED display
Adafruit UP501 66 channel GPS receiver
Adafruit Perma-Proto Quarter Sized Breadboard
Atmega 328P with UNO Bootloader
10mm Diffused RGB LED
Other bits (5v/3.3v regulator, female headers, resistors etc)

The OLED will display the distance to the Red Light Camera in Km, Direction that the vehicle is travelling, Speed, # of Satellites, Latitude and Longitude of the vehicle.

The Build:

The main unit consists of an Atmega 328P mounted to an Adafruit Perma-Proto Quarter sized breadboard. The board has both 5v and 3.3v rails running down either side to provide power for various components. The rest is a spaghetti mess of wires for all the components. I also decided to make this unit (somewhat) modular. The main board has been fitted with female header pins to allow all components to be plugged/unplugged. So, if I want to re-use the controller for another project, I can just unplug all the bits and I have a dual power supply-ready Arduino. Given that I would likely want to re-use the GPS on other projects, I hacked in USB ports on the main unit as well as a mini-USB connector on the GPS module.

As noted above, the GPS module is modular. With the mini-USB connector, I can move it over to other projects in a breeze. There are only 4 connectors that need to be brought to the Arduino to use this unit, so USB cables do the trick. Although there are more pins needed, the wiring can be done at the GPS module end itself (e.g resistor between two pins). I also wanted a minimal USB cable, so I picked up one of those self-retracting flat cable USB dongle thingamabobs and just took out the self-retracting bit. The cable is very flexible as well.

The Verdict:

Adafruit UP501 GPS Module: The UP501 is small, which makes it great for fitting into small packages. Another nice feature is that you only require 4 wires between the controller and the GPS, which makes it a perfect candidate for using readily available USB cables. I managed to get this one before the newer Adafruit Ultimate GPS that comes with a backup battery. As a result, my unit takes up to 45 seconds to as it would cold start every time it is powered up. This is negligible considering I don’t need the GPS functioning the moment I start my car. However, for other projects, this could be an issue. Once the unit acquires its first fix, it provides fast accurate updates. It is also great at acquiring signals indoors.. When testing, I would put it on my window sill to get a fix, then once fixed, I could move the unit to my desk to continue testing.

Adafruit 128×32 OLED Module: I won’t go into detail here as I have already done a review on this unit here. However, I will say that this is a nice, crisp, small display that works very well with small projects.

The Code:

(download)

// Select which PWM-capable pins are to be used.
int redPin = 9;
int greenPin = 3;
int bluePin = 10;

#include 
//SoftwareSerial mySerial(rxPin, txPin)
//SoftwareSerial nss(2, 3);  //yellow wire = RX  Blue wire = TX
SoftwareSerial nss(0, 2);   //yellow wire = RX  Blue wire = TX

#include 
#include                   //for OLED
#include                       //for OLED
#include 
#include 

#define OLED_RESET 7
#define OLED_DC 8
#define OLED_CS 6     // SPI slave-select
#define OLED_MOSI 11   // hardware SPI MOSI
#define OLED_CLK 13    // hardware SPI clock

// Connect the GPS Power pin to 3.3V
// Connect the GPS Ground pin to ground
// Connect the GPS VBAT pin to 3.3V if no battery is used
// Connect the GPS TX (transmit) pin to Digital 2
// Connect the GPS RX (receive) pin to Digital 3
// For 3.3V only modules such as the UP501, connect a 10K
// resistor between digital 3 and GPS RX and a 10K resistor
// from GPS RX to ground.
TinyGPS gps;
//NewSoftSerial mySerial(rxPin, txPin);

//OLED
SSD1306 oled(OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);

const int GPSActive = 4;               // Indicates GPS is getting data
const int statusLED = 5;               //System hearbeat LED

int updateFreq = 1000;                 //frequency to update GPS polls.  Good not to go below 1000 ms.

float flat, flon;                      //lat and long variables used in calculations
unsigned long age;                     //GPS reading age variable
float spd;                             // GPS Speed
float minDist = 100000;                //preset the minDist to some very high value (in meters)

//
//int md[] = {600, 180, 35};
//int j = 0;
//

const float ToRad = PI / 180.0;        // for HaverSine function
const float R = 6371;                  // radius earth in Km - for HaverSine function
int mappedDist = 0;                    // mapped variable converted for placement of icons on OLED
int spdProRate = 0;                    // pro rated speed value movement of road graphic on OLED - to mimic speed changes
int i = 128;                           // used for the looping through animations of the OLED
int state = LOW;                       // The input state of the status LED
int gpsStatCounter = 0;
// setup variables for Tiny GPS
void gpsdump(TinyGPS &gps);
bool feedgps();

char cVal[32];
int sats;
int hdop;
String cardinal;

//********************************************************************************************************
// use for testing
boolean debug = true;            //print debugging statements to the serial port.
//********************************************************************************************************

// different commands to set the update rate from once a second (1 Hz) to 10 times a second (10Hz)
#define PMTK_SET_NMEA_UPDATE_1HZ  "$PMTK220,1000*1F"
#define PMTK_SET_NMEA_UPDATE_5HZ  "$PMTK220,200*2C"
#define PMTK_SET_NMEA_UPDATE_10HZ "$PMTK220,100*2F"
// turn on only the second sentence (GPRMC)
#define PMTK_SET_NMEA_OUTPUT_RMCONLY "$PMTK314,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29"
// turn on ALL THE DATA
//#define PMTK_SET_NMEA_OUTPUT_ALLDATA "$PMTK314,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0*28"
// to generate your own sentences, check out the MTK command datasheet and use a checksum calculator
// such as the awesome http://www.hhhh.org/wiml/proj/nmeaxor.html

//Define list of waypoints to search
//format WayPt[Lat][Long]
//multidimensional array [howmany dn] [howmany across]
const float wayPt[175][2] PROGMEM =
{
{43.25981,-79.88897},
PUT YOUR RED LIGHT CAMERA COORDINATES HERE
}; 

void setup()
{

  Serial.begin(115200);
  pinMode(statusLED, OUTPUT); 

  //setup the RGB LED
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);

  //set the RGB status LED to off which is HIGH (255) reason: Common-Annode.
  analogWrite(redPin, 255);
  analogWrite(greenPin, 255);
  analogWrite(bluePin, 255);

  //Serial.println("Adafruit MTK3329 NMEA test!");
  nss.begin(9600);  //needed to change this to 9600 baud for the UP501 GPS module

  //*********  OLED SETUP STUFF ******************************************************************/
  SPI.begin ();  //for OLED
  // OLED: By default, we'll generate the high voltage from the 3.3v line internally! (neat!)
  oled.ssd1306_init(SSD1306_SWITCHCAPVCC);

  //*********  GPS SETUP STUFF ******************************************************************/
  // 9600 NMEA is the default baud rate
  // uncomment this line to turn on only the "minimum recommended" data for high update rates!
  nss.println(PMTK_SET_NMEA_OUTPUT_RMCONLY);
  // uncomment this line to turn on all the available data - for 9600 baud you'll want 1 Hz rate
  //mySerial.println(PMTK_SET_NMEA_OUTPUT_ALLDATA);
  // Set the update rate
  // 1 Hz update rate
  nss.println(PMTK_SET_NMEA_UPDATE_1HZ);
  // 5 Hz update rate- for 9600 baud you'll have to set the output to RMC only (see above)
  //nss.println(PMTK_SET_NMEA_UPDATE_5HZ);
  // 10 Hz update rate - for 9600 baud you'll have to set the output to RMC only (see above)
  //nss.println(PMTK_SET_NMEA_UPDATE_10HZ);
  //*********  END GPS SETUP STUFF ******************************************************************/

  //setupDisplay();

}

void loop()
{
  bool newdata = false;
  unsigned long start = millis();

  blinkLED();   // heartbeat to ensure system is working
  flat=0;
  flon=0;
  spd=0;
  sats=0;
  hdop=0;
  cardinal= "";

  // Every xxxx milliseconds we print an update
  while (millis() - start < updateFreq)
  {
    if (feedgps())
      newdata = true;
  }

  heartbeat(newdata);  //shows external heartbeat signal through GPS status LED

      if (newdata)
      {
                  feedgps(); // If we don't feed the gps during this long routine, we may drop characters and get checksum errors
                  gps.f_get_position(&flat, &flon, &age);
                  if (debug) {
                    Serial.print("Lat/Long(float): "); Serial.print(flat, 5); Serial.print(", "); Serial.print(flon, 5);
                    Serial.print(" Fix age: "); Serial.print(age); Serial.print("ms.");
                    Serial.print(" (kmph): "); Serial.print(gps.f_speed_kmph(),4); Serial.println();
                    //Serial.print(" Sats: "); Serial.print(gps.satellites()); Serial.println();
                    feedgps(); // If we don't feed the gps during this long routine, we may drop characters and get checksum errors
                    Serial.print(" Sats: "); print_int(gps.satellites(), TinyGPS::GPS_INVALID_SATELLITES, 5);
                    Serial.print(" HDOP: "); print_int(gps.hdop(), TinyGPS::GPS_INVALID_HDOP, 5);
                    Serial.print(" Course: "); print_float(gps.f_course(), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
                    Serial.print(" Cardinal: "); print_str(gps.f_course() == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(gps.f_course()), 6);

                  }
                  //compare the latest reading with the array of red light camera points and find which is closest.
                  minDist = getClosestPt(flat, flon);
                  //minDist = md[j];
                  //if (j == 2){j = 0;}else{j++;}

                  //indicate that GPS is active and receiving data
                  flash(1);  //flashes the LED on the project box showing GPS signal

                  if (debug) {
                    Serial.print("Delta = ");Serial.print(minDist, 2);Serial.println(" Meters   ");
                  }

                  //Process alerts via various means based on pre-defined distance thresholds.

                  if (minDist < 50)                 //Warning Alert < 50 meters - in range if red light camera
                  {
                    //red
                    changeWarning(4);
                  }
                  else if (minDist < 200)          //Approaching Alert < 200 meters
                  {
                    //yellow
                    changeWarning(3);
                  }
                  else if (minDist <= 600)          //Initial Alert - 600 meters
                  {
                    //blue - early warning
                    changeWarning(2);
                  }
                  else
                  {
                    //just show status that GPS is working.
                    changeWarning(1);
                  }

                  //for testing
                  //minDist = 40;
                  //updateDisplay(minDist, 65.00);
                  //end testing

                  //updateDisplay(minDist, gps.f_speed_kmph());

      }

      else
      {
          if (debug) {Serial.println("Polling GPS... waiting for fix...");}
      }

      oled.clear();

      //Distance to next red light
      oled.drawstring(0, 0, "Dist:");
      if (minDist == 100000)
      {
        oled.drawstring(30, 0, "?");
      }
        else
      {
        ftoa(cVal, minDist/1000, 2);
        oled.drawstring(30, 0, cVal);
      }
      oled.drawstring(55, 0, "km");

      //Cardinal Direction of vehicle
      //strcpy ( cVal, TinyGPS::cardinal(gps.f_course()) );
      strcpy ( cVal, gps.f_course() == TinyGPS::GPS_INVALID_F_ANGLE ? "?" : TinyGPS::cardinal(gps.f_course()));
      oled.drawstring(75, 0, "Dir:");
      oled.drawstring(100, 0, cVal);

      oled.drawline(0, 12, 128, 12, WHITE);

      //speed
      spd = gps.f_speed_kmph();
      if (spd < 0) {spd=0;}
      ftoa(cVal, spd, 0);
      oled.drawstring(0, 2, "Spd:");
      oled.drawstring(25, 2, cVal);

      //satellites
      itoa(gps.satellites(), cVal, 0);
      oled.drawstring(65, 2, "Sats:");
      oled.drawstring(90, 2, cVal);

      //latitude
      ftoa(cVal, flat, 2);
      oled.drawstring(0, 3, "Lat:");
      oled.drawstring(25, 3, cVal);
      //longitude
      ftoa(cVal, flon, 2);
      oled.drawstring(65, 3, "Lng:");
      oled.drawstring(90, 3, cVal);

      //Display all the results
      oled.display(); 

      //reset minDist for the next round
      minDist = 100000;     //meters  

}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
char *ftoa(char *a, double f, int precision)
{
  long p[] = {0,10,100,1000,10000,100000,1000000,10000000,100000000};

  char *ret = a;
  long heiltal = (long)f;
  itoa(heiltal, a, 10);
  while (*a != '\0') a++;
  *a++ = '.';
  long desimal = abs((long)((f - heiltal) * p[precision]));
  itoa(desimal, a, 10);
  return ret;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void setupDisplay()
{
    // Draw animated graphics to OLED - we will use the GPS speed to mimic changes in speed of the lanes.
    oled.clear();   // clears the screen and buffer
    //oled.drawbitmap(0, 2,  Road, 128, 32, 1);     //road - dash lines - draw the animating road
    //oled.drawbitmap(95, 4,  JukeIcon, 34, 40, 1);  //keep drawing the car icon in place
    oled.fillrect(0, 0, 128, 2, WHITE);            //keep drawing the top continuous line
    oled.fillrect(0, 30, 128, 2, WHITE);           //keep drawing the bottom continous line
    oled.display();
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void updateDisplay(int minDist, float spd)
{
    if (i==0){i=128;}  //we have 128 pixels to loop through for animation of the road dashed lines. reset when it gets to 0.

    // Draw animated graphics to OLED - we will use the GPS speed to mimic changes in speed of the lanes.
    //oled.drawbitmap(i, 16,  Road, 128, 32, 1);     //road - dash lines - draw the animating road
    //oled.drawbitmap(i-128, 16,  Road, 128, 32, 1);  //road - dash lines - draw the road ahead to keep contents on the screen

    //map values based on dist from camera, min dist on ground of 20m, max dist on ground of 500m, min dist in px to car, max dist in px from car
    mappedDist = map(minDist, 20, 500, 40, 110);
    //oled.drawbitmap(mappedDist, 10,  RedLightCam, 10, 15, 1);  //move the red light camera as it approaches 

    //oled.drawbitmap(95, 12,  JukeIcon, 34, 40, 1);  //keep drawing the car icon in place
    oled.fillrect(0, 0, 128, 4, WHITE);            //keep drawing the top continuous line
    oled.fillrect(0, 61, 128, 4, WHITE);           //keep drawing the bottom continous line
    oled.display();
    oled.clear();   // clears the screen and buffer 

    // convert speed to an int so it can be used in the map funciton.  1.25 km/h = 125
    //Serial.println(int(spd*10));
    spdProRate = map(int(spd*10), 0, 900, 0, 30);
    //Serial.println(spdProRate);
    //i=i-10;
    i = i - spdProRate;
    if (i < 0) {i=0;}

    //mappedDist = 0;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
float getClosestPt(float flat, float flon)
{
  float d;
  float d2;
  float md = 10000;
  //int minCoordIndex;
  //int coordsProcessed;

              if (flat != 0 && flon != 0)
              {
                for (unsigned int x=0; x<175; x++){
                      //In array lat is 2nd col, long is 1st col  e.g. lat:43.xxxx,long:-79.xxxxx - need to get right ones for calc
                      //flat2 =  pgm_read_float_near(&wayPt[x][0]);
                      //flon2 = pgm_read_float_near(&wayPt[x][1]);
                      //if (debug)
                      //{
                      //  Serial.print("Flat2:  ");Serial.print(flat2, 5);
                      //  Serial.print("  Flon2:  ");Serial.println(flon2, 5);
                      //}
                      //d = HaverSine(flat, flon, pgm_read_float_near(&wayPt[x][0]), pgm_read_float_near(&wayPt[x][1]));
                      d = gps.distance_between(flat, flon, pgm_read_float_near(&wayPt[x][0]), pgm_read_float_near(&wayPt[x][1]))/1000 ;
                      if (debug)
                      {
                        //Serial.print("DistanceCalcualted d1: ");Serial.print(d, 4); Serial.print(" d2:"); Serial.print(d2, 4); Serial.println("");
                        //Serial.print("DistanceCalcualted d1: ");Serial.print(d, 4); Serial.println("");
                      }
                      if (d < md)
                      {
                        md = d;
                        //minCoordIndex = x;
                      }
                      //coordsProcessed++;
                  }

                  //convert to meters
                  md = md * 1000;

                  //Serial.print(" Processed:");Serial.println(coordsProcessed);
                  /*
                  Serial.println("");
                  Serial.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
                  Serial.print(" Index:");Serial.println(minCoordIndex);
                  Serial.print(" Processed:");Serial.println(coordsProcessed);
                  Serial.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
                  Serial.println("");
                  */
                }
                //coordsProcessed = 0;
 return md;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 float HaverSine(float lat1, float lon1, float lat2, float lon2)
{
  //float ToRad = PI / 180.0;
  //float R = 6371;   // radius earth in Km

  float dLat = (lat2-lat1) * ToRad;
  float dLon = (lon2-lon1) * ToRad;

  float a = sin(dLat/2) * sin(dLat/2) +
	  cos(lat1 * ToRad) * cos(lat2 * ToRad) *
	  sin(dLon/2) * sin(dLon/2);

  float c = 2 * atan2(sqrt(a), sqrt(1-a));

  float d = R * c;
  return d;  //distance returned in Kilometers
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
bool feedgps()
{
  while (nss.available())
  {
    if (gps.encode(nss.read()))
      return true;
  }
  return false;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
static void print_float(float val, float invalid, int len, int prec)
{
  char sz[32];
  if (val == invalid)
  {
    strcpy(sz, "*******");
    sz[len] = 0;
        if (len > 0)
          sz[len-1] = ' ';
    for (int i=7; i= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
    for (int i=flen; i 0)
    sz[len-1] = ' ';
  Serial.print(sz);
  feedgps();
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void blinkLED()
{
state = !state;
digitalWrite(statusLED, state);
}

Arduino Temperature / Humidity Sensor

Dave — Thu, 05 Apr 2012 21:06:14 +0000

The projects I do tend to fall in one of two buckets – either proof-of-concept (so I can learn new stuff) or items that have some sort of functional use. The need for this project came about when my wife was prodding me about the humidity in the house and whether our humidifier was doing it’s job correctly. Most people would just go out and buy a temp / humidity sensor and be done with it. However, if you have a look around here, you will see that I don’t fit that mold. Instead, I decided to build an accurate temp / humidity sensor with a Sensiron SHT11 to read the values, a RBBB Arduino kit to process everything and an Adafruit 128×32 OLED to display the results – all wrapped up in… LEGO! Read on for more…

Admittedly, I would not normally spend the money required to outright build this gizmo (approx $95 incl shipping for all parts). Instead, I was able to acquire the parts for a fraction of this price. As a result, the purpose of this build is twofold. 1) Create a sensor that can be used in my house on an ongoing basis; 2) Review the parts to provide insight for those considering using them for similar or other projects.

Parts:

Adafruit Monochrome 128×32 OLED Display – ($17.50)
Newark Sensiron SHT11 Humidity / Temperature Sensor ($29.xx)
Modern Device RBBB Arduino Kit (3.3v) ($13.00)
Adafruit Through Hole 5-Way Navigation Switch ($2.95)
Insulated Silver-Plated Copper 30Ga Wire (~1.00)
The rest of the parts (caps, resistors, LED) I had as spares.

There were a few goals that I wanted to achieve with this project. Make it small and compact, easy to use, and conserve as little power as possible. Getting it into a small package was aided by the RBBB. I could have gone a step further by just making a standalone Atmega, but the LEGO shell was my starting place and everything fit fine within the space it had. For power conservation, I used the sleep abilities of the chip and tied it to Interrupt2 tied to the toggle switch. Pushing the switch ‘in’ would trigger the interrupt and wake the unit. I also have power for the OLED and the SHT11 sensor shut down just before it goes to sleep, and back on immediately after it wakes. To do this, I used 2 digital pins set to HIGH / LOW as needed. I am running the unit off 2x 3V 2032 cells in series, which are put through a 3.3v regulator to power the board and components. When running with all components powered it pulls 12mA. In sleep mode it pulls 0.6mA. I’d like to get it lower, but think that my use of the regulator is partially killing it due to the voltage drop out.

The key to the accurate humidity / temp readings is the Sensiron SHT11 sensor. It’s tiny – really tiny. There are 4 connections: 3.3V- 5V, GND, Data, CLK. In order to protect the sensor, it has been mounted to the side of the unit inside a clear plastic housing. The housing has a hole in the side to allow air to flow freely, but limits the any water that might find its way in there (because you never know when it might rain inside the house

Since everything is so small, I used very fine 30 gauge silver plated copper wire for this. It worked quite well for what I needed to do here.

Before migrating all the components into the project, I set everything up on a breadboard and used the Uno to test the sketches. Interestingly, I found getting the 5-way switch working the most challenging. It has a common anode I am using as both an Interrupt link (Pin2) as well as toggle switch for scrolling the OLED.

Below showing the completed RBBB kit. Initially, this came with an earlier Bootloader, but I updated to the Uno one with ease.

The next step was to start fitting the components into the case. The first parts to go in were the switch and red/green status LED. The LED was a pull from an old portable DVD player. After that was done, one side was cut to make room for the length of the RBBB kit. Being a die-hard LEGO fan and spending most of my life building, I was always against bastardizing LEGO for things like this – until I discovered Arduino / micro-controllers. Sorry AFOL’s. The 3rd pic shows the bits all soldered together using that nice 30Ga wire. The 4th shows a test fit with the RBBB inserted. I made the mistake of completing the RBBB kit as per instructions only to realize that I did not want the rows of breadboard pins as would not need them.. So, out came the solder sucker and I removed them (hence the burn marks you see in other pics). In the last picture, you can see a side view showing the SHT11 sensor.. Did I mention this thing is tiny!?

The Verdict:

Adafruit 128×32 OLED: If you are looking for a crisp display with a small footprint, then this is the unit for you. Don’t expect to be able to read this thing from afar. However, up close, the display is clear, and crisp. Because it does not have a backlight, and each pixel is self- illuminated, it has low power consumption and is easy to read. Out of the box, the display is slow to render for anything where rapid updates are necessary. However, the driver can easily be modified to use the Arduino SPI hardware to speed up its response. For this purpose, its not really necessary as I am not drawing rapid graphics or animating. If you are doing that, then you want to do this easy mod. Just remember that you must then also use the dedicated hardware SPI pins.

Sensiron SHT11: Did I mention the sensor is small? Ok, I know I did – so it’s small. This is great for integrating it into small projects like this. Sensiron claims the unit has a high degree of accuracy (+/- 0.4′C and +/-3% RH). When pitching the results against other temperature gauges in our house, I had different readings on all of them. When I tested the readings against a classic mercury unit, it was off by about 1 degree. It also responded well to rapid temperature changes at about a 1-2 hz rate. Not super fast, but good enough for measuring changes in room temperature. I did some tests where I set the update frequency to less than 500 Ms and it still took about 1+ seconds to return a result – so it seems that the sensor requires this time to produce and return an accurate reading.

Modern Device RBBB Kit: If you are looking for a small Arduino footprint, then this is a nice unit. It is not the smallest out there, but good enough for most small projects. For the price of about $13 plus shipping you can get a full setup in either 3.3v or 5v, the board, parts and an Atmega 328P with bootloader. The only caveat is that it comes with the Diecimila Bootloader, but you can change it to whatever you like easily. Yes, I could have put together a standalone kit with a little more soldering, but considering time and cost, it is not really worth it.

The Code: (download it)

Or click below to view it:

#include                   //SSD
#include                       //for OLED
#include 
#include 
#include                     //HumidityTemp Sensor SHT11

//OLED PINS
#define OLED_RESET 7    // RST on OLED
#define OLED_DC 8       // S/C on OLED
#define OLED_CS 6       // CS on OLED  - SPI slave-select
#define OLED_MOSI 11    // DATA on OLED - hardware SPI MOSI
#define OLED_CLK 13     // CLK on OLED - hardware SPI clock

//SHT11 Tmp/Humidity Sensor
// Specify data and clock connections and instantiate SHT1x object
#define dataPin  9
//#define clockPin 11
#define clockPin 10
SHT1x sht1x(dataPin, clockPin);
float temp_c;
float temp_f;
float humidity;

//#define SHTPwrPin 4  -not used. When using this, current draw went from 0.6mA when off to 37mA when off!!!!  put back
//to 5V pin and back to 0.6mA when off - much better!
#define OLEDPwrPin 3
int redLED = A2;
int grnLED = A3;
int LEDcounter = 0;

int SHTReadCounter = 0;
int centerToggle = 2;
int upToggle = 12;
int dnToggle = 5;
//switch debouncing
long debounceDelay = 20;    // the debounce time; increase if the output flickers -
long lastDebounceTime = 0;  // the last time the output pin was toggled
//for up toggle
int upButtonState;             // the current reading from the input pin
int upLastButtonState = LOW;   // the previous reading from the input pin
//for down toggle
int dnButtonState;             // the current reading from the input pin
int dnLastButtonState = LOW;   // the previous reading from the input pin

//end switch debouncing

volatile int toggle = 1;
char cVal[32];

int displayState = 1;                         //up and down toggles will change the display to different states

long shutoffStartMillis = 0;                  //Store the value to start the shutoff timer from in Milliseconds.
//**********************************
//Change this to determine how long the device stays on - in MS
long shutOffDelayMS = 180000;                  //In Milliseconds - Determines how long to keep LED system on (after shutoff timer clicked) in Milliseconds  10000 (10sec), 60000 (1min) 600000 (10min)
//**********************************
boolean debug = false;                         //turn debugging on or off here

//OLED
SSD1306 oled(OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);

void (*restart)(void) = 0;

/***************************************************
 *  Name:        pin2Interrupt
 *
 ***************************************************/
void pin2Interrupt(void)
{
  /* This will bring us back from sleep. */

  /* We detach the interrupt to stop it from
   * continuously firing while the interrupt pin
   * is low.
   */

  //appears that the interrup is not working correctly and re-triggering things.  Try a restart instead
  restart();

  //  - removed while testing restart() function.  Put these back if restart removed
  //toggle = 1;
  //delay(100);

  detachInterrupt(0);

}

/***************************************************
 *  Description: Enters the arduino into sleep mode.
 ***************************************************/
void enterSleep(void)
{

  /* Setup pin2 as an interrupt and attach handler. */
  //attachInterrupt(interrupt, function, mode)
  //attachInterrupt(0, pin2Interrupt, LOW);
  attachInterrupt(0, pin2Interrupt, FALLING);

  delay(100);

  //Serial.println("Going to sleep....");  

  set_sleep_mode(SLEEP_MODE_PWR_DOWN);

  sleep_enable();

  sleep_mode();

  /* The program will continue from here. */

  /* First thing to do is disable sleep. */
  sleep_disable();
}

void setup()
{
  Serial.begin(38400);
  pinMode(A5, OUTPUT);   //testing blink
  /* Setup the pin direction. */
  pinMode(centerToggle, INPUT);
  //pinMode(SHTPwrPin, OUTPUT);
  pinMode(OLEDPwrPin, OUTPUT);
  pinMode(redLED, OUTPUT);
  pinMode(grnLED, OUTPUT);
  digitalWrite(grnLED, HIGH);  //turn off the green LED - common annode - so they have to be high
  digitalWrite(redLED, HIGH);  //turn off the gred LED - common annode - so they have to be high

  digitalWrite(upToggle, LOW);
  digitalWrite(dnToggle, LOW);
  //digitalWrite(SHTPwrPin, LOW);
  digitalWrite(OLEDPwrPin, LOW);

  //*********  OLED SETUP STUFF ******************************************************************/
  SPI.begin ();  //for OLED
  // OLED: By default, we'll generate the high voltage from the 3.3v line internally! (neat!)
  oled.ssd1306_init(SSD1306_SWITCHCAPVCC);
  //*********  OLED SETUP STUFF ******************************************************************/
  //oled.clear();
  //oled.display();

// displayState = 1;

  if (debug)
  {
    Serial.println("Initialisation complete.");
    Serial.println("Entering sleep");
  }
  //delay(200);
  //enterSleep();

  oled.clear();

}

void doHumTmp(void)
{

    // Read values from the sensor
    if (SHTReadCounter == 20)  //this is based on the delay at the bottom. if delay changes, this value should as well
    {
    temp_c = sht1x.readTemperatureC();
    temp_f = sht1x.readTemperatureF();
    humidity = sht1x.readHumidity();
    SHTReadCounter = 0;
      if (debug)
      {
        // Print the values to the serial port
        Serial.print("Temperature: ");
        Serial.print(temp_c, DEC);
        Serial.print("C / ");
        Serial.print(temp_f, DEC);
        Serial.print("F. Humidity: ");
        Serial.print(humidity);
        Serial.println("%");
      }

    }

    oled.clear();

    if (temp_c < 0 || temp_f < 0 || humidity < 0)
    {
      //calibrating
      //oled.drawstring([character position from left - by pixel], [line number 0,1,2,3], "1");
      blinkLED(redLED);
      oled.drawline(0, 9, 128, 9, WHITE);
      oled.drawstring(0, 2, "Calibrating...");
      oled.drawline(0, 30, 128, 30, WHITE);

    }
    else if(displayState == 1) //good readings show - 2 display states
    {
      blinkLED(grnLED);
      //Temp in C and F
      oled.drawstring(0, 0, "Temp: ");
      ftoa(cVal, temp_c, 1);
      oled.drawstring(35, 0, cVal);
      //oled.drawchar(65, 0, 9);
      //draw degree symbol
      //oled.drawcircle([x position px], [y pos line], [diameter units??], WHITE);
      oled.drawcircle(61, 1, 1.5, WHITE);
      oled.drawstring(64, 0, "C");

      //degrees F
      ftoa(cVal, temp_f, 1);
      oled.drawstring(85, 0, cVal);
      //oled.drawchar(115, 0, 9);
      oled.drawcircle(110, 1, 1.5, WHITE);
      oled.drawstring(114, 0, "F");

      //draw split line
      oled.drawline(0, 15, 128, 15, WHITE);

      /*
      int upstate = digitalRead(upToggle);
      itoa(upstate, cVal, 0);
      oled.drawstring(0, 2, "up:");
      oled.drawstring(10, 2, cVal);

      int dnstate = digitalRead(dnToggle);
      itoa(dnstate, cVal, 0);
      oled.drawstring(45, 2, "dn:");
      oled.drawstring(50, 2, cVal);
      */

      ftoa(cVal, humidity, 1);
      oled.drawstring(0, 3, "Humidity:");
      oled.drawstring(60, 3, cVal);
      oled.drawstring(85, 3, "%");

    }
    else if (displayState == 2)//display state would be 2 here
    {
     blinkLED(grnLED);
     oled.drawstring(0, 0, "Sensor: Sensiron SHT11 Temp & Humidity");
     oled.drawstring(0, 2, "OLED:Adaft SSD1306 128x32");
    }

    else if (displayState == 3)
    {
     blinkLED(grnLED);
     oled.drawstring(0, 0, "Board: Modern Device RBBB Kit");
     oled.drawstring(0, 2, "Chip: Atmega 328P w/UNO Bootloader");
    }

    else if (displayState == 4)
    {
     blinkLED(grnLED);
     oled.drawstring(0, 0, "Sketch:");
     oled.drawstring(0, 1, "HumidityTempSensor1_4");
    }

    //Display all the results
    oled.display();
    delay(100);
    SHTReadCounter++ ;
}  

/***************************************************
 *  Name:        loop
 *  Description: Main application loop.
 *
 Operation
Our code will operate as follows:
1.  Set up the serial port and set pin 2 (INT0) as an input;
2.  Run the loop function which will:
3.  Stay awake for 3 seconds;
4.  Once the 3 seconds have elapsed, SLEEP_MODE_PWR_DOWN will be entered;
5.  All code execution stops;
6.  The user then pushes the switch and pin 2 (INT0) will become low;
7.  The INT0 interrupt will fire and bring the Arduino out of sleep mode;
8.  Code execution continues where it had previously stopped.

Circuit: 

http://donalmorrissey.blogspot.com/2010/04/arduino-external-interrupts.html

 ***************************************************/
//int seconds=0;
void loop()
{
  if (debug)
  {
   // Serial.println("Still awake....");
  }

   //Will put the unit to sleep after a pre-defined amount of time
  if (shutoffStartMillis != 0 && millis() - shutoffStartMillis > shutOffDelayMS)    //if shutoff time has elapsed, turn the LEDs off  1000ms = 1 second
  {
       //delay(100);

       shutoffStartMillis = 0;
       //power down the SHT11 Sensor and other ports
       digitalWrite(upToggle, LOW);
       digitalWrite(dnToggle, LOW);
       //digitalWrite(SHTPwrPin, LOW);

       //Power down the OLED
       oled.clear();
       oled.display();
       //digitalWrite(OLED_RESET, LOW);
       digitalWrite(OLEDPwrPin, LOW);

       //go to sleep
       if (debug) {Serial.println("Entering sleep");}
       delay(200);
       //seconds = 0;
       enterSleep();

  }

  //watch the up and down toggle

  //int upToggleReading = digitalRead(upToggle);
  //int dnToggleReading = digitalRead(dnToggle);

  //will be able to read each other toggle pin as LOW when it is pressed.
  if (debug)
  {
   // Serial.print("UpToggle: "); Serial.print(digitalRead(upToggle));    // Read the pin and display the value
   // Serial.print("  DnToggle: "); Serial.println(digitalRead(dnToggle));    // Read the pin and display the value
   // Serial.print("  DisplayState: "); Serial.println(displayState);    // Read the pin and display the value
  }

  if (digitalRead(upToggle) == 0)
  {
    //displayState++;
    //if (displayState > 2) {displayState = 1;}   //simple method to only go to 2 states
    displayState = 1;
    delay(100);
  }

  if (digitalRead(dnToggle) == 0)
  {

    //if (displayState < 1) {displayState = 2;}   //simple method to only go to 2 states

    if (displayState < 4)
    {
      displayState++;
    }  //dont let it go past a max value
    delay(100);
  }

  /*
     Serial.print("ButtonState: "); Serial.print(upButtonState);
     Serial.print("  LastButtonState: "); Serial.print(upLastButtonState);
     Serial.print("   DisplayState: "); Serial.println(displayState);

     Serial.print("ButtonState: "); Serial.print(dnButtonState);
     Serial.print("  LastButtonState: "); Serial.print(dnLastButtonState);
     Serial.print("   DisplayState: "); Serial.println(displayState);
*/

  // save the reading.  Next time through the loop,
  // it'll be the lastButtonState:
  //upLastButtonState = upToggleReading;
  //dnLastButtonState = dnToggleReading;

  if (toggle == 1)
  {
    shutoffStartMillis = millis();      //get a start value to start the countdown from.
    displayState = 1;  //ensure the display defaults to the main screen
    //digitalWrite(SHTPwrPin, HIGH);
    digitalWrite(OLEDPwrPin, HIGH);
    delay(1000);
    //*********  OLED SETUP STUFF ******************************************************************/
    //have to do this again with each power on state or the OLED does not come on.
    SPI.begin ();  //for OLED
    // OLED: By default, we'll generate the high voltage from the 3.3v line internally! (neat!)
    oled.ssd1306_init(SSD1306_SWITCHCAPVCC);
    //*********  OLED SETUP STUFF ******************************************************************/
    delay(500);
    //oled.clear();
    //oled.display();

    doHumTmp();

    //provide power to the toggle switch up and down.
    digitalWrite(upToggle, HIGH);
    digitalWrite(dnToggle, HIGH);

    delay(500); //give it some time to calibrate etc
    toggle = 0;

  }
  else
  {
    //show the temp and humidity values
    doHumTmp();
  }

  LEDcounter++;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
char *ftoa(char *a, double f, int precision)
{
  long p[] = {0,10,100,1000,10000,100000,1000000,10000000,100000000};

  char *ret = a;
  long heiltal = (long)f;
  itoa(heiltal, a, 10);
  while (*a != '\0') a++;
  *a++ = '.';
  long desimal = abs((long)((f - heiltal) * p[precision]));
  itoa(desimal, a, 10);
  return ret;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
static void print_str(const char *str, int len)
{
  int slen = strlen(str);
  for (int i=0; i 0)
    sz[len-1] = ' ';
  Serial.print(sz);
}

void blinkLED(int led)
{
 if (LEDcounter == 10)   //we do not want the LED blinking with every cycle as it is seizure enducing!
 {
    if (led == redLED)
    {
      digitalWrite(redLED, LOW);
      delay(50);
      digitalWrite(redLED, HIGH);
    }
    else
    {
      digitalWrite(grnLED, LOW);
      delay(50);
      digitalWrite(grnLED, HIGH);
    }
    LEDcounter = 0;
 }

}

Adafruit Monochrome 128×32 OLED graphic display

Dave — Sun, 04 Mar 2012 21:57:58 +0000

I recently got my hands on the Adafruit Monochrome 128×32 OLED graphic display for my next project. This is a 128×32 OLED B+W graphics chip and it’s tiny! Don’t let its size fool you however. Being an OLED display, text/graphics contrasts well against the black background. My initial intent for this display was to use it to provide information to you GPS Red Light Camera project. It’s job would be to provide key information such as; the distance to the next red light camera location, the direction of the vehicle (and possibly direction of the camera later on), speed, # of satellites, as well as Lat and Log. However, after some dry runs, I found that reading the information was too difficult if it was sunny out. Of course the obvious holds true that I should not be taking the time to read this sort of info while driving anyhow. The intent was more of an info display for viewing while stopped etc. However, the purpose of this write-up is not to discuss the merits of these things, but rather the quality of this display. More info on the project will come soon.

So, how about the quality. My first test was take some graphics and try to render them to the tiny screen. Keep in mind we are working with 128W x 32H pixels here folks. The Adafruit tutorial references a handle little app called LCD Assist that allows you to convert a monochrome bitmap to a character array which you can dump directly into your sketch and have it display the image. The image to the right shows a rendering of a car. The pixelation that is showing is due to my resizing the original image down to something that I could fit on the screen. The two lines are drawn using a built-in drawline function. The second image shows the rendering of text and variables to the screen.

Example (draws Latitude and Longitude and their related values):

//latitude

ftoa(cVal, flat, 2);

oled.drawstring(0, 3, “Lat:”);

oled.drawstring(25, 3, cVal);

//longitude

ftoa(cVal, flon, 2);

oled.drawstring(65, 3, “Lng:”);

oled.drawstring(90, 3, cVal);

Edit: I’ve recently added this display to my Temp / Humidity Monitor.

The good:

At $17.xx, this is reasonably priced for a small, crisp, thin, OLED package.
As always, Adafruit does a great job with providing drivers, samples, and a tutorial to help even the newest of noobs get this thing up-and-running.
It’s thin – really thin. Great for small projects where space is limited but you want to dump lots of info to the screen.
Four mounting holes are provided on the board. It’s hard to tell, but the above OLED is mounted to a piece of clear acrylic.
Having the connections all broken out (and labeled) to a header is a must have for those of us who cant work with those tiny ribbon connectors.
Headers are also supplied – its nice to see small added touches like this and Adafruit does this with most all of their products. The passion shows through. It would be a shame to wait a week or so to find out you don’t have a spare header laying around and your favourite electronics store is closed for the day!
Support! Let’s not forget the intangibles – Adafruit had an excellent forum where you can post your questions and get answers fast. It’s an excellent community and everyone there is very welcoming and want to help. Even Adafruit staff often weigh in to offer support.

The not so good:

Wiring: Rrequires a lot of wires – a total of 7. However, this is to be expected given the nature of what it is. I managed to find a flat-wired CAT5 cable in my search for something small and flexible. (The options are limited if you want to keep the cable to a minimum). The problem with this particular cable was that the encompassing insulator is moulded around all 8 internal wires. After carefully stripping back all 8 on both ends, I figured I had to find something else if I was going to do this again (which I am – more in that in another post). As irony would have it, I later came across these. Already ordered 4 for next time around! An aside note: I like to look of people’s faces when they see me take apart things immediately after they arrive. The look of why!? Then they get it once they know what I do for sh*ts and giggles… err… I mean my hobby.
Sunlight: It was difficult to view the text in bright sunlight while in the vehicle. This is part due to its size and secondly that you can only get so much contrast with this (or most any other) display. I am sure that if I was able to inset the OLED in some sort of compartment, the result would be much better.
Size: This is a tiny OLED. However, I knew that going in so I can’t really complain. I put this here as it is important to know what you need going into a project. This unit works great if you are working with a project that needs to be small. If you want something a little larger, Adafruit sells a 128×64 OLED that is the sibling to this one. I decided to take another leap and am currently working with the 1.8″ TFT LCD display, and am already very impressed with the result. More on this later.

Other thoughts:

For simple displaying of text, the provied driver works fine. However, as part of my project, I was animating a road against a vehicle icon and it was too slow for my needs. I followed the simple instructions on this simple tweak you can do to use hardware SPI to speed things up. Once I did this, it ran much faster and supported the necessary animations I was doing.

Review – AVAGO – ASMT-LW60 – LED Fibre Optic Strip

Dave — Sat, 14 Jan 2012 13:43:00 +0000

I’d say that LEDs have been one of the fastest spreading new technologies in the last 10 years. Consider now that most cars are being manufactured with LED lighting for all the turn/marker/brake/DRL lights. They have even made an impact with home lighting – even though people are being gouged with inflated pricing (IMHO) from places like Home Depot, Rona, Lowes etc.. This will change as LEDs become mainstream… Just wish I had invested in those companies who first got on the bandwagon!

Anyway, I decided to go away from the typical LED strip and try something new. The Avago ASMT-LW60′s are classified as LED strips, but I am not sure I agree. They are unique in that they use fibre optics to provide the illumination while a tiny SMD LED is buried inside each end of the light unit.

These little guys are about 15cm in length and the LED emitters are tiny. They would fit well in tiny spaces. As I write this, one use came to mind – if you are looking to illuminate things such as car ignition switches, or car AC/heater vents, these would be ideal as you can stick them around the inside as they are small and thin. What is also nice is the fibre optic flex tube is clear when not illuminated.

In order to use these guys, you can power from one or both sides. This is easier to do if you wrap them around something circular and both ends meet at the same place – just parallel the connections to 12v and your’re done. However, if you are setting them up in a linear fashion, you will need to run a set of leads to both ends to illuminate both LEDs.

Features / Specs:

LED STRIP, 2 LED, WHITE
LED Module Type: Plug & Play
LED Color: White
Power Module Configuration: Strip
Supply Voltage: 12V
Forward Current @ Test: 20mA
Power Rating: 363mW
Operating Temperature Range: -30°C to +60°C
Color: White
RoHS Compliant: Yes
Datasheet

The Good:

These things are cool. Although I have not come up with a plan yet, I KNOW I will have a use for these at some point.
Each side of the end modules has a tiny hole, so you can string these together in series (the fibre cable part).
Each perf board has solder points for + and – clearly marked.
The light is a nice white light (no blue and no yellow). Perfect for clear illumination of objects in the dark.

The Not So Good:

They are fagile. The fibre flex cable came out of one of the end units shortly after I unpacked them. I know that I must have pulled the two apart, but it was not much force. The rest of the connections were ok. I fixed the problem with a little silicon and slipped the fibre cable back into the socket with ease.
At 12v, these little units are not bright – don’t go looking to provide oodles of illumination here. However, they do illuminate the area they are around well enough.

Summary:

I can’t wait to use these in something. Look around my blog and you will see the variety of LED mods I have done to my 12′ Juke. I am sure these guys will find a place in my car. There has been a lot of discussion around the lack of lighting for the door window/lock controls on the driver’s side. These units may be a perfect solution for this since you can wind/run them around the innards due to their size and flexibility. I just have to see if the stock buttons are the types that can be illuminated from behind… As for pricing, these are about $6.50 USD at the time of writing. Not bad for a specialized solution.

Review – OPTEK – Warm White LED Strip

Dave — Sat, 14 Jan 2012 12:58:28 +0000

Lately, I’ve been toying around with different LED strips for my projects. I’ve had the chance to use a variety of LED strips (both RGB, and single colour types). They come in many flavours – water proof, 3m-backed, silcone encased, sealed, non-sealed, exposed etc. All have their advantages / disadvantages.

In this case, I am reviewing the warm white LED strip from Optek. The unit came well packaged from Newark. Typically when you get strips like this, they come of a larger LED strip roll (usually 5 meters), so the product often looks like it was cut with a set of scissors – no big deal.

Features / Specs:

Part #OVQ12S30WW7
LED STRIP, 30 LED, WARM WHITE
LED Module Type: Board + LED
LED Color: Warm White
CCT: 3300K
Luminous Flux @ Test: 60lm
Power Module Configuration: Strip
Supply Voltage: 12V
Power Rating: 1.6W
RoHS Compliant: Yes
Datasheet

The Good:

Light colour is as specified – warm white. This strip would serve well in locations where you want to cast a warm natural light (eg under kitchen cabinets).
Although, these are not as bright as their 5050 SMD counterparts, they are softer on the eyes.
Comes with 3M tape on the back. I have not tried to secure the strip to anything since I haven’t decided a use for it yet. I’m sure it’ll find its way in my car, or my workbench… somewhere…
The unit is less than 3mm high x 8mm wide, so they can be tucked away pretty much anywhere.
Price is very reasonable.

The Not So Good:

These LEDs are not bright. Don’t expect to use these where you are looking to illuminate objects from a distance. Only a few feet max.
They are not waterproof. Depending on your situation, this could make or break this buy.

Summary:

If you are looking for a LED strip that can be stuck on pretty much any surface, that casts a nice warm glow and has a small footprint (width and height), this is a nice choice. If you are looking to mount these in an environment that has to look clean, don’t forget that you will likely have to create some sort of carrier or barrier for these (so viewers won’t see the raw LEDs and the copper strip).

Review – Optek LED Strip

Dave — Sat, 07 Jan 2012 01:43:29 +0000

After completing my Juke footwell / glove box LED mod, I decided that the footwell LEDs just were not bright enough. I came across these Optek 3 LED white lights from Newark that have just the right white light and luminosity. These LED bars are built tough. The LEDs appear to be set in a hardened liquid plastic. Wires run in one end and out the other – it seems that these strips were built as a series set of 3x LED bars and cut to order. I ordered 2 and both were joined together. Before installing them above the footwell area, I had to do something about the white. After masking off the LEDs, I gave them a few coats of Plastidip to make them black.

I am impressed with the end result. I was after something that would provide nice white light when I am looking for something down in the footwell area during the dark… They cast a bright wide swath of light to illuminate the entire footwell area. They also cast enough light to see under the seats as well.

Illumination with the Optek 3x LED Bar:

The original LED illumination:

Nissan Juke – Footwell & Glove Box LED Lightning

Dave — Sat, 26 Nov 2011 00:10:07 +0000

Next on the block – adding LEDs to the foot wells and glove box. (Prev mods: LED Tails and Rear Passenger LED mods)

This mod can be especially useful this time of year up here on the 49th parallel since we are pretty much in darkness @ 5PM during November. All to often I drop something down near my feet and have to go looking for it. The light that casts from the map lights does not reach the areas down near the front driver/passenger foot wells, so I decided to add a few tiny LEDs to shed some love in the area when needed. In addition to this, the Juke comes with a MASSIVE glove box and no light. So, it was natural to throw a small LED strip in there as well. Both sets of LEDs are hooked up to a custom controller that uses an ATTiny85 and touch sensitive pins to control on/off states (I’m not one to go with status-quo, so the standard on/off switch would not cut it for me).

The switching unit (below) has 2 pairs of pins and 1 switch. The switch is used to control the rear passenger LED and is discussed here. Each pin pair make up a galvanic touch sensor that use the conductive abilities of skin to bridge the connection (reads – won’t work with gloves). Touch them once and the LEDs ramp up (on), touch them again to power them off. The top pair control the foot well LEDs, the bottom controls the glove box LED.

The switch controller installed – top left. Nissan was nice enough to leave us a blank, so naturally, I had to find a use for it!

LEDs:

I’ve replaced the original LEDs with a set of Optek ones. Details here.

New:

Old LEDs:

Below are the first run LEDs I used for each foot well. Yes, that is LEGO you see.. Have a look around this site to see why.. I can always rely on my LEGO inventory for parts when I need to do some sort of off hook-up, or mount. In this case, the pivot connectors allow me to swivel the LEDs to different positions – yet they are strong enough to hold their set position. They also allow me to quickly disconnect the LEDs in the event I have to remove something, such as the glove box. Some Goop glue and it’s all good.

Another pic showing the left and right foot well LEDs (old) .

Right footwell illuminiated (old):

Controller:

I did not take any pics of the controller, but it is loosely based on this. The idea being that the natural galvanic response of your skin acts to complete the circuit when touching the two touch pads/pins. This triggers a state change that the micro controller can interpret and act on. In this case, I have it watch the pin inputs for a voltage change and trigger the LEDs on (when the state is off) and vice-versa.

The code is pretty straight forward – monitor the 2 sets of touch pins for a change in voltage, when this happens to either, trigger the related LED output pin to ramp up to full brightness. Touch a pin set again, turn the related LED output pin off. A timer has also been used to automatically turn off either light after 5 minutes.

Code:

//uses button to dim LEDs in steps. Coded toward ATTiny85
//v6 updates to v5 include adding timer capabilities to allow LEDs to auto shut off after an elapsed time. Will prevent from leaving lights on if not hooked up on accessory mode in car.

#include // important note - MS2Timer2 affects PWM of PIN 3 and 11, so don't use them for PWM output.
#include
#include

//***********************
//CONFIGURABLE VALUES

int tchValSens = 990; //val 1023 is open circuit. 0 is closed. Dry fingers use 900, humid, damp, use 100

//************************

#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= -_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif

#define statusLED PB2 //Digital In D1 - used to show timer countdown.
#define ledCtrlrA PB0 //Digital In Pin 1 MUST BE A PWM PIN (oddly my PWM pin#11 does not work) - controls IRF530 transistor > LED lights
#define ledCtrlrB PB1 //Digital In Pin 0 MUST BE A PWM PIN (oddly my PWM pin#11 does not work) - controls IRF530 transistor > LED lights
int tchPadA = 3; //defined as Pin 3 (analog input 3) - physical pin ? on ATT85
int tchPadB = 2; //defined as Pin 4 (analog input 2) - physical pin 2 on ATT85

int i = 0;
int counterA = 0; //Counter used for dimming feature
int counterB = 0; //Counter used for dimming feature
int dlyTime = 20; //delay timer (for overall loop) in MS.
int statCounter = 0; //counter for the status LED.
int tchValA = 0; //Holder for tchValA
int tchValB = 0; //Holder for tchValB

int ledStateA = LOW; //Holds the current state of the LED lights (HIGH=on LOW=off)
int ledStateB = LOW; //Holds the current state of the LED lights (HIGH=on LOW=off)

int brightnessA = 0; //Brightness value for dimming the LED 0-255
int brightnessB = 0; //Brightness value for dimming the LED 0-255
int startBrightness = 0; //Initial brightness of the LED 0-255
int statusLEDFlashDur = 100; //In Milliseconds - Flash period for MSTimer2 to flash the LED in ms. 100ms

long previousMillis = 0; //Store last time LED was updated
long shutoffStartMillis = 0; //Store the value to start the shutoff timer from in Milliseconds.
long shutOffDelayMS = 300000; //In Milliseconds - Determines how long to keep LED system on (after shutoff timer clicked) in Milliseconds 10000 (10sec), 60000 (1min) 300000 (5min)

//boolean sleepEnable = 1;

void setup ()
{
//Serial.begin (9600);
pinMode(tchPadA, INPUT); //Setup the tchPadA as an Input
pinMode(tchPadB, INPUT); //Setup the tchPadB as an Input
pinMode(statusLED, OUTPUT); //Setup the statusLED as an Output
pinMode(ledCtrlrA, OUTPUT); //Setup the ledCtrlrA as an Output
pinMode(ledCtrlrB, OUTPUT); //Setup the ledCtrlrA as an Output
}

void system_sleep()
{
sbi(MCUCR,PUD); //Disables All Internal Pullup Resistors
sbi(GIMSK,PCIE); //Enable Pin Change Interrupts Interrups
//add interrupt on 2 pins:
sbi(PCMSK,PCINT3); //Changes Interrupt to pin 2 on physical chip (PIN 3 Analog Input 3) (see http://hlt.media.mit.edu/wiki/pmwiki.php?n=Main.ArduinoATtiny4585)
sbi(PCMSK,PCINT4); //Changes Interrupt to pin 3 on physical chip (PIN 4 Analog Input 2)
cbi(ADCSRA,ADEN); //switch Analog to Digital Converter OFF
cbi(MCUCR,SM0); //Power Down Mode
sbi(MCUCR,SM1); //Power Down Mode
sbi(MCUCR,SE); //sleep Mode Power down enable (Sleep_enable(); should set this-- not tested yet)
sleep_enable(); //Sets the Sleep Enable bit in the MCUCR Register (SE BIT)
sleep_mode(); //sleep begins here
sleep_disable(); //Coming out of sleep
sbi(ADCSRA,ADEN); //switch Analog to Digital Converter ON
cbi(MCUCR,PUD); //Enables Pullup Resistors Again (this should happen anyway, but i have it here for now just in case, haven't fully tested yet)
}

void flash(byte howmany, byte dly) {
for (i=0; i < howmany; i++)
{
digitalWrite(statusLED, HIGH);
delay(dly);
digitalWrite(statusLED, LOW);
delay(dly);
}
}

void rampLEDDownNoff(byte ledPin, byte lval, int dly, byte ledStateWhich)
{
//sleepEnable = 0;
if (dly == 0)
{
analogWrite(ledPin,0);
}
else
{
flash(3, 60);
while(lval > 0)
{
analogWrite(ledPin,lval);
lval--;
delay(dly);
}
//make it is all the way off
digitalWrite(ledPin, LOW);
}

if (ledStateWhich == 1)
{
ledStateA = LOW;
}
else
{
ledStateB = LOW;
}
//sleepEnable = 1;
}

void rampLEDupOn(byte ledPin, byte lval, byte ledNormVal, int dly, byte ledStateWhich)
{
//sleepEnable = 0;
if (dly == 0)
{
analogWrite(ledPin,255);
}
else
{
flash(3, 60);
while(lval < ledNormVal)
{
analogWrite(ledPin,lval);
lval++;
delay(dly);
}
}
if (ledStateWhich == 1)
{
ledStateA = HIGH;
}
else
{
ledStateB = HIGH;
}
//sleepEnable = 1;
}

void loop (){

tchValA = analogRead(tchPadA);
tchValB = analogRead(tchPadB);

/*
Serial.print("touchValA: ");
Serial.print(tchValA, DEC);
Serial.print(" touchValB: ");
Serial.print(tchValB, DEC);
Serial.print(" TriggerVal: ");
Serial.print(tchValSens, DEC);
Serial.print("\n");
*/
/* continue to watch the touch for a capacitance change, when this happens determine
* what the intent is:
* a) user is holding finger on sensor, ramp LEDs up until they remove their finger.
* b) user tapped sensor, so turn lights on full (basic on/off)
*/

//using a threshold value to determine when the touch sensor is being pressed/tapped.
//average normal values hover around 480-490, then when tapped, are about 680. However
//seems to be some sort of leak or interferance in the circuit as sometimes the circuit
//can be made to jump to higher values and trigger the below statement to execute.
//this was noticed by simply waving hand near the transistors/touch sensor.

if (tchValA < tchValSens) //use this if modified R3 (2.2K) and T2 Emitter grounded direct to 0V. Arduino pin to Collector out of T2 (will be HIGH)
{
//when the sensor is either touched or pressed for a longer perior, the below statement triggers.
//when a finger is held to the sensor, the time difference between current and previous Millis is very small
//(as its resetting through every cycle which is approx 50ms) so, the first statement executes which causes the
//LED power to ramp down from high to low
//when tapped quickly, the intent is to toggle the LED on/off. This is triggered when the current and previous
//Millis are further apart. Then the state of the LED is checked and toggled to determine if it needs to be switched
//on or off.
//flash(3, 60);

//check state and turn led on or off - if the LED is off turn it on and vice-versa:
if (ledStateA == LOW)
{
brightnessA=startBrightness;
counterA = 0;
shutoffStartMillis = millis(); //get a start value to start the countdown from.
MsTimer2::start(); //start the timer to trigger the shutoff
rampLEDupOn(ledCtrlrA, 0, 255, 2, 1); //5
}
else
{
brightnessA=startBrightness;
counterA = 0;
rampLEDDownNoff(ledCtrlrA, 255, 0, 1); //10
MsTimer2::stop(); //shut off is reset any time user changes something
}
flash(3, 60);
}

if (tchValB < tchValSens)
{
//Check on the second touch sensor
//flash(3, 60);

//check state and turn led on or off - if the LED is off turn it on and vice-versa:
if (ledStateB == LOW)
{
brightnessB=startBrightness;
counterB = 0;
shutoffStartMillis = millis(); //get a start value to start the countdown from.
MsTimer2::start(); //start the timer to trigger the shutoff
rampLEDupOn(ledCtrlrB, 0, 255, 2, 2); //5
}
else
{
brightnessB=startBrightness;
counterB = 0;
rampLEDDownNoff(ledCtrlrB, 255, 0, 2); //10
MsTimer2::stop(); //shut off is reset any time user changes something
}
flash(3, 60);
}

//this will shut down the LED after the ellapsed time period. Rules - if the shutoffStartMilis has been set AND the time ellapsed is greater than the delay time. Shut off the LED
if (shutoffStartMillis != 0 && millis() - shutoffStartMillis > shutOffDelayMS) //if shutoff time has elapsed, turn the LEDs off 1000ms = 1 second
{
if (ledStateA == HIGH)
{
rampLEDDownNoff(ledCtrlrA, 255, 10, 1); //10
}
if (ledStateB == HIGH)
{
rampLEDDownNoff(ledCtrlrB, 255, 10, 2); //10
}

shutoffStartMillis = 0;
MsTimer2::stop();
}

//we dont need to be polling with every cycle, so slow things down a bit. 20 original value.
delay(dlyTime);

//pulse the status LED every second. Use the delay value to calculate into approx a flash every second.
//if (statCounter * dlyTime >= 1000)
// {
// flash(1, 60);
// statCounter = 0;
//}

//statCounter++;

// system_sleep(); //Runs the system_sleep() function

}

Nissan Juke – Interior LED Illumination – Rear Passenger Light

Dave — Sun, 13 Nov 2011 12:27:17 +0000

I just finished adding LEDs to the tail lights, and now its time to move on to the interior. For those of you who have a Juke, you can sympathize with me on this – the Juke is a great vehicle, but it is lacking in some very basic necessities (e.g. armrest, removable cup holders, and… a rear passenger light!). This has been further compounded by the fact that I have 2 children in child seats that can’t quite do up their own seat belts yet. …and the seat buckles are buried flush with the seats! (NISSAN!) …and I can’t see squat! Here is my solution to the problem:

LED Rear Passenger Light

This was a simple mod. The hardest part was taking the plunge and cutting into the roof material. Since I like the way the front map lights came on (and faded off) with the opening of the driver door, and that they also have a switch to turn them on permanently (or off), I wired the rear LED light to the center map light. In addition to this, I also linked the light to a switch (detailed below) that I can used to separately control the rear passenger LED light only (e.g. when the kids are sleeping during a late night out and I dont want the rear light to come on when the door opens).

The Build:

I picked up a mini recessed LED (MRL-xW9SMD – in warm white) from SuperBrightLEDs. It was a perfect fit as it has a low profile and rubber surrounds so that it would fit without any glue.

I have the Juke SL with a sunroof and needed to first make sure that there was enough room. After pulling back the sunroof opening surround, I was able to peek back to see that, with the sunroof open, there was still about 1″ clearance. The only tweak I had to do is bend the wire coming out if the LED 90 degrees and secure it to the roof inside. The first step – measure to find center and score the cutting area with a protractor.

The hardest part was doing the cut – not because it was hard, but because it was a point of no return.

The opening. The nice thing about this LED is that you do not have to worry about a perfect cut since it has a wide trim around the outside.

The final result. To install the LED, I just had to push it up into the ceiling while putting pressure downward from the inside (you are going to want a pair of small arms for this – else a long piece of 1″x2″ wood):

Wiring the LED was pretty easy. I ran the wiring around the driver’s side and used duct tape to secure it to the top of the ceiling panel. You can route the wires in such a way that they don’t interfere with the sunroof. To handle the addition of the switch, I spliced a connection into the “+” line and took it down the front pillar and into the area of the switch plate, then ran the rest of the wire to the map light.

Removal of the map lights is easy. First remove the clear surround by pulling down with your fingers around. To remove the light, there is a pressure tab on the right side that you just pull inward (toward the light) while pulling down. The light will come out of the ceiling easily.

To wire up the rear LED, I simply soldered the two wires directly to the brass power bus bars inside. You could choose to wire it up to any one of the 3 lights. In my case, I wanted it wired to the center light and also wanted to ensure that it would follow the same ‘rules’ when you switch between the 3 power positions with the button that is available there.

As mentioned earlier, I also wanted to be able to separately turn the rear LED off when all other lights are on. The Juke comes with a blank switch plate to the lower left of the steering wheel (near the mirror controls0. I popped it out to add the switch. The switch is the black nub at the bottom. A SPST latching switch so that it can be left on ‘always on’ or ‘always off’ position. Note – the two sets of gold pins you see there are for my next LED mod. Stay tuned for more on that later. (Spoiler – they are touch capacitive switches).

Another view showing the switch depth. That black rubber pad is from an old Thinkpad UltraNav button that I had sitting around. I also spray painted the shell of the unit with PlastiDip.

This is the panel to the left of the steering wheel. To get it out, you have to pull out along the top with your fingers. It pops most of the way out, but I have not figured out how to completely pull it off (since it wraps around below the steering column). This was not a problem since I only need to get at the tab to pop out the blank plate (just to the right of my finger). BTW – if you want to remove the blank plate, use a small screwdriver to push down on the tab at the top and push the plate into the back (dont pull it out as it does not come out this way).

I am impressed with the end result. Now there is enough light to see the seats, beside the seats and even in the foot area. Not too bright either. Note – the pictures don’t do it justice. It is brighter than it appears and casts more light in areas that appear darker in the pics.

Nissan Juke – Custom LED Tail Lights

Dave — Wed, 09 Nov 2011 11:49:53 +0000

I’m a sucker for not conforming to status quo when it comes to my toys.. This includes my new Nissan (2012) Juke. In this mod, I added a set of LED light strips to the tail lights with a twist – I wanted to also monitor and react to braking to enhance the effect. I decided to go with an ATTiny85 using the Arduino core. It only needed 1 input from the 12V brake power and 1 PWM output to control a MOSFET which in turn powered the LED light strip @ 12V. I built one controller per tail light. Check out the video to see it in action:

Some pics of the final result:

The Build:

I Ebayed a pair of red LED side-emitting LED light strips from overseas. Side-emitting are necessary due to the design of the Juke tail cluster lense. The mounting of the strip allows these LEDs to shine toward the back of the car rather than out the side.

Mounting the light strip was a bit of a challenge. Not so much in the actual mounting/gluing but rather in the strip quality. When mounting the first strip, it broke half way along the strip and killed power to the downstream LEDs. Poor build quality as it broke along one of the ‘cut lines’. I had to scrape away the clear rubber coating and solder 2 new tiny connectors and re-link the strip back together. All while half the strip was already glued to the tail light. Fun. Guess this is what you get for buying overseas quality…

To mount the strip, I used a glue gun and tacked along every inch or so. The strip itself also has an adhesive backing, but I dont imagine that will last long given that this LED strip will be exposed to the elements (yes, even though this appears to be inside the tail light, there is no rubber seal when mounted back to the vehicle – there is an open gap which will allow the elements in – this is by design, but not sure why Nissan did it this way.

Locating connections for the controller was straight forward. There is 12V main (from the parking light), 12V brake (from the brake light) and ground. The following shows the wires for each of these:

The Electronics:

The circuit is pretty straight forward. The heart of the unit is the ATTiny85. 12V power comes in when the parking lights are turned on. This is dropped to 3.3V via a voltage regulator to power the ATTiny85. When the brakes are applied, 12V comes into the optoisolator to allow the ATTiny to detect when the brakes are applied. Since the ATTiny85 can only accept input up to 5V, I needed a way to drop the 12V in from the brakes to something more manageable. I could have used a voltage divider, but I decided the optoisolator approach as it allowed the brake circuit to be completely separate from the parking light circuit. When 12V is applied to the optoisolator, it triggers its output to go low (0V) which is connected to the ATTiny85′s input pin (normally high). This triggers the controller to go from 75% LED power to 100%. The circuit also channels 12V directly to a MOSFET which is controlled by the ATTiny85′s PWM output pin. On normal startup, it PWM’s the LEDs up to 75%. When brakes are applied, it goes temporarily to 100% then back.

The controller. In order to make the circuit weather resistant, I dipped it in PlastiDip. I still have the ATTiny85 and optoisolator chips exposed as I may want to change the code before committing.

/*
Control LED light strip via 12V power provided by parking lights (rear red). Additionally,
the actuation of the brake lights will also illuminate the LED strip at a brighter level to allow it to
enhance the effectiveness and visibility of the rear brake lights
Design:
12V main to power the arduino (ATTiny85) (via 3.3v regulated circuit). 12V main also directly powers the LED light strip.
However, the Arduino will be used to control a MOSFET via PWM to act as a light level controller. On start
the LEDs will automatically 'ramp up' to specific light intensity, but not 100% power. When the brake lights
are applied, the Arduino will detect this on an input pin and turn the LEDs on to full brightness, and then
back off once the brakes are no longer applied.
*/

byte ledMaxVal = 255; //Full LED brightness level - to be applied when brakes are on.
byte ledNormVal = 100; //normal LED light level.
boolean ledState = 0; //The current state of the LEDs. 0=off 1=on
boolean ledAtMax = 0;
//boolean brakeState = 0; //The current state of the brake detected on brakePin. 0=off 1=on
//int brakeV = 0; //Mapped value converted read from brakePin mapped from 0-1023 to 0-5V. Note Brake pin has a pull down resistor of 10K to have it read 0 by default.
int flashCounter = 0;
int brakeThresh = 500; //brake threshold. Pin is high. When brakes applied, pin drops to near 0V. value in mV

//Configurable values
const int LEDPin = 1; //output pin to control MOSFET switching to power the LED strip from 12V.
const int brakePin = 3; //pin that will detect when brake lights are on.
const int LEDstatPin = 0;

void flash() {
digitalWrite(LEDstatPin, HIGH);
delay(20);
digitalWrite(LEDstatPin, LOW);
}

void rampLEDDownNoff(byte lval, int dly)
{
while(lval > 0)
{
analogWrite(LEDPin,lval);
lval--;
delay(dly);
}
//make sure they are all off
digitalWrite(LEDPin, LOW);
ledState = 0;
}

void rampLEDupOn(byte lval, byte ledNormVal, int dly)
{
while(lval < ledNormVal)
{
//give the LED a pulsing look
//if (lval > 20) {
//analogWrite(LEDPin,20);
//delay(5);
//}
//comment the above to get rid of the LED pulsing.

analogWrite(LEDPin,lval);
//analogWrite(LEDstatPin, lval); //flash the status LED to show that the LEDs are ramping up.
flash();
lval++;

//often, the brake lights will be applied on vehicle start. If this is the case, then just go to full power on the LEDs and
//stop the remp-up procedure
if (analogRead(brakePin) < brakeThresh) { // bail out on sensor detect
analogWrite(LEDPin,ledMaxVal);
ledState = 1;
break;
}

delay(dly);
}
ledState = 1;
}

void setup()
{
//Serial.begin(9600);
pinMode(LEDPin, OUTPUT);
pinMode(LEDstatPin, OUTPUT);
pinMode(brakePin, INPUT);
}

void loop()
{

if (ledState == 0) //LEDs are not on, turn them on.
{

rampLEDupOn(0, ledNormVal, 20);
analogWrite(LEDstatPin, 100);
}

else if(analogRead(brakePin) < brakeThresh) //ledState would be 1
//Optoisolator keeps brakePin Hi at 5V. When 12V applied (brake light), pulls brakePin low. Hi=1023. Just picked an arbitrary # of 500
//if (analogRead(brakePin) < brakeThresh && ledState == 1)
{
//brakeState = 1;
analogWrite(LEDPin,ledMaxVal);
ledAtMax = 1;
}
else if (ledAtMax)
{
//brakeState = 0;
analogWrite(LEDPin,ledNormVal);
ledAtMax = 0;
}

//Serial.print("brkState=");
// Serial.print(brakeState, DEC);
//Serial.print(" brkPinV=");
// Serial.print(brakeV, DEC);
//Serial.print(" brkPinRaw=");
//Serial.print(analogRead(brakePin), DEC);
// Serial.print(" flsCnt=");
//Serial.print(flashCounter, DEC);

//Serial.println();

flashCounter++;

if (flashCounter == 20)
{
flash();
flashCounter = 0;
}

delay(20); //give the processor some breathing time.
//brakeV = 0;

}

Lessons learned: I should have learned this one a long time ago – don’t rush. I figure I will have to re-mount the strips again as I don’t like the fit. The Juke tail innards is too tight in some spots to allow the light strip to fit nicely and consistently inside and pointing to the rear. I plan to take a dremmel in there next time to open it up a bit. I also want to figure out why there is a lag in timing when the brake light is applied and when the LED goes to 100%. When being tested, it was immediate.

After watching the videos a few times, I noticed a lag in the time from when the LED strip comes on and when the actual brake light fully illuminates. I think this is due to the time it takes for the incandescent bulb to reach its max brightness. However, the LEDs are able to reach instantaneously. I’ve re-programmed the ATTiny to delay the LED 75% to 100% trigger timing by a few hundred milliseconds to make up for the brake light bulb and come on at the same time.

Future ideas - I am waiting to see if the digitally addressable RGB LEDs can be made thinner/less wide to fit the Juke tails. I have some ideas about the power on phase (eg have the LEDs ramp up or down one LED at a time, allow interaction with the brakes (red) as well as the signals (amber)…

Dual LED Desk Light Controller – Arduino

Dave — Thu, 24 Mar 2011 02:14:05 +0000

I’ve been involved in microcontrollers for some time – but of the LEGO Mindstorms flavour (and BASIC Stamp to a lesser extent). Lately, I’ve jumped on the Arduino bandwagon. I’ve always had the natural nack to fix pretty much anything that has batteries or a plug running out of it. As the Arduino revolution has picked up dramatically over the past few years, so to has my desire to do DIY projects around the house. At some point in the future, we plan a kitchen reno. Part of that reno will the addition of under-cabinet LED lighting. Since that is far off, but I also had the need for better lighting in my office, I figured this would be a great time to proto something for the kitchen upgrade, while making something functional for the office. So, here it is..

TouchPad Mapped Areas

At first, I did not really have a plan. I knew I wanted some sort of switchless control of the LEDs, and to illuminate the main part of my desk. My initial prototype used a capacitive touch control using 2 copper tubes mounted on the project box. The idea being bridging the two tubes with your finger, the LEDs would dim up/down. You could also to a tap to turn them on (ramp up) and another tap to turn them off (ramp down). I was nearly done, but while perusing the web, I came across someone using an arduino and a synaptics touchpad together for another purpose – which got me thinking (smoke coming out of ears). I also found the need to want to control more than one light at my desk. I have multiple shelves and, even though the desk area can be illuminated, the shelf above are dark at night. This is also the place where all my electronic bits manage to find themselves when Im tinkering – and I often have to go fishing around for a flashlight to find bits I’m looking for. The addition of a touchpad provides many possibilities here.

When connected to the Arduino, a Synaptics touchpad can be used in two modes. Relative mode is the norm. It works like you would expect it to on a laptop. No matter where you put your finger and move it, your mouse will move from its current point in the direction you move your finger. Well, I’m not using a computer or moving a mouse around. I needed the unit to work in absolute mode. I need to know the exact X/Y coordinates of where my fingers were moving. Knowing this, I could create mapped areas to monitor in the Sketch and perform various actions when movement was detected in those areas. Thanks to this Instructable, the users Sketch contained the necessary commands to put the Synaptics touchpad in Absolute mode. The sketch uses the PS2 library as well. More on this later.

After testing a touchpad from my old and trusty Compact N600c, I decided to pickup a few extras from Ebay. I managed to pickup one from a Gateway W340UA and a Gateway Solo unit ($5 each). Both units had the Synaptics chip I was looking for, but I am sure there are many other Laptops that have similar units (eg IBM T42 does), and quick Google search will yield lots of results. I like this touchpad as it already has the arrow markers for the dimming feature that I wanted (more on this later re X/Y values). The next image shows the pinouts and trace paths for the Gateway W340UA touchpad that I used for this project. I have toyed with 4 different Synaptics touchpads and found them all very similar in their layout.

TouchPad Pinouts

The pinouts are straight forward: +5V, GND, Data and Clock. Most sample sketches out there (especially the PS2 library) will have info on where to hook each of these up to on the Arduino. You can also download my sketch for this project further down below. Synaptics was even nice enough to give us DIY’ers little pads to solder to. These are evident for the Data and Clock points below. Note that, for the 5V power, you should track back as far to the ribbon connector as you can. There is at least 1 resistor and capacitor along the path to the pin on the Synaptics chip. Don’t bypass them if they are there. The Data and Clock pins are ok to go direct to the Synaptics pins. Also take note of the reference dot on the Synaptics chip – this typically refers to the starting location of PIN#1 on the chip.

After soldering the pin connections on the back of the touchpad, I had to find a way to mount it. I thought of different ways to do this (embedding it on the desk, on the side, etc etc). Since I had a lot of metal mounting points aronund me (filing cabinet, side shelf beams, shelves), I just decided to put some magnets to the back of it. Of course, since my roots are with LEGO I could not fore-go the bastardization of a LEGO plate to mask the circuit board and soldering I had done with that fine blue wire (figure it must be 30-something gauge – it’s like thread!). So, I took to the dremmel and cut up a black plate and glued it to the back of the touchpad. Now, if I want to in the future, I can build any type of mounting system I want – using LEGO!

Touch Pad Back - Mounting

I am a minimalist when it comes to designing circuits. I don’t like large boxy control units. One day, I will perfect my SMD abilities and make these things even smaller. For now, I had to settle with a project box that I’m pretty happy with – approx 3″ x 2″ x 1″. I managed to cram in an Arduino Nano, 12V power connector, regulated 5V supply, 4x IRF 530′s (to control the LEDs), status LEDs and a number of connectors. It’s tight. I know what you Arduino junkes are thinking.. What a waste of a Nano. I’m cool with that. This is the first, and in future projects, I plan on creating my own Atmega based circuits. I’ve already cobbled together a staging board that I can use to program future chips. In the case of this circuit, I needed to use the PWM abilities of the 168/328 chips. I’m using all available PWM pins (4 of them). Again, Arduino junkies, I know what you are thinking – there are more than 4 PWM pins. Yes there are. However, I’m using the MSTimer2 library which kills the PWM of pins 3 and 11 for this project – I could have used another for the secondary LED lights, so if you have any ideas, share them up in the comments.

LED Light Controller project box.

Looking at the Main Board below, I’ve labelled all the main parts. I used IRF530 MOSFETs to allow the Arduino to cleanly regulate 0-12V to each of the R, G, B on the main LED light bar and 1 IRF530 to do the same for the second LED light. In the case of the second LED light, I used a leftover strip of 3 RGB LEDs. In this case, I did not care to individually control Red, Green and Blue. What I did was simply use the IRF530 to power 0-12V to the LEDs on 2 wires. On the LED strip itself, I bridged R+G and from RG added a 330 Ohm resistor to Blue. This reduces the power output of blue which gives the light a warmer more natural light (not that bluish white light).

Main Board

I’ve also included a breadboard layout created i Fritzing. Although Fritzing has some bugs, its a great app for rapidly producing usable breadboard, PCB and Schamatics of your circuits. I recommend it. I almost forgot to mention the speaker. This was a bit of an afterthought, but i had one laying around and thought it would be good to have some aural feedback when the touchpad was being used. Glad I did it. I have the LEDs ramp up/down and it can lead the user to wonder if it’s working as it can take a few seconds to complete its on/off cycle. This way, I can add beeps and chirps to the interaction of the unit.

Breadboard Layout

The Sketch:

There are a few interesting things I thought I would point out about the sketch:

To turn the Main LED on off – touch the center of the touchpad. The Main LEDs will ramp up to max brightness (more on this later). If they LED is on, it will ramp down to an OFF position.
To manually control Main LED brightness, just slide your finger up/down along the right side of the touchpad (where the arrows are). There was an added bonus to the X values that Synaptics returned to the unit. Any touch to the area of the right band returns an X value of 8176. This way, my conditional check only has to check the 1 X value and a range of Y values. The Y values are mapped between 0 – 255 (the range of power to the LEDs)
Delayed Time off – I have a feature that when the Main LED is on, clicking the top center will initiate a countdown timer of 10 minutes. After which the Main LEDs will turn off.
Secondary LED on/off – clicking the top left corner of the touchpad will toggle the Secondary LED on or off (depending on its current state). I had to play around a bit with debouncing here as the loop cycle is ~20ms as it was catching multiple on/off states (even with fast finger taps). I used a simple delay in the code on this (did not want to get into fancy debouncing – will save that for the kitchen project)
LED Brightness Save – I thought it would be cool to be able to save the Main LED brightness state. Using the right slider, you can adjust the brightness of the Main LEDs. When the desired level is reached, touching (and holding for approx 3 seconds) the bottom left area of the touchpad will save the brightness to EEPROM within the Arduino. The next time the unit is powered up, it will only ramp up to the saved max brightness value. This is persistent even if the Arduino looses power. The only issue is that I can only do it up to approx 100,000 times. Shucks…

Arduino Sketch: LEDLightDimmer11