ThermalCam with Arduino, XBee and Processing

ThermalCam with MLX90614, Arduino UNO, XBee Series 2 and prototyping shield

A project I'm working on for some weeks now is a cheap ThermalCam based on the Melexis MLX90614 IR sensitive thermopile detector chip (more on the chip from Melexis: MLX90614 )

There are lots of people out there, who already built a working version with this $35 device, but most of them use a wired connection and a Java graphical user interface (GUI).

I wanted to get the thing wireless and also to build my own GUI where I may customize some things that I miss with the Java-version. I chose a XBee Series 2 configured as a Router AT with 57600 baud and Processing for the GUI. I'm already done with the data transmission part. I can control the ThermalCam with some buttons in the Processing sketch and get the data out of the chip but it still lacks a nice GUI and a webcam overlay.

This awesome project was first developed by two german pupils Markus Kohl/  Max Ritter for "Jugend forscht 2010" (german science competition for pupils). Well done!

I already made some thermal images with the Java program and here are some examples.

Sitting at the desk, waving my hand. Background dark blue: windows, right orange square: tft screen

Raspberry Pi with voltage regulator (left bottom), main chip (middle) and ethernet chip (right)

Laptop laying flat on the ground, upper half display, lower half keyboard/ mainboard

Arduino UNO Rev. 2

 Arduino basics presentation

On April 1 I had a short presentation on Arduino basics in the Hamburg (Germany) Makerspace attraktor .
 The participants learned about the Arduino environment, the IDE and how to program a sketch so that it blinks an led.
