I wanted something cheap and quick that I could pull out on short notice, turn on and drop into the plants to have a light show for the evening.  I also wanted something that I could whip together quickly.  Can’t really claim this as my idea as its been done many a time… Since I also wanted the components to be water resistant, and I wanted an easy way to power the units on/off, the concept of a Reed switch and magnet came immediately to mind.  The idea being to have a magnet attached to a stick that is stuck into the ground.  Then, when it comes time to put the glowies out, I would just stick them to the magnets.  They would serve 2 purposes; 1) to hold the glowie in the middle of the shrub, and 2) trip the Reed switch to turn the glowie on.  With that plan, I went hunting.   I managed to fleebay some RGB LEDs, reed switches, 2032 batteries (DX) and some coin cell holders.  Total price < $10.  Not bad.  I managed to scrounge the tiny plastic ball casings from some of my kids toys (shhh).   They are perfect casings that just fit the battery holder and bits all inside and are < 1″ in diameter..  The RGB LEDs also have an embedded microchip that automatically slowly cycles them between all level of RGB combination of colours (not just red>green>blue, but everything in between).  This saved lots of time, money and space as the alternative was to cobble together some ATTiny85/25′s and have each PWM the LED’s..  That would have pushed this project into the “not worth the effort territory”.

Anyway, I’m happy with the result.  The glowies are just visible inside the plants, but no too bright that the are a big distraction.  This is an easy project that most anyone with basic soldering skills can do – and for < $10.  Check out the night effect in the front garden below.

Result: Not the best pic, but the glowies have been placed inside each shrub/bush and are noticeable from a distance as shown

BTBotControl is an Android application that allows you to remotely control a micro controller-based robot using Bluetooth (i.e. Arduino).  It also allows you to (optionally) view a video stream from an IPCamera mounted to your robot.  This could be any type wireless IP camera or phone that has the ability to broadcast a video stream/images to the web.  Example Foscam, Ai-Cam etc.

** Looking to see if there is interest for adding LEGO Mindstorms NXT control to BT Bot Control.  Let me know if you are interested or have suggestions. **

Some of the features of BTBotControl:

• Can use Joystick via finger movement, or the orientation sensor on your device.  (default is Joystick mode).
• Supports 8 individual commands via Command Buttons.   4 on by default. 4 more can be turned on in the Settings section.
• Sends the x/y coordinates as positive and negative integers based on 4 quadrants of the joystick.   Data is sent via Bluetooth and can be parsed to set both direction and velocity.  (sample code below)
• Coordinates are generated as X+/- and Y +/-. These are packaged and sent in the following format sX=val,Y=vale  i.e. sX=75,Y=-55e  where ‘s’ indicates the start and ‘e’ indicates the end.
• Command button values are packaged and sent in the following format: sC=[val]e  i.e. sC=2e  where ‘s’ is the start,  ‘c’ indicates the a command button as pressed, ’2′ is the value and ‘e’ indicates the end.
• Configurable Bluetooth packet send interval – used to set the speed (quantity) of packets sent.  Default of 200ms works well.
• Shows video stream of IP Camera mounted to robot. (see FAQ)
• Configurable camera URLs. Remembers last camera connection for easy re-connect.
• Configurable Bluetooth connections.  Remember last Bluetooth connection for easy re-connect.
• Sample Arduino Sketch provided (below).
• Screen auto re-sizes for smaller phones.
• Supports any micro controller that can parse Bluetooth data (bluetooth module required) (sample sketch below).

Note on Lite version:  The Lite version is a fully functional version.  However, Bluetooth data will be sent as ’9′s.  i.e. s9,9e and c9e which will provide you with enough to determine if this app is right for you.  If you like BT Bot Control, the Pro version has full functionality enabled with proper data, and can be yours for less than the price of a coffee.  Also, you won’t be pestered by that start-up message either!  We hope you agree that the features and functionality provided are well worth the pocket change.

Note on Bluetooth: The control distance is dependent on a number of factors including; your Bluetooth device range, battery power, obstacles etc.

Download BTBotControl here:

