Arduino   Hardware

Arduino with Raspberry Pi

Contents

1. 1 Arduino  
   1. 1.1 Hardware
2. 2 Arduino with Raspberry Pi
3. 3 Raspberry Pi master controls Arduino UNO slaves via I2C

    Why ? Because Arduino have more PWM and Direct, So, The following is showed that how to connect two device by I2C and Read Write between two device.

Thanks for : http://raspberrypi4dummies.wordpress.com/2013/07/18/raspberry-pi-master-controls-arduino-uno-slaves-via-i2c/

OK, I finally have the software up and running to control my Arduino (or up to 127 of them) from a single Raspberry Pi.

My objective was to add a simple way to control the i/o ports on the Arduino both analog and digital from my Raspberry Pi. Besides controlling them, I also wanted to be able to read the values on the pins, both digital & analog. Already at an early stage I figured to use the I2C interface. It’s pretty simple and straight forward and works with a bunch of other devices.

So, what I did, is turn the Arduino UNO in a slave, waiting for the commands from the Raspberry Pi.

I implemented the following commands:

setPin(device, pin, mode)

This is the equivalent of the pinMode(pin, mode).

Usage e.g. 

setPin(33, “13″, “OUPUT”).

INPUT, OUTPUT and INPUT_PULLUP are supported.

writePin(device, pin, value)

This is the equivalent of digitalWrite(pin, value).

Usage e.g. 

writePin(33, “13″, “HIGH”)

analogWritePin(device, pin, value)

This is the equivalent of analogWrite(pin, value) and can only be used on the PWM capable pins.

Usage e.g. 

writePin(33, “6″, “120″)

getStatus(device)

This asks the Arduino to read all the pins and return the values in a single 30 byte string. The Arduino performs a digital read on all the digital pins and an analog read on all the analog pins. The digital pins that are PWM enabled, are not read in case the PWM is in use. Because a read event would interrupt the PWM cycle, instead a P is returned as value.

A return string could look like this: 11000000000P011023000005121023 and can be read as follows: pin 0 and 1 are HIGH, pin 2 – 10 are LOW, pin 11 is in PWM mode, pin 12 is low, pin 13 is HIGH, A0 = 1023, A1 = 0000, A2 = 0512 and A3 = 1023.

A4 and A5 can’t be used as the pins are required for the I2C communication. 

pinValue(device, pin)

this is the equivalent of both digitalRead(pin) and analogRead(pin), it returns the value that is currently read for the specific pin.

The Python code for the raspberry can be found 

here.

In order to make use of the Raspberry Pi Master, you need to install 

the slave code on the Arduino. You need Arduino_I2C_slave_v0_21. This slave version v0_21 is not fully compatible with the Arduino Master software from my previous post and only works 100% with the Raspberry Pi.

I’m just a beginning programmer, so any feedback for me to improve is really appreciated. I’ve tried to document the programs extensively in the code.

The I2C wiring is quite simple as well. You could use an I2C connection without level shifter between the 3.3v Raspberry Pi and 5v Arduino as signals are send by pulling the signal low. However, I prefer using a level shifter in order to avoid problems.

The code on the RPi to control the Arduino could look like this if you wanted to blink the LED on pin 13:

import I2C_Master_v0.2.py

setPin(33, “13″, “Output”)

while True:

writePin(33,” 13″, “High”)

    print (“Status pin 13 = ” + pinValue(33,’13′))

    writePin(33,”13″,”Low”)

After every message from the Raspberry Pi to the Arduino a 1 sec pause is included in the code in order to avoid a request overload on the Arduino, because the Arduino is much slower than the Raspberry Pi. It would get interrupted before completing the command.

Happy tinkering!

Racer993

Raspberry Pi and Arduino Uno connected via I2C.

This is the RPI code:

I2C_Master_v0_2.py

 (click to download from my dropbox)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216

