Arduino Archives - MitchTech

Home Arduino

Raspberry Pi + Arduino + SPI

Posted by meyers on Aug 11, 2012 in Arduino, Raspberry Pi, Tutorials | 48 comments

This tutorial will show you how to communicate from your raspberry pi to your arduino using 3-wire SPI.

Requirements

1 Raspberry pi (running Raspbian)
1 Arduino
4 wires

Your raspberry pi should be running the newest version of Raspbian. To ensure your system is up-to-date please download and run rpi-update.

Wiring

Arduino

Open your Arduino ide and flash the below code to your Arduino.

Arduino code

// Written by Nick Gammon // February 2011 /** * Send arbitrary number of bits at whatever clock rate (tested at 500 KHZ and 500 HZ). * This script will capture the SPI bytes, when a '\n' is recieved it will then output * the captured byte stream via the serial. */ #include <SPI.h> char buf [100]; volatile byte pos; volatile boolean process_it; void setup (void) { Serial.begin (115200); // debugging // have to send on master in, *slave out* pinMode(MISO, OUTPUT); // turn on SPI in slave mode SPCR |= _BV(SPE); // get ready for an interrupt pos = 0; // buffer empty process_it = false; // now turn on interrupts SPI.attachInterrupt(); } // end of setup // SPI interrupt routine ISR (SPI_STC_vect) { byte c = SPDR; // grab byte from SPI Data Register // add to buffer if room if (pos < sizeof buf) { buf [pos++] = c; // example: newline means time to process buffer if (c == '\n') process_it = true; } // end of room available } // end of interrupt routine SPI_STC_vect // main loop - wait for flag set in interrupt routine void loop (void) { if (process_it) { buf [pos] = 0; Serial.println (buf); pos = 0; process_it = false; } // end of flag set } // end of loop

Raspberry Pi

With your updated rasbian system you should have the drivers that you need. Now it’s time to load them.

modprobe spi_bcm2708
modprobe spidev

Check to be sure the modules loaded:

lsmod
Module Size Used by
spidev 5944 0
spi_bcm2708 5350 0
snd_bcm2835 21681 0
snd_pcm 81170 1 snd_bcm2835
snd_seq 59528 0
snd_timer 21602 2 snd_seq,snd_pcm
snd_seq_device 6924 1 snd_seq
snd 57427 5 snd_seq_device,snd_timer,snd_seq,snd_pcm,snd_bcm2835
snd_page_alloc 5343 1 snd_pcm
i2c_bcm2708 3822 0

Raspberry Pi Code

Save the below code as spidev_test.c on to your Raspberry Pi and compile it

gcc spidev_test.c -o spidev_test