If you have an feature requests, or suggestions,  please let me know.

Default Mode Joystick Sample Sketch:  BTBotControl12DefaultModeJoystick

Simple Mode Joystick Sample Sketch:   BTBotControl12SimpleJoystickSample

Note:  For this project, I used a Digispark (Arduino-based micro controller).  This sample sketch is targeted for a Digispark (ATTiny85), but was also tested on an Uno, so it should work for most Arduino’s.   If using an ATTiny, remove any Serial.Print statements. Also watch the size of the sketch as there are limitations on the ATTiny85.  

<HTML>
<HEAD>
  <meta name="keywords" content="">
  <meta name="description" content="">
  <meta name="robots" content="NOFOLLOW,NOINDEX">
  <link rel="stylesheet" href="/style.css" type="text/css">
</HEAD>
<BODY>
		  <table align="center" border="1" cellpadding="0" cellspacing="0">
		    <tr> 
			  <td>
			    <img src="http://[YOURCAMERAIPHERE]/snapshot.cgi?user=[USERNAME]&pwd=[PASSWORD]&t=" name="refresh" id="refresh" onload='reload(this)' onerror='reload(this)'> 
  			  </td>
			</tr>
		  </table>
</BODY>
<script type="text/javascript">
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~									
//Reload Video Interval
function reload()
{
	setTimeout('reloadImg("refresh")',100)   //this triggers an image reload every 100ms.  You can try to make this faster by lowering the number.
};
function reloadImg(id) 
{ 
	var obj = document.getElementById(id); 
    var date = new Date(); 
    obj.src = "http://[YOURCAMERAIPHERE]/snapshot.cgi?user=[USERNAME]&pwd=[PASSWORD]&t=" + Math.floor(date.getTime()/1000); 
} 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
</script>
</HTML>

Here are some pictures of the bot (click to enlarge):

My original plan was to pickup up an Arduino Network shield and use the camera to watch the CNC via custom webpage using streaming video and then, with some buttons, call the Arduino to trigger a servo to hit the Esc key on the CNC keyboard (which in turn would trigger Mach3 to shut down the CNC).  There were a few problems with this. 1) I have to wait for the Network shield to come from China (about a month or so), and I did not want to run a lengthy network cable from my router in the basement into the garage.  An Arduino WiFi shield was also out of the question as they are costly.

Then it hit me..  The Foscam has the ability to remotely trigger the IR LEDs to go on or off.    I managed to trace the signal wire to a wire on the mainboard that goes HI (1.5V) when the IR LEDs are on, and LOW (0v) when off.  Voila!  Tapping this signal then bringing it out to an ATTiny85 with a bit of simple code, I could control a servo connected to the keyboard..  So, onto the Arduino IDE, and out came the soldering iron.  A few hours later, here we are.

Foscam publishes an API to it’s camera interface which allows you to create your own pages and embed the camera stream and other functions in it. I just needed something simple – a video stream and a big STOP button. There area number of other buttons there to allow me to view various status outputs as well as change some settings. However, the only thing I need to do is stop the CNC (button triggers the call to turn the IR LEDs off) and turn the IR LED’s back on (small button below the Stop button). As part of the whole process, the IR LEDs need to be triggered back on in order to reset the control unit as this puts the voltage HIGH again. I had Javascript behind the Stop button doing this at first (triggering IR OFF, then IR ON), however, it caused reliability issues on my Andriod tablet (using Opera) and sometimes did not work (something that I could not have for this to work properly since the trigger HAS to work).

Showing the ATTiny85 circuit and the servo. The circuit is simple, the Tiny watches the output trigger from the camera, when it goes HIGH, it triggers the servo to ‘tap’ the Esc key. I also added an LED in there to provide visual feedback. Since the Tiny does not allow you to monitor via Serial, I was also using the LED as a debug tool. During testing, I wanted to make sure there were no phantom taps triggered (as I had this happen earlier). I used the LED to count the number of taps and blink that count.

Showing the modifications to the Foscam IPCam. This is an earlier picture before I was taking power from the camera. Since then, I have power coming directly off the power adapter inputs (bottom right shown with the black wire and red (drawn-in) wire). The IR LED trigger signal is the gray wire connected to pin #3 from the right.