The paper (pdf) is downloadable here (sorry folks, it's only available in german - again).

XBee Series 2

XBee presentation @ Makerspace Attraktor

On March 4 I had a short presentation on XBee modules in the Hamburg (Germany) Makerspace attraktor .


The paper (pdf) is downloadable here (sorry folks, it's only available in german).

Electronic compass part 2

This is part 2 of the electronic compass with the video and the Arduino sketch.

Video:

Sketch:

/*****************************************
 * Compass with Pollin HDMM01-compass-module
 * and Nokia 5110-display
 * Last edit: 3.1.2013
 * By Markus Ulsass
 ******************************************/

/*******************************************************************************
 * This is an example sketch for our Monochrome Nokia 5110 LCD Displays
 *
 * Pick one up today in the adafruit shop!
 * ------> http://www.adafruit.com/products/338
 *
 * These displays use SPI to communicate, 4 or 5 pins are required to
 * interface
 *
 * Adafruit invests time and resources providing this open source code,
 * please support Adafruit and open-source hardware by purchasing
 * products from Adafruit!
 *
 * Written by Limor Fried/Ladyada  for Adafruit Industries.
 * BSD license, check license.txt for more information
 * All text above, and the splash screen must be included in any redistribution
 *******************************************************************************/

#include <Adafruit_GFX.h>
#include <Adafruit_PCD8544.h>

#include <Wire.h>

#define  I2ADDR       0x30
#define  TakeMeasure  0x01
#define SET_COIL 0x02 // set magnetic coil
#define RESET_COIL 0x04 // reset magnetic coil

// pin 7 - Serial clock out (SCLK)
// pin 6 - Serial data out (DIN)
// pin 5 - Data/Command select (D/C)
// pin 4 - LCD chip select (CS)
// pin 3 - LCD reset (RST)
Adafruit_PCD8544 display = Adafruit_PCD8544(7, 6, 5, 4, 3);

int r = 24;  // radius of compass rose
int x0= 60;  // x-origin
int y0 = 24; // y-origin

void setup()   {

  // Serial.begin(9600);

  display.begin();
  display.setContrast(60);
  display.clearDisplay();

  Wire.begin();

}

void loop() {

  ResetSetCoils();
 
  byte MsbX,LsbX,MsbY,LsbY;
  int x,y;
  char line[80];
  Wire.beginTransmission(I2ADDR); // Pollin HDMM01 address
  Wire.write(0x00);  
  Wire.write(TakeMeasure);
  Wire.endTransmission();
  delay(20);
  Wire.beginTransmission(I2ADDR);
  Wire.write(0x01);
  Wire.requestFrom(I2ADDR, 4);

  while(Wire.available()<4);
  MsbX  =Wire.read();          // upper  4 Bit X
  LsbX  =Wire.read();          // lower 8 Bit X
  MsbY  =Wire.read();          // upper 4 Bit Y
  LsbY  =Wire.read();          // lower 8 Bit Y
  Wire.endTransmission();         // stop transmitting
  x=((MsbX&0x0f)*256)+(LsbX);
  y=((MsbY&0x0f)*256)+(LsbY);
  x = map(x, 1960, 2151, -180, 180);
  y = map(y, 1939, 2131, -180, 180);
  double mygrad = atan2(-x, y)*180/3.1415927410;
  if (mygrad < 0)    mygrad = mygrad +360;
  int angleActual = mygrad;
  // Serial.println(mygrad); // debug
  delay(200);

  // Calculation of compass needle on lcd pointing to the direction
 
  if (angleActual >= 0 && angleActual <=45) {
    // 0-45 degrees
    int angle = angleActual/2;
    display.drawLine(x0, y0, x0+angle, y0-r, BLACK);
    // 45 degrees
    // display.drawLine(x0, y0, x0+r, y0-r, BLACK);
  }
  else if (angleActual >45 && angleActual <=90) {
    // 46-90 degrees
    int angle = (angleActual-44)/2 ;
    display.drawLine(x0, y0, x0+r, (y0-r)+angle, BLACK);
    // 90 degrees
    // display.drawLine(x0, y0, x0+r, y0, BLACK);
  }
  else if (angleActual >90 && angleActual <=135) {
    // 91-135 degrees
    int angle = (angleActual-90)/2;
    display.drawLine(x0, y0, x0+r, y0+angle, BLACK);
    // 135 degrees
    // display.drawLine(x0, y0, x0+r, y0+r, BLACK);
  }
  else if (angleActual >135 && angleActual <=180) {
    // 136-180 degrees
    int angle = (angleActual-134)/2;
    display.drawLine(x0, y0, (x0+r)-angle, y0+r, BLACK);
    // 180 degrees
    // display.drawLine(x0, y0, x0, y0+r, BLACK);
  }
  else if (angleActual >180 && angleActual <=225) {
    // 181-225 degrees
    int angle = (angleActual-178)/2;
    display.drawLine(x0, y0, x0-angle, y0+r, BLACK);
    // 225 degrees
    // display.drawLine(x0, y0, x0-r, y0+r, BLACK);
  }
  else if (angleActual >225 && angleActual <=270) {
    // 226-270 degrees
    int angle = (angleActual-222)/2;
    display.drawLine(x0, y0, x0-r, (y0+r)-angle, BLACK);
    // 270 degrees
    // display.drawLine(x0, y0, x0-r, y0, BLACK);
  }
  else if (angleActual >270 && angleActual <=315) {
    // 271-315 degrees
    int angle = (angleActual-270)/2;
    display.drawLine(x0, y0, x0-r, y0-angle, BLACK);
    // 315 degrees
    // display.drawLine(x0, y0, x0-r, y0-r, BLACK);
  }
  else if (angleActual >315 && angleActual <=360) {
    // 316-360 degrees
    int angle = (angleActual-312)/2;
    display.drawLine(x0, y0, (x0-r)+angle, y0-r, BLACK);
    // 360/ 0 degrees
    // display.drawLine(x0, y0, x0, y0-r, BLACK);
  }

  // text display

  // display.drawCircle(x0, y0, r-1, BLACK);
  // Display actual heading
  display.setTextSize(2);
  display.setTextColor(BLACK);
  display.setCursor(0,0);
  display.println(angleActual);
 
  display.setTextSize(1);
  display.setTextColor(BLACK);
  display.setCursor(x0-2,0);
  display.println("N");
 
  display.setTextSize(1);
  display.setTextColor(BLACK);
  display.setCursor((x0+r)-5,y0-3);
  display.println("0");
 
  display.setTextSize(1);
  display.setTextColor(BLACK);
  display.setCursor(x0-2,y0+r-8);
  display.println("S");
 
  display.setTextSize(1);
  display.setTextColor(BLACK);
  display.setCursor((x0-r)+5,y0-3);
  display.println("W");
 
  // Triangle for direction
 
  // display.drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color)
  display.drawTriangle(0, 46, 20, 46, 10, 18, BLACK);
  // fillTriangle ( int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color)
  display.fillTriangle (0, 46, 20, 46, 10, 18, BLACK);
  display.display();
  delay(100);
  display.clearDisplay();

}

void ResetSetCoils (void)
{

    // RESET / SET Coils
    Wire.beginTransmission(I2ADDR);
    Wire.write(0x00);
    Wire.write(RESET_COIL);
    Wire.endTransmission();
    delay(1);
    Wire.beginTransmission(I2ADDR);
    Wire.write(0x00);
    Wire.write(SET_COIL);
    Wire.endTransmission();
    delay(1);
}

Level-Shifter for XBee & Raspberry Pi

Some projects have mixed supply voltages (e.g. 5 Volt and 3.3 Volt) and sometimes integrated circuits don't work with those unequal signal levels - or worse get damaged by the higher level supply signals.

Level shifter pcb

In case of the XBee which is driven by 3.3 Volt up to now I added a simple resistor divider to get the signals down to the lower supply level (see this older post ). But even if you feed the XBee without translating the different supply levels, I never got any problems (but I wouldn't recommend).

It might look slightly different with the Raspberry Pi, so to be on the safe side I built a simple 2-bit bidirectional voltage-level translator circuit for the alleged thin-skinned RasPi. You just need four 10k resistors, two BSS138 (N-Channel Logic Level Enhancement Mode Field Effect Transistor) and two four-pin headers.

I etched the board by myself but if you want to take the short way, there are already breakout boards and ICs available (e.g. Sparkfun Logic Level Converter, TXS0102 from Texas Instruments or ADuM1250/ ADuM1251 from Analog Devices).

Anyway I wanted to do some practice with my favourite pcb layout software Eagle and designed this simple pcb.

How does the level shifting work? If nothing happens on the bus (in this special case on the I2C-bus, thats what the pcb is labled for, but it also works with RX/ TX or any other 2-bit bidirectional digital purposes) all signals are pulled high by the 10k resistors. If either side goes low, the N-Channel MOSFET steps in and also pulls the signal line low, either because it turns on (low level side) or passes through the body diode (high level side).

Electronic compass

Just a note to a little project I'm building at the moment - an electronic/ digital compass:

There is no XBee involved - but a Nokia5110 lcd display, an Arduino Nano, a 2-axis compass module (HDMM01) and a HCF4050 for level-shifting. Of course you could add a XBee if you are using the compass for a robot or other mobile project.

And yes - the Halloween project is still to be posted. Just give me some more time.

Project XSkull

Halloween. Early darkness in fall. Pumpkins everywhere. Little kids in fancy costumes demanding candies.

XSkull with glowing eyes and moving jaw

So why not greeting them appropiate with an Arduino-based project combining a skull with red glowing and fading eyes and moving jaw which is servo operated and XBee-remote controlled. Haze in the dark from a fog machine which is radio controlled and triggered via XBee. Where the status of the heating-up process is reported back to the remote control where an illuminated switch is lit when the fog machine is ready? Where another switch can control a light or sound source?

That's what I will present in the next weeks until Halloween. Hardware, Arduino-Sketches and XBee configuration will be explained. For the beginning here are some photos. Have fun!

Remote control

 The remote control consists of an enclosure where an Arduino nano and a XBee are the main parts. With a sliding potentiometer you are remote controlling the moving of the skull-jaw. The red momentary switch shows the status of the heating-up process of the fog machine and signals it with the internal LED. If you push the switch fog will evaporate. Everything is driven by a 9 volt battery and the circuit can be activated by a rocker switch. One additional illuminated green switch can control another source like light or sound and signal an additional status to the remote control.

Fog machine

A servo which is connected to an Arduino Uno in the brain of the skull controls the momentary switch on the fog machine so that there is no need to work with high voltage. The light of the bulb which signalizes the heating process of the fog machine is analyzed by a light dependent resistor (LDR) which reports the resistance to the Arduino Uno which then sends the value via XBee to the remote control and lights the LED on the red fog switch when the fog machine is ready.