#// Arduino I2C Wire master version 0.2 #// by Racer993 <http://raspberrypi4dummies.wordpress.com/> #// Turns the Raspberry Pi into a I2C master device using I2C-tools. #// send commands to the I2C Arduino slave for configuring pins, #// read and write to pins via a simple instruction set. #// the i2c-tools are required use "sudo apt-get install i2c-tools" #// the I2C slave software must be installed on the Arduino #// Supported instructions # #// pinMode             = setPin(device, pinnumber, INPUT/OUTPUT/INPUT_PULLUP) #// digitalWrite        = writePin(device,pinnumber,HIGH/LOW) #// analogWrite (=PWM)  = analogWritePin(device,pinnumber,0-255) #// digital/analog read = getStatus(device) reads all the digital/analog pins #// digital/analog read = pinValue gets the value for a single pin # #// A0 - analog read / digital write #// A1 - analog read / digital write #// A2 - analog read / digital write #// A3 - analog read / digital write #// A4 - IN USE as SDA #// A5 - IN USE as SCL #//  1 - digital read / write + RX #//  2 - digital read / write + TX  + Interrupt #//  3 - digital read / write + PWM + Interrupt #//  4 - digital read / write #//  5 - digital read / write + PWM #//  6 - digital read / write + PWM #//  7 - digital read / write #//  8 - digital read / write #//  9 - digital read / write + PWM #// 10 - digital read / write + PWM + SPI - SS #// 11 - digital read / write + PWM + SPI - MOSI #// 12 - digital read / write +       SPI - MISO #// 13 - digital read / write + LED + SPI - SCK # # #// HOW TO USE #// sending commands #// general: all commands must be 7 bytes long + 1 ending byte # #// 1) to set the pinMode write a message with 7 characters on I2C bus to the arduino #// first character = S for set pinMode #// second & third character are pin ID 00 - 13 for digital pins & A0 - A3 for analog pins #// fourth character is to set the mode I for INPUT, O for OUTPUT, P for INPUT_PULLUP #// character 5,6,7 are not used, set to 000 #// e.g. S13O000 Sets pin 13 to an OUTPUT # #// 2) to turn the pin on or off write a message with 7 characters on I2C bus to the arduino #// first character = W for digitalWrite #// second & third character are pin ID 00 - 13 for digital pins & A0 - A3 for analog pins #// fourth character is to turn off or on H for HIGH and L for LOW #// character 5,6,7 are not used, set to 000 #// e.g. W13H000 turns pin 13 on # #// 3) to turn use PWM write a message with 7 characters on I2C bus to the arduino #// first character = A for analogWrite #// second & third character are pin ID 00 - 13 for digital pins & A0 - A3 for analog pins #// forth character is not used, set to X #// fifth - seventh character are used to write the PWM cycle (000-255) #// e.g. A05X120 performs an analogWrite on digital pin 5 with a PWM cycle of 120 # #// 4) to get a status with pin readings send Wire.requestFrom(device, #chars = 30) #// the arduino will send back 30 chars #// char 1-14 for each digital pin 1 = on 0 = off P = PWM #// char 15-18 for reading of A0, 1000 is added to the A0 reading in order to guarantee a 4 digit reading, subtract 1000 to get the proper reading #// char 19-22 for reading of A1, 1000 is added to the A0 reading in order to guarantee a 4 digit reading, subtract 1000 to get the proper reading #// char 23-26 for reading of A2, 1000 is added to the A0 reading in order to guarantee a 4 digit reading, subtract 1000 to get the proper reading #// char 27-30 for reading of A3, 1000 is added to the A0 reading in order to guarantee a 4 digit reading, subtract 1000 to get the proper reading # #// 5) to get the value for a single pin use pinValue(device,pin) to get the value back 1=HIGH, 0= LOW, P=PWM for digital pins and 0-1023 for analog pins #// remark: the communication between the RPi and Arduino is very sensitive, especially for timings #// as the RPi is much faster than the Arduino you need to included pauses between commands of atleast #// 1 sec to be save, I found that 0.5 seconds works as well (most of the time) but in that case you #// occasionally  need to perform a hard reset on the Arduino as it locks up. #// Created 28 July 2013 #// This example code is in the public domain. # # import smbus import time # RPi rev 1 = SMBus(0) # RPi rev 2 = SMBus(1) bus = smbus.SMBus(1) # address of the Arduino use "i2cdetect -y 1" from the RPi prompt to detect the Arduinos (up to 127!) device = 0x21 # initialize variables pin      = ""  #holds the pin number 0 - 13 or A0 - A3 type     = ""  #holds the pin type: INPUT, OUTPUT, INPUT_PULLUP mode     = ""  #holds the pinmode: HIGH, LOW, PWM pwmValue = ""  #holds the pwmValue pwm      = ""  #holds the pwmValue in 3 digits val      = ""  #holds a String to be converted into ASCII cmd      = ""  #holds the first byte of the message for the Arduino message  = ""  #holds the second - seventh byte of the message for the Arduino valCmd   = 88                #holds the command as ASCII value 88 = "X" valMessage  = [88,88,88,88,88,88] #holds the Message as ASCII values # ------------------------------------------------------------------------------------------------------------------------------------------------ # this routine sends a setPin command to the Arduino to make a pin INPUT, OUTPUT or INPUT_PULLUP def setPin(device, pin, type):         cmd = "S"         message = pinString(pin)+type[0]+"000"         sendMessage(device, cmd, message) # ------------------------------------------------------------------------------------------------------------------------------------------------ # this routine sends a writePin command to the Arduino to turn a pin HIGH or LOW def writePin(device, pin, mode):         cmd = "W"         message = pinString(pin)+mode[0]+"000"         sendMessage(device, cmd, message) # ------------------------------------------------------------------------------------------------------------------------------------------------ # this routine send an analogWritePin command to the Arduino to set a PWM pin to a duty cycle between 0 and 255 def analogWritePin(device, pin, pwmValue):         cmd = "A"         message = pinString(pin)+"X"+pwmString(pwmValue)         #print ("PWM Message : " + pwmValue + " : " + pwmString(pwm))         sendMessage(device, cmd, message) # ------------------------------------------------------------------------------------------------------------------------------------------------ # this routine converts Strings to ASCII code def StringToBytes(val):         retVal = []         for c in val:                 retVal.append(ord(c))         return retVal # ------------------------------------------------------------------------------------------------------------------------------------------------ # this routine actually transmits the command, # sleep is required in order to prevent a request overload on the Arduino def sendMessage(device, cmd, message):         cmd=cmd.upper()         message = message.upper()         valCmd = ord(cmd)         valMessage  = StringToBytes(message)         print("Message: " + cmd + message + " send to device " + str(device))                bus.write_i2c_block_data(device, valCmd, valMessage)         time.sleep(1) # ------------------------------------------------------------------------------------------------------------------------------------------------ # this routine send a request to the Arduino to provide a 30 byte status update, return all 30 bytes def getStatus(device):         status = ""         for i in range (0, 30):             status += chr(bus.read_byte(device))             time.sleep(0.05);         time.sleep(0.1)                return status # ------------------------------------------------------------------------------------------------------------------------------------------------ # this routine send a request to the Arduino to provide a 30 byte status update, return the value of a single pin def pinValue(device,pin):         status = ""         for i in range (0, 30):             status += chr(bus.read_byte(device))             time.sleep(0.05);         pinvalues = {'0':status[0],                      '1':status[1],                      '2':status[2],                      '3':status[3],                      '4':status[4],                      '5':status[5],                      '6':status[6],                      '7':status[7],                      '8':status[8],                      '9':status[9],                      '10':status[10],                      '11':status[11],                      '12':status[12],                      '13':status[13],                      'A0':int(status[14]+status[15]+status[16]+status[17])-1000,                      'A1':int(status[18]+status[19]+status[20]+status[21])-1000,                      'A2':int(status[22]+status[23]+status[24]+status[25])-1000,                      'A3':int(status[26]+status[27]+status[28]+status[29])-1000}         time.sleep(0.1)         return  pinvalues[pin] # ------------------------------------------------------------------------------------------------------------------------------------------------ # this routine converts a 1 or 2 digit pin into a 2 digit equivalent def pinString(pin):         while len(pin) < 2:               pin = "0"+pin;         return pin # ------------------------------------------------------------------------------------------------------------------------------------------------ # this routine converts a 1, 2 or 3 digit pin into a 3 digit equivalent def pwmString(pwm):         while len(pwm) < 3:               pwm = "0"+pwm;              return pwm # ------------------------------------------------------------------------------------------------------------------------------------------------ # this is where the main program starts pinNO = "13" pinPWM = "A2" setPin(33, pinPWM, "Output") for i in range(0, 254, 25):     analogWritePin(33, pinPWM, str(i)) analogWritePin(33, pinPWM, str(0)) while True:    setPin(33, pinNO, "Output")  #on Arduino with I2C ID #33 set pin 13 to OUTPUT    writePin(33,pinNO, "High")   #on Arduino with I2C ID #33 set pin 13 HIGH    print ("Status pin 3 =" + pinValue(33,pinNO))        writePin(33,pinNO,"Low")     #on Arduino with I2C ID #33 set pin 13 LOW    print("30 byte status:" + getStatus(33))