This is the servo mounted to the keyboard. … and of course, the ideal way to build custom mounting solutions – LEGO Technic. Check the rest of this site out if you are wondering why I use LEGO.

I wanted the ability to easily remove and install the servo to the keyboard. I used a set of Technic friction pins and glued them in. The servo is mounted to a Technic 15 hole beam so it slides on and off easily, but is also secure enough to stay in place when the servo is triggered.

Here’s the ShapeOko & IPCam.

Here’s a video below of the system in action during testing. Now, I can roam around the house, be cooking dinner, etc.. while checking on the CNC and trigger a shutdown if needed. The Foscam also has a microphone, so I can also listen for those crazy noises you hear when your CNC skips a step and things go wrong – you know them, I’m sure you’ve heard it too!
(Link)

Improvements that could be done:

• The IR LEDs have to be triggered back on. Streamline the web interface component to ensure it automatically turns the IR LEDs back on after each Stop call. This could just be a Javascript timing issue. The code works by calling a new window, waiting a short period of time, then closing it. It does this for both the Stop call, and the call to turn the IR LEDs back on. During testing, I had both together in one call and it worked fine on my PC (networked), but did not work on my wireless tablet (it would miss either or both calls). By taking out the call to turn the IR LEDs back on, it reliably turns them off when called.
• The camera itself uses a photo resistor to turn the IR LEDs during daytime. This is not good considering that my CNC work area is well lit. Covering it with black tape does the trick. To solve the problem, I could modify the Foscam to not dim the IR LEDs (apparently this setting already exists for other Foscam cameras).

Other Thoughts:

• This could be used for other projects if you have a similar Foscam camera and want to remotely trigger actions using an Arduino or other microcontroller.

Files / Code:

CNCControl_WebInterfaceHTML

Arduino 1.0.3 Code:  CNCControlFoscamFI8918W_1_2  (must have Servo8Bit library).

</pre>
//This is written to go onto an ATTiny85. If using an Arduino, change pin references. Also must change back to using the Servo library
//as Servo8Bit wont work.

//ATTiny85 Pinouts:
// ________
// Reset |1 8| VCC
// Pin 3(analog in 3) |2 7| Pin 2 (analog in 1)
// Pin 4(analog in 2) |3 6| Pin 1 (PWM)
// GND |4 5| Pin 0 (PWM)
// --------
//
//

#include "Servo8Bit.h"
Servo8Bit myservo; //create a servo object.
 //a maximum of five servo objects can be created
int statusLED = 0; //shows as Pin 0 on ATTiny (pin 5 on board)
int pos = 0; // variable to store the servo position
//int foscamIRpin = A0; //when IR is on, pin is high 1.5v. Else LOW 0v
int foscamIRpin = 3; // shows as Pin 3(analog in 3) - labelled pin #3 on ATTiny85 board layout - when IR is on, pin is high 1.5v. Else LOW 0v
int state = 1;
int doneOnce = 0;
int CNCoff = 0;
int blinkCount = 0;
void setup()
{

myservo.attach(1,544,2200); //shows as Pin 1 on ATTiny (pin 6 on board)

//Serial.begin (9600);
 //Serial.print("Started... running..."); Serial.println();
 pinMode(foscamIRpin, INPUT);
 pinMode(statusLED, OUTPUT);
 //get the starting state of the IR LEDs
 //if (analogRead(foscamIRpin) < 1) { startState = 0;} else {startState = 1;};
 //Serial.print("StartState: "); Serial.print(startState);
 //Serial.println();

 //send servo to start position
 myservo.write(0);

}