/* * SPI testing utility (using spidev driver) * * Copyright (c) 2007 MontaVista Software, Inc. * Copyright (c) 2007 Anton Vorontsov <avorontsov@ru.mvista.com> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License. * * Cross-compile with cross-gcc -I/path/to/cross-kernel/include */ #include <stdint.h> #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <getopt.h> #include <fcntl.h> #include <sys/ioctl.h> #include <linux/types.h> #include <linux/spi/spidev.h> #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) static void pabort(const char *s) { perror(s); abort(); } static const char *device = "/dev/spidev0.0"; static uint8_t mode; static uint8_t bits = 8; static uint32_t speed = 500000; static uint16_t delay; static void transfer(int fd) { int ret; uint8_t tx[] = { 0x48, 0x45, 0x4C, 0x4C, 0x4F, 0x20, 0x57, 0x4F, 0x52, 0x4C, 0x44, 0x0A }; uint8_t rx[ARRAY_SIZE(tx)] = {0, }; struct spi_ioc_transfer tr = { .tx_buf = (unsigned long)tx, .rx_buf = (unsigned long)rx, .len = ARRAY_SIZE(tx), .delay_usecs = delay, .speed_hz = speed, .bits_per_word = bits, }; ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr); if (ret < 1) pabort("can't send spi message"); /* for (ret = 0; ret < ARRAY_SIZE(tx); ret++) { if (!(ret % 6)) puts(""); printf("%.2X ", rx[ret]); } puts(""); */ } static void print_usage(const char *prog) { printf("Usage: %s [-DsbdlHOLC3]\n", prog); puts(" -D --device device to use (default /dev/spidev1.1)\n" " -s --speed max speed (Hz)\n" " -d --delay delay (usec)\n" " -b --bpw bits per word \n" " -l --loop loopback\n" " -H --cpha clock phase\n" " -O --cpol clock polarity\n" " -L --lsb least significant bit first\n" " -C --cs-high chip select active high\n" " -3 --3wire SI/SO signals shared\n"); exit(1); } static void parse_opts(int argc, char *argv[]) { while (1) { static const struct option lopts[] = { { "device", 1, 0, 'D' }, { "speed", 1, 0, 's' }, { "delay", 1, 0, 'd' }, { "bpw", 1, 0, 'b' }, { "loop", 0, 0, 'l' }, { "cpha", 0, 0, 'H' }, { "cpol", 0, 0, 'O' }, { "lsb", 0, 0, 'L' }, { "cs-high", 0, 0, 'C' }, { "3wire", 0, 0, '3' }, { "no-cs", 0, 0, 'N' }, { "ready", 0, 0, 'R' }, { NULL, 0, 0, 0 }, }; int c; c = getopt_long(argc, argv, "D:s:d:b:lHOLC3NR", lopts, NULL); if (c == -1) break; switch (c) { case 'D': device = optarg; break; case 's': speed = atoi(optarg); break; case 'd': delay = atoi(optarg); break; case 'b': bits = atoi(optarg); break; case 'l': mode |= SPI_LOOP; break; case 'H': mode |= SPI_CPHA; break; case 'O': mode |= SPI_CPOL; break; case 'L': mode |= SPI_LSB_FIRST; break; case 'C': mode |= SPI_CS_HIGH; break; case '3': mode |= SPI_3WIRE; break; case 'N': mode |= SPI_NO_CS; break; case 'R': mode |= SPI_READY; break; default: print_usage(argv[0]); break; } } } int main(int argc, char *argv[]) { int ret = 0; int fd; parse_opts(argc, argv); fd = open(device, O_RDWR); if (fd < 0) pabort("can't open device"); /* * spi mode */ ret = ioctl(fd, SPI_IOC_WR_MODE, &mode); if (ret == -1) pabort("can't set spi mode"); ret = ioctl(fd, SPI_IOC_RD_MODE, &mode); if (ret == -1) pabort("can't get spi mode"); /* * bits per word */ ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits); if (ret == -1) pabort("can't set bits per word"); ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits); if (ret == -1) pabort("can't get bits per word"); /* * max speed hz */ ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed); if (ret == -1) pabort("can't set max speed hz"); ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed); if (ret == -1) pabort("can't get max speed hz"); printf("spi mode: %d\n", mode); printf("bits per word: %d\n", bits); printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000); transfer(fd); close(fd); return ret; }

Running

Plug your Arduino to your desktop via the serial cable. Open the arduino Serial Monitor and set the bitrate to 115200. Now, on the Raspberry Pi, run the compiled code

sudo ./spidev_test

You should see HELLO WORLD print in the Arduino IDE Serial Monitor.

Debugging

Make sure that your kernel has the required drivers (spi-bcm2708.ko and spidev.ko)

pi@raspberrypi ~/spi $ ls -al /lib/modules/`uname -r`/kernel/drivers/spi/
total 64
drwxrwxr-x 2 pi pi 4096 Aug 10 10:53 .
drwxrwxr-x 23 pi pi 4096 Aug 10 10:53 ..
-rw-rw-r– 1 pi pi 14428 Aug 10 10:53 spi-bcm2708.ko
-rw-rw-r– 1 pi pi 10852 Aug 10 10:53 spi-bitbang.ko
-rw-rw-r– 1 pi pi 15803 Aug 10 10:53 spidev.ko
-rw-rw-r– 1 pi pi 10693 Aug 10 10:53 spi-gpio.ko

Thanks to Nick Gammon for the SPI slave code.

Thanks to Anton Vorontsov for the kernel Documentation spidev_test.c example code.

Arduino Poor Man’s Oscilloscope

Posted by meyers on Aug 6, 2012 in Arduino, Tutorials | 9 comments

252

This tutorial will show you how to use your Arduino as an oscilloscope. We end the tutorial with a verification portion that uses the Arduino to generate a square wave, requiring a single wire.

lxardoscope

Lxardoscope is another Arduino + real-time graphing project that has the potential to turn an Arduino into an oscilloscope. Unfortunately, I was unable to get any readings (the visual graph remained static).