This is the Arduino Slave code:

Arduino_I2C_slave_v0_21

 (click to download from my dropbox)

// Arduino I2C Wire Slave version 0.21

// by Racer993 <

http://raspberrypi4dummies.wordpress.com/&gt;

// Turns the Arduino to a I2C slave device (for the Raspberry Pi)

// using the Wire library. Configure pins, read and write to pins

// via a simple instruction set.

// Supported instructions

// pinMode = setPin(device, pinnumber, INPUT/OUTPUT/INPUT_PULLUP)

// digitalWrite = writePin(device,pinnumber,HIGH/LOW)

// analogWrite = analogWritePin(device,pinnumber,0-255)

// getStatus(device)

// A0 – analog read / digital write

// A1 – analog read / digital write

// A2 – analog read / digital write

// A3 – analog read / digital write

// A4 – IN USE as SDA

// A5 – IN USE as SCL

// 1 – digital read / write + RX

// 2 – digital read / write + TX + Interrupt

// 3 – digital read / write + PWM + Interrupt

// 4 – digital read / write

// 5 – digital read / write + PWM

// 6 – digital read / write + PWM

// 7 – digital read / write

// 8 – digital read / write

// 9 – digital read / write + PWM

// 10 – digital read / write + PWM + SPI – SS

// 11 – digital read / write + PWM + SPI – MOSI