void loop()
{

 //Stop button clicked - IR goes off - trigger CNC Stop - but only if it hasn't alread been triggered
 //startState of 0 means IRs where already off - dont want to trigger keyboard stop
 //startState of 1 means IRs are on at start - good this is what we want.
 if (analogRead(foscamIRpin) < 1 && CNCoff == 0)
 {
 //IR LEDs are off

hitKey(2);
 digitalWrite(statusLED, HIGH); // turn the LED on (HIGH is the voltage level)
 blinkCount ++;
 CNCoff = 1;
 doneOnce = 0;
 //Serial.print("Stop clicked - IR LEDs off "); Serial.println();
 delay(500);
 digitalWrite(statusLED, LOW); // turn the LED of

}
 //this is to catch when the IR LED have been reset (switched back on). It will reset the system for the next round of cutting.
 //will look for a way in the web form to have it automatically reset the IR LEDs after a triggered shutdown.
 else if (analogRead(foscamIRpin) > 50 && doneOnce == 0)
 {
 //IR LEDs are on
 //Serial.print("Start clicked - IR LEDs on "); Serial.println();
 CNCoff = 0;
 doneOnce = 1;
 }
 //Serial.print("IRVoltage: "); Serial.print(analogRead(foscamIRpin));
 //Serial.print(" CNCoff: "); Serial.print(CNCoff);
 //Serial.print(" DoneOnce: "); Serial.print(doneOnce);
 //Serial.println();
 delay(100);
 //blink(blinkCount);
}
void hitKey(int spd)
{
 //CNCoff = 1;
 //Serial.print("CNC Triggered to shut off. ");
 //Serial.println();

 for(pos = 0; pos < 60; pos += 1) // goes from 0 degrees to 180 degrees
 { // in steps of 1 degree
 myservo.write(pos); // tell servo to go to position in variable 'pos'

 //Serial.println (myservo.read());
 delay(spd); // waits 15ms for the servo to reach the position
 }
 for(pos = 60; pos>=1; pos-=1) // goes from 180 degrees to 0 degrees
 {
 myservo.write(pos); // tell servo to go to position in variable 'pos'
 //Serial.println (myservo.read());
 delay(spd); // waits 15ms for the servo to reach the position

 }

 delay(100);

}

/*
void blink(int cnt)
{
 int i;
 if (cnt > 0)
 {
 for (i = 0; i<=cnt; i++)
 {
 digitalWrite(statusLED, HIGH);
 delay(10);
 digitalWrite(statusLED, LOW);
 delay(100);
 }
 }
}
*/
<pre>

Phase 1 – enable functionality for controlling manual mode shifting using an RF remote.  This will be discussed here.

Phase 2 – Custom CNC milled aluminum paddle shifter units mounted to the steering wheel. Stay tuned

Phase 1:

Preface:  If you want to try this yourself, you take responsibility for anything that may result from it.  If you mess up, you risk frying one of the BCM which could cost you some serious coin.  There is no guarantee that this will work for you, or of the long term affects.  I know enough about electronics / car electrical systems to have confidence that this will work.   If you don’t have this same confidence, then this may not be for you.

Since I don’t have many hobbies (not), I’ve jumped into desktop CNC milling and recently picked up a MyDIYCNC.  My first project will be the paddles.  I’ve modeled the unit  as shown here.  This will come in Phase II, but I wanted to show the end goal.  The view here is of the backside of the paddle.  The recessed area to the right is where the finger would rest when triggering the paddle.  The blank area to the right is going to hold a small switch (see image).  The switch will be mounted upside-down inside the paddle and will rest against the steering wheel.  The switch itself will serve to both trigger a shift as well as provide the ‘spring’ to allow the paddle to triggered as the switch compresses against the back of the steering wheel.  The far left side will be used to mount a tab to to attach the paddle to the steering wheel itself.

The Juke manual mode shifter has some built-in checks to ensure that it is in the manual mode state and that the ‘up’ and ‘down’ shifts are not phantom shifts.  It does this with a few pins and an internal slide switch. Namely pins 7, 8, 9 and 10 (shown below).   These pins can be seen circled red in the connector that mounts to the backside of the shifter pod.  The manual mode shifting is monitored by the car computer to ensure than a shift took place and also determines which way.  Reading the switching diagram to the right, the following can be interpreted:

1. Manual Mode engaged:  Pin 8 & 9 – no continuity between pin 10.  Pin 7 – continuity to 10.
2. Shift Up – Pin 9 continuity to 10, pin 8 &7  no continuity
3. Shift Dn – Pin 8 continuity to 10, pin 9 & 7 no continuity
4. Shift unit connector wire colours: pin 7=brown, 8=green, 9=grey, 10=yellow

I wanted to do the mod as well as ensure the stock unit would still work as designed.  To do this, I had to tap into these wires to mimic the action of the shifter lever, but not disable the shifter itself.  The RF remote receiver has 2 relays – one for each button ‘A’ and ‘B’.  This was perfect as it allowed me to run parallel lines off pins 8 & 9 and connect them to pins A of each relay.  Pin 10 was connected to GND on both relays.  The default state of the relay had no continuity between Pin 8 & 10 and pin 9 & 10 (as per spec). When the RF remote buttons are pressed, continuity to pin 10 is triggered from (8 or 9).  The challenge was pin 7.   Since pin 7 continuity needs to be broken when either 8 or 9 is triggered, it could not be connected to the relay as one of the relays would always keep continuity between 7 & 10 while the other relay would try to open it – not gonna work!

Jumping ahead, here is a demo of first part.  The RF remote controlling the switching.  Choppy video warning in 3…2…1….

Link

The build:

To handle the pin 7 issue, I used an ATTiny85 Arduino micro controller to work as a NOT gate.  It monitors pins 8 & 9 and, when either of them go LOW (no continuity), it would trigger pin 7 to go High (and vise-versa).  The following image shows the circuit.  The bottom shows the leads coming form pins 8 & 9 and the connection to the relays of the RF remote receiver.  Recall that when in manual mode neutral state (still driving), pins 8 & 9 are Low and 7 is high.  This is fed to a voltage divider for each of 8 & 9 to drop the voltage to a range between 0 – 5V.  The ATTiny reads this, and triggers the output on pin 6 (top right in blue), which in turn triggers the 2222 transistor.  On the car, the wire for pin 7 leading into the shifter was cut and leads were taken into the circuit (shown below top right for pin 7).    One lead goes to the Collector and the other to the Emitter of the 2222.  The idea is that the ATTiny serves as a trigger to set pin 7 High or Low.

Showing the wireless remote receiver and emitter.  Pin 8 & 9 went to connector C on each relay while pin 10 when to both ‘B’ connectors.  The ‘A’ connectors are not needed.

The below pic shows the ATTiny85 circuit connected to the RF receiver while testing.   I had originally intended to build just use a quad NAND gate to make this work, but ran into difficulties with leaky voltage not triggering pin 7 to go Low.  I also realized that there would be a timing issue.  Consider that, when manually shifting by hand, it takes time (in hundreds of milliseconds) to go from the shifter neutral state to either an up or down shift. During that time, there is a mechanical switch that changes states for pins 7,8 and 9.  However, when using the method here, everything is instantaneous. Once you touch a button on the RF remote and the relay is triggered, the switching is much faster than you can do with your hand.  Once the relay is triggered, the output states of the pins switch from one state to the other and back very fast – too fast for the car to see them sometimes.  I realized this when the RF remote was not working at first, but then when I held the button for a little longer, it worked.   I introduced a delay into the Arduino sketch to allow for approx 600 ms time to hold the pins in their switched state (High or Low).

Showing some of the wiring.  This is for pins 8, 9 and 10.  Pin 7 missing as this is an early picture of the project.  For pin 7, the wire is cut and a line is taken from each side.  In the case of the other pins, I tapped into the line but left the wire intact.  This is necessary to ensure that the shifter pod will still work.  The pin 7 wire had to be cut or it would not be able to be triggered from the RF and Arduino units.  BTW – pin 7 is the brown wire.

Phase I is complete – the circuit and RF remote allow the manual mode shifting to be controlled.  I have yet to mill the paddles and hack the remote to get switching into the paddles – this is Phase II and will be coming in a bit.  Check back again!

Source Code:

/*
Juke paddle shifter code - NOT gate. ATTiny85
Purpose: monitor inputs on A2, A3. When either go High, output on digital pin 0 to go Low.  NOT gate
July 2012
D. Astolfo
*/

                  // On ATTiny85