Poor Man’s Oscilloscope

First, download processing.

http://processing.googlecode.com/files/processing-1.5.1-linux.tgz
gzip -d processing-1.5.1-linux.tgz
tar -xf processing-1.5.1-linux.tar

Desktop Application

Arduino uses a modified RXTXcomm.jar library. This causes a problem when the processing project runs poor man’s oscilloscope and loads the RXTXcomm.jar library bundles with the processing project. Instead, we wish for process to load the modified Arduino RXTXcomm.jar library. To remedy this problem we simply replace processing RXTXcomm.jar with the Android specific RXTXcomm.jar.

rm processing-1.5.1/modes/java/libraries/serial/library/linux64/librxtxSerial.so
rm processing-1.5.1/modes/java/libraries/serial/library/RXTXcomm.jar
ln -s /usr/share/arduino/lib/RXTXcomm.jar processing-1.5.1/modes/java/libraries/serial/library/

Run processing

cd processing-1.5.1
./processing

Running the processing command should result in a GUI application launching that looks a lot like the Arduino idea. Download and open the below code in processing and click play.

Arduino Code

Arduinoscope has a simple arduino component to poll and forward analog 0 to the desktop via the serial connection. Save the below code and flash it to your Arduino.

Verifying the Oscilloscope

To test the oscilloscope we will generate data using the Arduino and feed it in to the analog A0 port to be viewed on our Desktop. Flash the code below to your Arduino.

Connect pin digital pin 13 on the Arduino to analog pin A0. The above code will turn on and off the digital pin to produce a square wave.

Extras

You can alter the baud rate from 9600 to 115200 in the arduino code as well as the processing code.
Plus sign zooms in (shift and =) while – zooms out (just -, no shift)
PWM at a normal 50 HZ is easily observable
Raspberry Pi pin 18 can generate PWM and the arduino can be used to test it.
An idle capture looks like:

Arduino Physical CPU Gauges

Posted by michael on Jul 3, 2012 in Arduino, Tutorials, Ubuntu | 0 comments

111

Use Arduino and two hobby servos to control physical servo gauges for cpu activity, memory usage, bandwidth, and more. The script uses the python psutil and pyserial modules. The psutil module provides an interface for retrieving information on all running processes and system utilization (CPU, disk, memory, network) providing service similar to command line tools such as ps, top, iostat, and netstat. The servo control portion of the project is based on Arduino-Python 4-Axis Servo Controlby Brian Wendt, and the Arduino sketch is essentially unmodified from the SerialServoControl Sketch on Sparkfun.

Hardware