// 12 – digital read / write + SPI – MISO

// 13 – digital read / write + LED + SPI – SCK

// HOW TO USE

// sending commands

// general: all commands must be 7 bytes long + 1 ending byte

// 1) to set the pinMode write a message with 7 characters on I2C bus to the arduino

// first character = S for set pinMode

// second & third character are pin ID 00 – 13 for digital pins & A0 – A3 for analog pins

// fourth character is to set the mode I for INPUT, O for OUTPUT, P for INPUT_PULLUP

// character 5,6,7 are not used, set to 000

// 2) to turn the pin on or off write a message with 7 characters on I2C bus to the arduino

// first character = W for digitalWrite

// second & third character are pin ID 00 – 13 for digital pins & A0 – A3 for analog pins

// fourth character is to turn off or on H for HIGH and L for LOW

// character 5,6,7 are not used, set to 000

// 3) to turn use PWM write a message with 7 characters on I2C bus to the arduino

// first character = A for analogWrite

// second & third character are pin ID 00 – 13 for digital pins & A0 – A3 for analog pins

// forth character is not used, set to X

// fifth – seventh character are used to write the PWM cycle (000-255)

// 4) to get a status with pin readings send Wire.requestFrom(device, #chars = 30)

// the arduino will send back 30 chars

// char 1-14 for each digital pin 1 = on 0 = off

// char 15-18 for reading of A0, 1000 is added to the A0 reading in order to guarantee a 4 digit reading, subtract 1000 to get the proper reading

// char 19-22 for reading of A1, 1000 is added to the A0 reading in order to guarantee a 4 digit reading, subtract 1000 to get the proper reading

// char 23-26 for reading of A2, 1000 is added to the A0 reading in order to guarantee a 4 digit reading, subtract 1000 to get the proper reading

// char 27-30 for reading of A3, 1000 is added to the A0 reading in order to guarantee a 4 digit reading, subtract 1000 to get the proper reading

// Created 17 July 2013

// This example code is in the public domain.

#include <Wire.h>

void setup()

{

int arduinoI2CAddress = 33; // set the slave address for the Arduino on the I2C buss

Wire.begin(arduinoI2CAddress

); // join i2c bus with specified address
Wire.onRequest(requestEvent); // register wire.request interrupt event
Wire.onReceive(receiveEvent); // register 

Wire.onRequest(requestEvent); // register wire.request interrupt event

Wire.onReceive(receiveEvent); // register 

wire.write interrupt event
}

}