int pin7Juke = 0; //pin #5
int led = 1;      //pin #6
int shiftUp = 3;  //pin #2 (note that pins are defined based on the ‘analog input text 3’ on the image at the below URL)
int shiftDn = 2;  //pin #3  (note that pins are defined based on the ‘analog input text 2’ on the image at the below URL)
                  //http://hlt.media.mit.edu/?p=1695

void setup() {
  //Serial.begin(115200);
  // initialize the digital pin as an output.
  pinMode(pin7Juke, OUTPUT);
  pinMode(led, OUTPUT);
  pinMode(shiftUp, INPUT);
  pinMode(shiftDn, INPUT);

  digitalWrite(pin7Juke, HIGH);  //onstartup, pin7 needs to be supplying 12V.
}

// the loop routine runs over and over again forever:
void loop() {

  //Serial.print("Val1=");
  //Serial.print(analogRead(shiftUp), DEC);
  //Serial.print("  Val2=");
  //Serial.println(analogRead(shiftDn), DEC);

  if (analogRead(shiftUp) < 900 || analogRead(shiftDn) < 900)
  {
    //will set pin 7 to LOW to tell the car that a shift up or dn has ocurred.
    digitalWrite(pin7Juke, LOW);
    blink();
    //keep the pin low for a bit as the relays and electrics trigger much faster than doing this by hand through the shifter
    delay(500);
  }
  else
  {
    //sets the pin back high again.
    digitalWrite(pin7Juke, HIGH);
  }

  delay(100);

}

void blink()
{
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(100);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(100);               // wait for a second

}

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.

Looking for an Android remote control for your robot? Check out BTBotControl - I built this to remotely control IPCamBot and view a live feed of a mounted IP Camera.

The Code:

(download)

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

#include <SoftwareSerial.h>
//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 <avr/pgmspace.h>
#include <SSD1306.h>                  //for OLED
#include <SPI.h>                      //for OLED
#include <string.h>
#include <TinyGPS.h>

#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<len; ++i)
        sz[i] = ' ';
    Serial.print(sz);
  }
  else
  {
    Serial.print(val, prec);
    int vi = abs((int)val);
    int flen = prec + (val < 0.0 ? 2 : 1);
    flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
    for (int i=flen; i<len; ++i)
      Serial.print(" ");
  }
  feedgps();
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/*
void beep(int howmany, int itone) {

 if (itone == 0){itone=2200;}

 for (int i=0; i < howmany; i++){
    tone(piezo, itone, 10);
    delay(100);
  }
}
*/
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
static void print_str(const char *str, int len)
{
  int slen = strlen(str);
  for (int i=0; i<len; ++i)
    Serial.print(i<slen ? str[i] : ' ');
  feedgps();
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void flash(int howmany) {
 for (int i=0; i < howmany; i++){
    digitalWrite(GPSActive, HIGH);
    delay(100);
    digitalWrite(GPSActive, LOW);
    delay(100);
  }
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void heartbeat(boolean nd){

  //show if there is no data - hearbeat of system - shows it is working.  Fast blink.
  if (nd == false){

    if (gpsStatCounter == 2)
      {
          analogWrite(redPin, 127);
          analogWrite(greenPin, 255);
          analogWrite(bluePin, 0);
          delay(50);
          analogWrite(redPin, 255);
          analogWrite(greenPin, 255);
          analogWrite(bluePin, 255);
          //delay(50);

          gpsStatCounter = 0;
      }
      else
      {
      gpsStatCounter++;
      }
  }

}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void changeWarning(int stateLevel)
{
    switch (stateLevel) {

    case 1:
      //green LED - show for status that GPS is getting data
      analogWrite(greenPin, 155);
      delay(200);
      break;

     case 2:
      //early warning.
      analogWrite(bluePin, 155);
      delay(200);
      break;

    case 3:
      //yellow
      analogWrite(redPin, 0);
      analogWrite(greenPin, 190);
      delay(200);
      break;

    case 4:
      //in and just before red light camera
      analogWrite(redPin, 155);
      delay(200);
      break;

    default:
      //all off
      analogWrite(greenPin, 255);
      analogWrite(bluePin, 255);
      analogWrite(redPin, 255);
      break;
    }

    //turn the LEDs back off
    analogWrite(greenPin, 255);
    analogWrite(bluePin, 255);
    analogWrite(redPin, 255);

}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
static void print_int(unsigned long val, unsigned long invalid, int len)
{
  char sz[32];
  if (val == invalid)
    strcpy(sz, "*******");
  else
    sprintf(sz, "%ld", val);
  sz[len] = 0;
  for (int i=strlen(sz); i<len; ++i)
    sz[i] = ' ';
  if (len > 0)
    sz[len-1] = ' ';
  Serial.print(sz);
  feedgps();
}

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


]]>
			http://www.plastibots.com/index.php/2012/04/10/red-light-camera-alerter/feed/
		11
		
		
		
		http://www.plastibots.com/index.php/2012/04/05/arduino-temperature-humidity-sensor/
		http://www.plastibots.com/index.php/2012/04/05/arduino-temperature-humidity-sensor/#comments
		Thu, 05 Apr 2012 21:06:14 +0000
		Dave
				
		
		

		http://www.plastibots.com/?p=2333
		Continue reading →]]>
				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 <avr/sleep.h>