Connect the red, power lines of the servos to +5v, the black ground lines to GND, and the yellow signal lines to the desired output pins, 5 and 6 in the example (others can be used, but must be PWM capable

You can download my cheesy gauge overlay from here:

http://mitchtech.net/arduino-physical-cpu-gauges/gauges/

Print it out, cut out the gauges, and poke a hole in the lower center of the gauge. Remove the servo horn, slide the shaft through the hole in the gauge printout, and reconnect the servo horn on top of it.

Software

The first step is to install the python psutil and pyserial modules. The easiest way to install it is using the python pip package manager. If you don’t have it installed already, you can install it using apt-get:

sudo apt-get install python-pip

Then install the psutil and pyserial modules:

sudo pip install psutil pyserial

Next, flash the sketch to the Arduino board. You can download it or copy and paste into the Arduino IDE.

/******************************************************* * SerialServoControl Sketch * Written by Ryan Owens for SparkFun Electronics * 7/15/11 * * This sketch listens to serial commands and uses the data * to set the position of two servos. * * Serial Command Structure: 2 bytes - [ID Byte][Servo Position byte] * ID byte should be 0 or 1. * Servo position should be a value between 0 and 180. * Invalid commands are ignored * The servo position is not error checked. * * Hardware Setup * Servos should be connected to pins 5 and 6 of the Arduino. * 9V DC Power supply is recommended as USB can't always handle powering two servos */ #include <Servo.h> //Used to control the Pan/Tilt Servos //These are variables that hold the servo IDs. char tiltChannel=0, panChannel=1; //These are the objects for each servo. Servo servoTilt, servoPan; //This is a character that will hold data from the Serial port. char serialChar=0; void setup(){ servoTilt.attach(5); //The Tilt servo is attached to pin 5. servoPan.attach(6); //The Pan servo is attached to pin 6. servoTilt.write(90); //Initially put the servos both servoPan.write(90); //at 90 degress. Serial.begin(9600); //Set up a serial connection for 9600 bps. } void loop(){ while(Serial.available() <=0); //Wait for a character on the serial port. serialChar = Serial.read(); //Copy the character from the serial port to the variable if(serialChar == tiltChannel){ //Check to see if the character is the servo ID for the tilt servo while(Serial.available() <=0); //Wait for the second command byte from the serial port. servoTilt.write(Serial.read()); //Set the tilt servo position to the value of the second command byte received on the serial port } else if(serialChar == panChannel){ //Check to see if the initial serial character was the servo ID for the pan servo. while(Serial.available() <= 0); //Wait for the second command byte from the serial port. servoPan.write(Serial.read()); //Set the pan servo position to the value of the second command byte received from the serial port. } //If the character is not the pan or tilt servo ID, it is ignored. }

Then download or copy and paste the Python script:

#!/usr/bin/env python import serial, sys, time, psutil # Assign Arduino's serial port address # Windows example # usbport = 'COM3' # Linux example # usbport = '/dev/ttyUSB0' # MacOSX example # usbport = '/dev/tty.usbserial-FTALLOK2' usbport = '/dev/ttyUSB0' # Set up serial baud rate ser = serial.Serial(usbport, 9600, timeout=1) def move(servo, angle): '''Moves the specified servo to the supplied angle. Arguments: servo the servo number to command, an integer from 1-4 angle the desired servo angle, an integer from 0 to 180 (e.g.) >>> servo.move(2, 90) ... # "move servo #2 to 90 degrees"''' if (0 <= angle <= 180): ser.write(chr(255)) ser.write(chr(servo)) ser.write(chr(angle)) else: print "Servo angle must be an integer between 0 and 180.\n" def main(): while 1: cpu_percent = psutil.cpu_percent(interval=1, percpu=False) mem_percent = psutil.phymem_usage().percent cpu_angle = int(cpu_percent / 100 * 180) mem_angle = int(mem_percent / 100 * 180) cpu_str = "CPU: " + str(cpu_percent) + " % (" + str(cpu_angle) + "/180)" mem_str = "Mem: " + str(mem_percent) + " % (" + str(mem_angle) + "/180)" print cpu_str print mem_str move(0, cpu_angle) move(1, mem_angle) #time.sleep(1) if __name__ == "__main__": sys.exit(main())

That’s it! To run the script:

python cpu_serial_servo.py

Note:If you receive this error:

raise SerialException(“could not open port %s: %s” % (self._port, msg)) serial.serialutil.SerialException: could not open port /dev/ttyUSB0: [Errno 13] Permission denied: ‘/dev/ttyUSB0’

The problem is the default permissions of the /dev/ttyUSB0 (or /dev/ttyACM0) device. This can be fixed by running the command:

sudo chmod 777 /dev/ttyUSB0

Arduino USB HID Keyboard

Posted by michael on Jun 24, 2012 in Arduino, Tutorials, Ubuntu | 114 comments

138

Turn your Arduino UNO into a USB HID keyboard, and make buttons that do whatever you want. Make it a useful tool, with new buttons for Cut/Copy/Paste or Volume+/Volume-/Mute, or annoy your friends and colleagues by setting the keyboard to perform random keypress after random delays!

The USB HID keyboard conforms to the standard USB specification, so is functional on all modern operating systems. All this is made possible by the use of the Arduino Device Firmware Update (DFU) function.

Arduino Device Firmware Update (DFU)

The Atmega8U2 chip on the Arduino UNO can be programmed directly using the special USB protocol called Device Firmware Update (DFU). This is completely independant of the ‘normal’ method of flashing sketches to the board using the Arduino IDE.

This process is normally used to update the firmware to a more recent version, as explained in the offical Arduino guide, Updating the Atmega8U2 on an Uno or Mega2560 using DFU. Note: If your board is NOT an Arduino UNO SMD you’ll need to solder a 10k resistor (Brown-black-orange) at the back of your board as shown on the Arduino site.

However, in addition to the ability to flash standard USB Serial firmwares, we can also flash alternative firmwares as well. This allows the device to be recognized as many other device types, including keyboard, mouse, joystick, midi device, etc. This is made possible in part to the wonderful open source LUFA (Lightweight USB Framework for AVRs) USB stack, and keyboard HID firmware from Darran.

In this demonstration, we will flash generic USB HID keyboard firmware. The USB HID protocol provides manufactures the generic specifications to interact with nearly every operating system in existence. For more info, check out the USB HID Spec sheet.

Before you start, install the required packages. On Ubuntu and Debain systems, in a terminal run:

sudo apt-get install dfu-programmer dfu-util

For Windows and Mac instructions to install the dfu-programmer tool, consult the official Arduino DFU documentation.

Then download these two firmware files:

Arduino-usbserial.hex
Arduino-keyboard-0.3.hex

The first step is to make sure you are able to flash the standard arduino firmware. This will confirm that the programmer and the environment are both functional. NOTE: There is no chance of ‘bricking’ the device using this method. The Arduino bootloader firmware can always be updated using the DFU protocol!

sudo dfu-programmer at90usb82 erase
sudo dfu-programmer at90usb82 flash --debug 1 Arduino-usbserial.hex
sudo dfu-programmer at90usb82 reset

Plug cycle the Arduino, then open the Arduino IDE and ensure that you can still upload a sketch. Assuming everything flashes normally, we can move forward with flashing the HID keyboard firmware.

sudo dfu-programmer at90usb82 erase
sudo dfu-programmer at90usb82 flash --debug 1 Arduino-keyboard-0.3.hex
sudo dfu-programmer at90usb82 reset

NOTE: The Arduino can only be flashed with skectches through the Adruino IDE if the Arduino-usbserial.hex bootloader is active. So, to develop a USB HID device, the process becomes:

Flash Arduino-usbserial.hex bootloader with dfu-programmer (erase/flash/reset)
Plug cycle the Arduino
Flash firmware sketch using Arduino IDE
Plug cycle the Arduino
Flash Arduino-keyboard-0.3.hex bootloader with dfu-programmer (erase/flash/reset)
Test and repeat

Now that you understand how the process works, you can try out some of these keyboard samples. The easiest example is the random keypress with random delays, since it doesn’t require any components connected to the Arduino.

Random Key/Random Delay

/* Arduino USB HID Keyboard Demo * Random Key/Random Delay */ uint8_t buf[8] = { 0 }; /* Keyboard report buffer */ void setup() { Serial.begin(9600); randomSeed(analogRead(0)); delay(200); } void loop() { int randomChar = random(4, 130); long randomDelay = random(1000, 10000); delay(randomDelay); buf[2] = randomChar; // Random character Serial.write(buf, 8); // Send keypress releaseKey(); } void releaseKey() { buf[0] = 0; buf[2] = 0; Serial.write(buf, 8); // Release key }

The following two examples both use three buttons connected to the Arduino. The code can easily be changed to make the buttons perform other actions, by consulting the mapping tables in the USB HID documentation. Here is a diagram of the circuit, (created with Fritzing):

Volume+/Volume-/Mute

/* Arduino USB Keyboard HID demo * Volume+/Volume-/Mute keys */ uint8_t buf[8] = { 0 }; /* Keyboard report buffer */ #define PIN_VOLUME_UP 5 #define PIN_VOLUME_DOWN 6 #define PIN_MUTE 7 int state = 1; void setup() { Serial.begin(9600); pinMode(PIN_VOLUME_UP, INPUT); pinMode(PIN_VOLUME_DOWN, INPUT); pinMode(PIN_MUTE, INPUT); // enable internal pull-ups digitalWrite(PIN_VOLUME_UP, 1); digitalWrite(PIN_VOLUME_DOWN, 1); digitalWrite(PIN_MUTE, 1); delay(200); } void loop() { state = digitalRead(PIN_VOLUME_UP); if (state != 1) { buf[2] = 128; // Volume up key Serial.write(buf, 8); // Send keypress releaseKey(); } state = digitalRead(PIN_VOLUME_DOWN); if (state != 1) { buf[2] = 129; // Volume down key Serial.write(buf, 8); // Send keypress releaseKey(); } state = digitalRead(PIN_MUTE); if (state != 1) { buf[2] = 127; // Mute key Serial.write(buf, 8); // Send keypress releaseKey(); } } void releaseKey() { buf[0] = 0; buf[2] = 0; Serial.write(buf, 8); // Release key }

Cut/Copy/Paste

/* Arduino USB Keyboard HID demo * Cut/Copy/Paste Keys */ #define KEY_LEFT_CTRL 0x01 #define KEY_LEFT_SHIFT 0x02 #define KEY_RIGHT_CTRL 0x10 #define KEY_RIGHT_SHIFT 0x20 uint8_t buf[8] = { 0 }; /* Keyboard report buffer */ #define PIN_COPY 5 #define PIN_CUT 6 #define PIN_PASTE 7 int state = 1; void setup() { Serial.begin(9600); pinMode(PIN_COPY, INPUT); pinMode(PIN_CUT, INPUT); pinMode(PIN_PASTE, INPUT); // Enable internal pull-ups digitalWrite(PIN_COPY, 1); digitalWrite(PIN_CUT, 1); digitalWrite(PIN_PASTE, 1); delay(200); } void loop() { state = digitalRead(PIN_CUT); if (state != 1) { buf[0] = KEY_LEFT_CTRL; // Ctrl buf[2] = 27; // Letter X // buf[2] = 123; // Cut key: Less portable Serial.write(buf, 8); // Ssend keypress releaseKey(); } state = digitalRead(PIN_COPY); if (state != 1) { buf[0] = KEY_LEFT_CTRL; // Ctrl buf[2] = 6; // Letter C // buf[2] = 124; // Copy key: Less portable Serial.write(buf, 8); // Send keypress releaseKey(); } state = digitalRead(PIN_PASTE); if (state != 1) { buf[0] = KEY_LEFT_CTRL; // Ctrl buf[2] = 25; // Letter V // buf[2] = 125; // Paste key: Less portable Serial.write(buf, 8); // Send keypress releaseKey(); } } void releaseKey() { buf[0] = 0; buf[2] = 0; Serial.write(buf, 8); // Release key delay(500); }

Arduino on Raspberry Pi

Posted by michael on Jun 14, 2012 in Arduino, Raspberry Pi, Tutorials | 13 comments

Connecting an Arduino to a Raspberry Pi is simple. In a terminal, install the Arduino IDE:

sudo apt-get install arduino

This will take a while to download and install all of the dependencies. Once completed, you can start the IDE from the terminal:

arduino

Or, from the LXDE menu, Electronics->Arduino IDE. ~~Note: This is IDE version 0018, and does not seem to recognize boards newer then the Duemilanove.~~ Update: The IDE version in the package manager has been updated to version 1.01 and should work with newer boards like the Uno and Leonardo now as well.

The 1 amp power supply I have connected to my Raspberry Pi was not sufficient to power both the Pi and the Arduino through the USB port, so I connected the Arduino through a powered external USB hub. ~~This may not be necessary with a larger power supply connected to the Pi.~~ Update: A larger power supply will not overcome this limitation; the micro USB port on the Raspberry Pi is fused with 1100mA. –Thanks cavebeat

Alternatively, the 5V GPIO R_Pi Pin can be used to power the Arduino. Just connect the 5V GPIO pin on the Raspberry Pi to the VIN pin on the Arduino, and respectively GND from one board to the other.

This eliminates the need for the externally powered USB hub, but can make development more of a chore due to the USB port restriction: the keyboard and Arduino will need to be swapped in and out to flash the Arduino.

Android + Arduino + USB Host + Temperature + Light

Posted by michael on May 2, 2012 in ADB Microbridge, Android, Arduino, Tutorials | 23 comments

Sensing temperature and light with Android and Arduino. This article will demonstrate a basic thermometer / ambient light level detection input accessory.

For additional background information on interfacing Android with the real world, check out my other introductory tutorials:

Simple Digital Input
Simple Digital Output
Simple Analog Input
Simple Analog Output

Hardware

Parts needed:

Android Device (1.6+)
Photocell
10K ohm resistor
TMP36 temperature sensor
Hook-up wire
Android ADK Board*
– OR –
Arduino compatible and USB Host shield

*Supported boards include:

Google ADK board, Freeduino ADK board , Seeed Studio ADK board, and DIY Drones ADK board

Assembly

Connect one of the photocell leads to 5v and the other to analog input pin A0. Also connect the same lead through a 10K resistor to ground. In hardware, this concept is known as a voltage divider. Then connect the ground and power leads of the TMP36 to, you guessed it, ground and 5V. Finally, connect the signal lead of the TMP36 to analog input pin A1. Here is a diagram of the completed circuit (created with Fritzing):

Software

Arduino Firmware

Next, upload the Arduino sketch to the microcontroller. The sketch uses the Microbridge implementation by Niels Brouwers. Microbridge uses Android Debug Bridge (ABD) forwarding over TCP, rather than the Google Android ADK. You can checkout the source for the Arduino sketch from Github, or just copy and paste the following into the Arduino IDE.

#include <SPI.h> #include <Adb.h> // Adb connection. Connection * connection; // Elapsed time for sensor sampling long lastTime; // Event handler for shell connection; called whenever data sent from Android to Microcontroller void adbEventHandler(Connection * connection, adb_eventType event, uint16_t length, uint8_t * data) { // Unused in this case } void setup() { Serial.begin(57600); // Record time for sensor polling timer lastTime = millis(); // Init the ADB subsystem. ADB::init(); // Open an ADB stream to the phone's shell. Auto-reconnect. Use port number 4568 connection = ADB::addConnection("tcp:4568", true, adbEventHandler); Serial.println("Ready!"); } void loop() { //Check if sensor should be sampled. if ((millis() - lastTime) > 20) { uint16_t data[2]; // light sensor data[0] = analogRead(A0); float celsius = getVoltage(1); //getting the voltage reading from the temp sensor celsius = (celsius - .5) * 100; //converting from 10 mv per degree wit 500 mV offset //to degrees ((volatge - 500mV) times 100) float fahrenheit = (celsius * (9.0 / 5.0)) + 32.0; data[1] = (int) fahrenheit; //Send the sensor value to Android as 4 bytes of data. connection->write(sizeof(data),(uint8_t*)&data); // Output debugging to serial Serial.println(data[0],DEC); Serial.println(data[1],DEC); // Update timer for sensor check lastTime = millis(); } // Poll the ADB subsystem. ADB::poll(); } float getVoltage(int pin){ return (analogRead(pin) * .004882814); //converting from a 0 to 1024 digital range // to 0 to 5 volts (each 1 reading equals ~ 5 millivolts }

Android App

The next step is to install the Android Demo application onto the device. You can either download the pre-built .apk or checkout the source from Github:

git clone git://github.com/mitchtech/android_adb_temp_light.git

Finally upload the app to the device (or browse to this page on the device and download the apk above). Connect the Android device to the USB Host board/shield, and start up the app.

« Older Entries

Raspberry Pi + Arduino + SPI

Requirements

Wiring

Arduino

Arduino code

Raspberry Pi

Raspberry Pi Code

Running

Debugging

Arduino Poor Man’s Oscilloscope

lxardoscope

Poor Man’s Oscilloscope

Desktop Application

Arduino Code

Verifying the Oscilloscope

Extras

Arduino Physical CPU Gauges

Hardware

Software

Arduino USB HID Keyboard

Arduino Device Firmware Update (DFU)

Random Key/Random Delay

Volume+/Volume-/Mute

Cut/Copy/Paste

Arduino on Raspberry Pi

Android + Arduino + USB Host + Temperature + Light

Hardware

Parts needed:

Assembly

Software

Arduino Firmware

Android App

Recent Posts

#INCLUDE STD_DISCLAIMER

Live Chat

Raspberry Pi + Arduino + SPI

Requirements

Wiring

Arduino

Arduino code

Raspberry Pi

Raspberry Pi Code

Running

Debugging

Share this:

Arduino Poor Man’s Oscilloscope

lxardoscope

Poor Man’s Oscilloscope

Desktop Application

Arduino Code

Verifying the Oscilloscope

Extras

Share this:

Arduino Physical CPU Gauges

Hardware

Software

Share this:

Arduino USB HID Keyboard

Arduino Device Firmware Update (DFU)

Random Key/Random Delay

Volume+/Volume-/Mute

Cut/Copy/Paste

Share this:

Arduino on Raspberry Pi

Share this:

Android + Arduino + USB Host + Temperature + Light

Hardware

Parts needed:

Assembly

Software

Arduino Firmware

Android App

Share this:

Recent Posts

#INCLUDE STD_DISCLAIMER

Live Chat