char sendStatus[31] = “000000000000000000000000000000″; // initialize the container variable

int index = 0; // initialize the index variable

char pwm[15] = “00000000000000″; // initialize the PWM flag container

void loop()

{

String pinStatus=””; // initialize pinStatus variable

for(int digitalPin = 0; digitalPin <= 13; digitalPin++) // loop through 14 digital pins 0 – 13

{

if (pwm[digitalPin] == 0) // in case PWM is off for the pin, read the pin status

{

pinStatus += String (digitalRead(digitalPin)); // read the pin status & add it to the container variable

}

else

{

pinStatus += “P”; // in case PWM is on for the pin, add P to the pin status container string

}

}

for(int analogPin = 0; analogPin <= 3; analogPin++) // loop through the 4 (unused) analog pins 0 – 3

{

pinStatus += String (1000+analogRead(analogPin)); // read the analog value from the pin, add 1000 to make it 4 digit & add it to the container variable

}

pinStatus.toCharArray(sendStatus, 31); // convert the container variable pinStatus to a char array which can be send over i2c

delay(1000); // wait for an interrupt event

}

//——————————————————————————–

// function that executes whenever a status update is requested by master

// this function is registered as an event, see setup()

void requestEvent() {

Wire.write(sendStatus

[index]);
++index;
if (index >= 30) {
index = 0;
}
}

++index;

if (index >= 30) {

index = 0;

}

}

//——————————————————————————–

// function that executes whenever a message is received from master

// this function is registered as an event, see setup()

void receiveEvent(int howMany)

{

int receiveByte = 0; // set index to 0

char command[7]; // expect 7 char + 1 end byte

String mode = “”; // initialize mode variable for holding the mode

String pin = “”; // initialize pin variable for holding the pin number as a String

String awValue = “”; // intitalize the variable for holding the analogWrite value

int pinVal; // inititalize the variable for holding the pin number as integer

int awValueVal; // initialize the variable for holding the analog write value as integer (only PWM pins!)

while(Wire.available()) // loop through all incoming bytes

{

command[receiveByte] = 

Wire.read(); // receive byte as a character
receiveByte++; // increase index by 1
}

receiveByte++; // increase index by 1

}

pin = String(command[1]) + String(command[2]); // combine byte 2 and 3 in order to get the pin number

awValue = String(command[4]) + String(command[5]) + String(command[6]); // combine byte 5, 6 and 7 in order to get the analogWrite value

awValueVal = 

awValue.toInt(); // convert the awValue string to a value

if (String(command[1]) != “A” ) { pinVal = 

pin.toInt();} // in case of not an analog pin assignment convert into digital pin number
if (String(command[1]) != “A” ) { pwm[pinVal] = 0;} // in case of not an analog pin assignment set PWM flag to 0

if (String(command[1]) != “A” ) { pwm[pinVal] = 0;} // in case of not an analog pin assignment set PWM flag to 0

// incase of analog pin assignment determine analog pin to be set

if (String(command[1]) == “A” && String(command[2]) == “0″) { pinVal = A0;}

if (String(command[1]) == “A” && String(command[2]) == “1″) { pinVal = A1;}

if (String(command[1]) == “A” && String(command[2]) == “2″) { pinVal = A2;}

if (String(command[1]) == “A” && String(command[2]) == “3″) { pinVal = A3;}

// if requested set pinmode

if (String(command[0]) == “S” && String(command[3]) == “I”) { pinMode(pinVal, INPUT);}

if (String(command[0]) == “S” && String(command[3]) == “O”) { pinMode(pinVal, OUTPUT);}

if (String(command[0]) == “S” && String(command[3]) == “P”) { pinMode(pinVal, INPUT_PULLUP);}

// if requested perform digital write

if (String(command[0]) == “W” && String(command[3]) == “H”) { digitalWrite(pinVal, HIGH);}

if (String(command[0]) == “W” && String(command[3]) == “L”) { digitalWrite(pinVal, LOW);}

// if requested perform analog write

if (String(command[0]) == “A” && pinVal == 3 || pinVal == 5 || pinVal == 6 || pinVal == 9 || pinVal == 10 || pinVal == 11 )

{

analogWrite(pinVal, awValueVal);

pwm[pinVal] = 1;

}

}