#include <avr/power.h>
#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<len; ++i)
    Serial.print(i }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
static void print_int(unsigned long val, unsigned long invalid, int len)
{
  char sz[32];
  if (val == invalid)
    strcpy(sz, "*******");
  else
    sprintf(sz, "%ld", val);
  sz[len] = 0;
  for (int i=strlen(sz); i<len; ++i)     sz[i] = ' ';   if (len > 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;
 }

}


]]>
			http://www.plastibots.com/index.php/2012/04/05/arduino-temperature-humidity-sensor/feed/
		5
		
		
		
		http://www.plastibots.com/index.php/2012/03/04/adafruit-monochrome-128x32-oled-graphic-display/
		http://www.plastibots.com/index.php/2012/03/04/adafruit-monochrome-128x32-oled-graphic-display/#comments
		Sun, 04 Mar 2012 21:57:58 +0000
		Dave
				
		

		http://www.plastibots.com/?p=2296
		Continue reading →]]>
				 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.

]]>
			http://www.plastibots.com/index.php/2012/03/04/adafruit-monochrome-128x32-oled-graphic-display/feed/
		0
		
		
		
		http://www.plastibots.com/index.php/2012/01/14/review-avago-asmt-lw60-led-fibre-optic-strip/
		http://www.plastibots.com/index.php/2012/01/14/review-avago-asmt-lw60-led-fibre-optic-strip/#comments
		Sat, 14 Jan 2012 13:43:00 +0000
		Dave
				
		
		

		http://www.plastibots.com/?p=2260
		Continue reading →]]>
				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.
]]>
			http://www.plastibots.com/index.php/2012/01/14/review-avago-asmt-lw60-led-fibre-optic-strip/feed/
		0
		
		
		
		http://www.plastibots.com/index.php/2012/01/14/review-optek-warm-white-led-strip/
		http://www.plastibots.com/index.php/2012/01/14/review-optek-warm-white-led-strip/#comments
		Sat, 14 Jan 2012 12:58:28 +0000
		Dave
				
		
		
		

		http://www.plastibots.com/?p=2248
		Continue reading →]]>
				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).
]]>
			http://www.plastibots.com/index.php/2012/01/14/review-optek-warm-white-led-strip/feed/
		0
		
		
		
		http://www.plastibots.com/index.php/2012/01/06/review-optek-led-strip/
		http://www.plastibots.com/index.php/2012/01/06/review-optek-led-strip/#comments
		Sat, 07 Jan 2012 01:43:29 +0000
		Dave
				

		http://www.plastibots.com/?p=2229
		Continue reading →]]>
				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:

]]>
			http://www.plastibots.com/index.php/2012/01/06/review-optek-led-strip/feed/
		2