Category Archives: Tutorial

If you went through our series of lesson on the Raspberry Pi, you will remember that we found the major limitation of the Pi is that it has no analog input pins. Luckily, the Beaglebone Black as a number of analog input pins, so we can greatly expand the scope of projects we can do. The pinout below shows the pins that are available on the Beaglebone Black for analog input. (If you do not already have your Beaglebone Black, you can pick one up HERE.)

Beaglebone Black Pinout — Default Pin Configuration for the Beaglebone Black Rev. C.

You can see the blue shaded pins in the diagram above are for analog input.

A couple of very important points. These pins are designed to read analog voltages between 0 and 1.8 volts. Applying voltages above 1.8 volts can burn out the pin, or even smoke the Beaglebone. Hence, as you set up voltage divider circuits you must ensure they have a rail of 1.8 Volts, to ensure that the analog in pins will never see more than 1.8 Volts. Luckily, the Beaglebone provides a handy 1.8 Volt reference signal on pin 32 (on P9 header). Always use pin 32 as your reference rail when working with analog inputs. Similarly, you should use pin 34 (on P9 header) as your reference ground on your analog input circuits.

To demonstrate how to do analog reads, we will set up a simple voltage divider using a potentiometer. Go ahead and hook up your circuit as follows:

Note we are using P9_32 as the reference voltage on the voltage divider, we are using P9_34 as the reference ground, and we are using P9_33 as the analog sense pin.

With this circuit hooked up we are ready to develop some code. In the attached video we take you through this program step-by-step to show you how you can make analog readings from the potentiometer using python.

import Adafruit_BBIO.ADC as ADC
ADC.setup()
from time import sleep
analogPin="P9_33"
while(1):
        potVal=ADC.read(analogPin)
        potVolt=potVal*1.8
        print "The Potentiometer Voltage is: ",potVolt
        sleep(.5)

import Adafruit_BBIO.ADC as ADC

ADC.setup()

from time import sleep

analogPin="P9_33"

while(1):

potVal=ADC.read(analogPin)

potVolt=potVal*1.8

print "The Potentiometer Voltage is: ",potVolt

sleep(.5)

Note the analog read returns a number between 0 and 1, which is proportional to the applied voltage. Hence to convert to actual voltage, we multiply this read value by 1.8 Volts.

Beaglevone Black Rev. C, Tutorial

Beaglebone Black LESSON 6: Control PWM Signals on Output Pins from Python

June 9, 2015 admin

In Lesson 4 and Lesson 5 we showed how to do digital writes to the GPIO pins using Python. (If you have not picked up your Beaglebone Black Rev. C yet, you can get one HERE) With digital writes, we could generate an output of 3.3 volts or 0 volts. For many applications, we would like analog output, or the in between voltages. The Beaglebone Black, as with most microcontrollers, can not produce true analog output. However, for many applications, an analog output can be simulated by creating a fast on/off sequence where the analog value is simmulated by controlling the ratio of on time and off time. This technique is called Pulse Width Modulation, or more simply, PWM. Consider a 3.3 volt signal, which is turning on and off with a frequency of 50 Hz. A 50 Hz signal has a Period of: Period=1/frequency=1/50=.02 seconds, or 20 milliseconds. If during that 20 millisecond period, the signal was “High” for 10 milliseconds, and “Low” for 10 milliseconds, the signal would act like a 1.65 volt analog signal. The output voltage therefor could be considered the rail voltage (3.3 volts) multiplied by the duty cycle (percentage of time the signal is high.

For the Beaglebone Black, only certain pins can be used for PWM signals.

In the chart above, the purple pins are suitable for PWM output. You can see there are 7 pins which can produce PWM signals. In this lesson we show you how to control those pins.

In order to control PWM signals, we are going to use Python and the Adafruid_BBIO Library. Recent versions of Beaglebone Black Rev. C are shipped with the library already part of the operating system. If you are getting errors indicating that you do not have the library, update your operating system to the latest Debian image for the Beaglebone Black.

In order to use PWM in Python, you must load the Adafruit Library. If you have the recent versions of Debian Wheezy for the Beaglebone black, the library will already be on your system. If you do not do an update and upgrade on your operating system.

To begin with, you will need to load the library.

import Adafruit_BBIO.PWM as PWM

1	import Adafruit_BBIO.PWM as PWM

Next up, you will need to start the PWM on the pin you are using. We will use pin “P8_13”. Remember you must use one of the purple colored pins on the chart above. We start the PWM with the following command:

PWM.start("P8_13", 25, 1000)

1	PWM.start("P8_13", 25, 1000)

This command puts a 1000 Hz signal (Period of 1 mSec) on pin P8_13, with a duty cycle of 25%. This should yield a simulated analog voltage of .84 volts.

We can change the duty cycle after this initial setup with the command:

PWM.set_duty_cycle("P8_13", 90)

1	PWM.set_duty_cycle("P8_13", 90)

This command would change the duty cycle to 90%, which would simulate a voltage of 3.3 * .9 = 2.97 volts.

You can also change the frequency of the signal using the command:

PWM.set_frequency("P8_13", 100)

1	PWM.set_frequency("P8_13", 100)

This would change the frequency to 100 Hz (Period of 10 mSec). Changing the frequency does not really affect the net result of PWM in most applications, although it does matter for many servo applications.

After you are done, you can stop the PWM with the command:

PWM.stop("P8_13")

1	PWM.stop("P8_13")

And always remember to clean up after yourself with:

PWM.cleanup()

1	PWM.cleanup()

Play around with the Python Program below. Connect a DVM to your Beaglebone Black, and measure the DC voltage at the output pin. The DVM should show your anticipated voltages.

import Adafruit_BBIO.PWM as PWM
myPWM="P8_13"
PWM.start(myPWM, 0, 1000)
for i in range(0,5):
    DC=input("What Duty Cycle Would You Like (0-100)? ")
    PWM.set_duty_cycle(myPWM, DC)
PWM.stop(myPWM)
PWM.cleanup()

import Adafruit_BBIO.PWM as PWM

myPWM="P8_13"

PWM.start(myPWM, 0, 1000)

for i in range(0,5):

DC=input("What Duty Cycle Would You Like (0-100)? ")

PWM.set_duty_cycle(myPWM, DC)

PWM.stop(myPWM)

PWM.cleanup()

Considering that the simulated analog voltage V=3.365 X Duty Cycle, how would modify the program above to ask the user for the Voltage he desires, and then calculate the duty cycle that would give that voltage. Your assignment is to modify the program above where the user inputs desired voltage, and DC is calculated. Use a DVM to check your results

Tutorial

Comparing the Arduino, Raspberry Pi Model 2, and Beaglebone Black

June 5, 2015 admin

In this video we do a head to head comparison of the Arduino, Raspberry Pi Model 2, and the Beaglebone black. We compare the pros and cons of each platform and discuss how to decide which platform to learn on and which is best for different types of projects.

You can pick up the gear discussed in this video below:

Arduino: This is a great place to start, and the device is very affordable.

Sparkfun Inventor Kit: Everything you need to learn microcontroller programming and circuits. This is the kit we use in our Arduino Lessons, and even includes the Arduino.

Raspberry Pi Kit: This kit has everything you need to follow along on our Raspberry Pi Lessons.

Raspberry Pi: If you already have the cords and cables, you can buy just the Raspberry Pi.

Beaglebone Black: We are not working on a series of lessons showing you how to use the Beaglebone Black. Now would be a good time to go ahead and order your Beagle.

I hope you enjoyed this video lesson, and hope you will jump in and take our lessons on using the Arduino, Raspberry Pi, and the Beaglebone Black

Raspberry Pi, Tutorial

Raspberry Pi LESSON 29: Configuring GPIO Pins as Inputs

June 3, 2015 admin

We are now ready to learn how to “read” values from the Raspberry Pi GPIO pins. In order to demonstrate this, we will show a simple example using buttons. If you ordered the Raspberry Pi kit we recommend, you already have everything you need, or you can pick your kit up HERE. To start with, you need to put together a simple circuit that connects two push buttons to your Raspberry Pi. Connect according to this schematic.

Raspberry Pi Buttons — Simple Circuit Connecting Two Push Buttons to the Raspberry Pi

Note that one leg of each button is connected to the ground rail on the breadboard, that is connected to the Pi ground at physical pin 6. Then we connect the left leg of the left button to physical pin 16, and the left leg of the right button to physical pin 12.

In order to read the state of these buttons, that is, whether they are being pressed or not, we need to write a python program. To begin with we must import GPIO library and specify that we want to

from time import sleep     # Import time library
import RPi.GPIO as GPIO    # Import RPi Library
GPIO.setmode(GPIO.BOARD)   # Specify We Want to reference Physical pins

from time import sleep # Import time library

import RPi.GPIO as GPIO # Import RPi Library

GPIO.setmode(GPIO.BOARD) # Specify We Want to reference Physical pins

Now we are ready to set the pin modes on the pins we are using. We are using pins 12 and 16. We will set up variables so that we can reference the pins by descriptive variables.

button1=16  # Descriptive Variable for pin 16
button2=12  # Descriptive Variable for pin 12
GPIO.setup(button1,GPIO.IN,pull_up_down=GPIO.PUD_UP) # Set button1 as input and Activate pull up resistor
GPIO.setup(button2,GPIO.IN,pull_up_down=GPIO.PUD_UP) # Set button2 as input and Activate pull up resisor

button1=16 # Descriptive Variable for pin 16

button2=12 # Descriptive Variable for pin 12

GPIO.setup(button1,GPIO.IN,pull_up_down=GPIO.PUD_UP) # Set button1 as input and Activate pull up resistor

GPIO.setup(button2,GPIO.IN,pull_up_down=GPIO.PUD_UP) # Set button2 as input and Activate pull up resisor

Note in our GPIO.setup commands, we are not just defining the pins as inputs, we are also activating pullup resistors with

pull_up_down=GPIO.PUD_UP

1	pull_up_down=GPIO.PUD_UP

With this command, the raspberry pi places a pullup resistor between the designated pin and the 3.3 V rail. This means that if we simply read the pin, we will read a “1”, “True”, or “High”, since the pin will see the rail through the pullup resistor. If we connect the pin to ground by pressing a button or switch, the pin will then read a “0”, “False” or “Low” because it will be a straight connection to ground, and as current flows through the pullup resistor, the 3.3 Volts will drop across the pullup resistor. Hence, the pin sees 0 volts.

The result is that with the pullup resistor activated, the pin will always report a “1” until something connects the pin to ground, and then it will read a “0”. This configuration should work for most things, but if you are getting unpredictable results which can result from electrical noise, then try using external pullup resistors.

Now we are ready to read the values from the pins.

while(1): # Create an infinite loop

        if GPIO.input(button1)==0: # button1 will report 0 if it is pressed
                print "Button 1 Pressed"
                sleep(.1)   # delay
        if  GPIO.input(button2)==0: # button 2 will report 0 if it is presses
                sleep(.1)
                print "Button 2 Pressed"

while(1): # Create an infinite loop

if GPIO.input(button1)==0: # button1 will report 0 if it is pressed

print "Button 1 Pressed"

sleep(.1) # delay

if GPIO.input(button2)==0: # button 2 will report 0 if it is presses

sleep(.1)

print "Button 2 Pressed"

Notice that we read from the pin using the GPIO.input command. Also note that for reliable results you need to usually put a small delay in your code. This will help debounce the button, and will also give more stable results.

OK, so our final code is as follows:

from time import sleep
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BOARD)
button1=16
button2=12
GPIO.setup(button1,GPIO.IN,pull_up_down=GPIO.PUD_UP)
GPIO.setup(button2,GPIO.IN,pull_up_down=GPIO.PUD_UP)
while(1):
        if GPIO.input(button1)==0:
                print "Button 1 Pressed"
                sleep(.1)
        if  GPIO.input(button2)==0:
                sleep(.1)
                print "Button 2 Pressed"

from time import sleep

import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BOARD)

button1=16

button2=12

GPIO.setup(button1,GPIO.IN,pull_up_down=GPIO.PUD_UP)

GPIO.setup(button2,GPIO.IN,pull_up_down=GPIO.PUD_UP)

while(1):

if GPIO.input(button1)==0:

print "Button 1 Pressed"

sleep(.1)

if GPIO.input(button2)==0:

sleep(.1)

print "Button 2 Pressed"

This code will sit and monitor the buttons, and when one is pressed it will report that that button has been pressed.

Arduino with Python, Tutorial

Python with Arduino LESSON 17: Sending and Receiving Data Over Ethernet

April 6, 2015 admin

Arduino Ethernet — This circuit contains an Arduino Nano and Pressure Sensor Communicating over Ethernet

In LESSON 16 we showed a simple Client Server model that allows us to send strings between Python running on a PC and the arduino over Ethernet. That lesson simply passed strings back and forth to show a very basic Server on Arduino, and Python acting as the Client. In this lesson we show a more practical example, with the Arduino connected to an Adafruit BMP180 Pressure Sensor. In order to complete this lesson, you will need an Arduino, an Ethernet Shield, and the Pressure Sensor. If you do not have this particular pressure sensor, you can probably follow along in the lesson using whatever sensor you have that is of interest. The video will take you through the tutorial step-by-step, and then the code we developed is shown below.

The key issue in getting this project to work is to get your mac address and IP address from your router or network. If you are at school, simply speak to your network administrator, and he will help you get an IP address for your arduino. If you are at home, you will need to connect to your router from a browser, and configure it to assign an IP address and agree on a mac address for your arduino. Some arduino Ethernet shields have a sticker with a mac address. If your Ethernet shield has a sticker with mac address, use that one. If it does not, you will need to come up with a unique mac address. There are thousands of possible routers and networks out there, so I can not help you with that part. But if you look in the router documentation, you should be able to get the IP address and mac address worked out. The arduino itself does not have a hard wired mac address, but you set the mac address in the arduino software, and the IP address as well. The key thing is that the mac address is unique on your network, and the router and arduino agree on the IP address and mac address. If you have a clearer way to explain this, please leave a comment below.

This is the server side software to run on the arduino. Again, you should use a suitable IP address and mac address for your network. Do not think you can just copy the ones I use in the code below.

#include <Ethernet.h> //Load Ethernet Library
#include <EthernetUdp.h> //Load the Udp Library
#include <SPI.h> //Load SPI Library

#include "Wire.h" //imports the wire library
#include "Adafruit_BMP085.h" // import the Pressure/Temperature sensor library
Adafruit_BMP085 mySensor; //Create a sensor object

float tempC; //Declare variable for Temp in C
float tempF; //Declare variable for Temp in F
float Pressure; //Declare a variable for Pressure

byte mac[] ={ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xEE}; //Assign mac address
IPAddress ip(10, 1, 15, 243); //Assign the IP Adress
unsigned int localPort = 5000; // Assign a port to talk over
char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; //dimensian a char array to hold our data packet
String datReq; //String for our data
int packetSize; //Size of the packet
EthernetUDP Udp; // Create a UDP Object

void setup() {
  
  Serial.begin(9600); //Initialize Serial Port 
  Ethernet.begin( mac, ip); //Inialize the Ethernet
  Udp.begin(localPort); //Initialize Udp
  delay(1500); //delay
  mySensor.begin(); //initialize pressure-temp sensor
  

}

void loop() {
  
  packetSize =Udp.parsePacket(); //Reads the packet size
  
  if(packetSize>0) { //if packetSize is >0, that means someone has sent a request
    
    Udp.read(packetBuffer, UDP_TX_PACKET_MAX_SIZE); //Read the data request
    String datReq(packetBuffer); //Convert char array packetBuffer into a string called datReq
    
    if (datReq =="Temperature") { //Do the following if Temperature is requested
    
      tempC = mySensor.readTemperature(); //Read the temperature
      tempF = tempC*1.8 + 32; //Convert temp to F
      
      Udp.beginPacket(Udp.remoteIP(), Udp.remotePort()); //Initialize packet send
      Udp.print(tempF); //Send the temperature data
      Udp.endPacket(); //End the packet
      
    }
    
    if (datReq== "Pressure") { //Do the following if Pressure is requested
    
      Pressure=mySensor.readPressure(); //read the pressure
      
        Udp.beginPacket(Udp.remoteIP(), Udp.remotePort()); //Initialize packet send
        Udp.print(Pressure); //Send the Pressure data
        Udp.endPacket(); //End the packet
        
    }
      
  }
  memset(packetBuffer, 0, UDP_TX_PACKET_MAX_SIZE); //clear out the packetBuffer array
}

#include <Ethernet.h> //Load Ethernet Library

#include <EthernetUdp.h> //Load the Udp Library

#include <SPI.h> //Load SPI Library

#include "Wire.h" //imports the wire library

#include "Adafruit_BMP085.h" // import the Pressure/Temperature sensor library

Adafruit_BMP085 mySensor; //Create a sensor object

float tempC; //Declare variable for Temp in C

float tempF; //Declare variable for Temp in F

float Pressure; //Declare a variable for Pressure

byte mac[] ={ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xEE}; //Assign mac address

IPAddress ip(10, 1, 15, 243); //Assign the IP Adress

unsigned int localPort = 5000; // Assign a port to talk over

char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; //dimensian a char array to hold our data packet

String datReq; //String for our data

int packetSize; //Size of the packet

EthernetUDP Udp; // Create a UDP Object

void setup() {

Serial.begin(9600); //Initialize Serial Port

Ethernet.begin( mac, ip); //Inialize the Ethernet

Udp.begin(localPort); //Initialize Udp

delay(1500); //delay

mySensor.begin(); //initialize pressure-temp sensor

}

void loop() {

packetSize =Udp.parsePacket(); //Reads the packet size

if(packetSize>0) { //if packetSize is >0, that means someone has sent a request

Udp.read(packetBuffer, UDP_TX_PACKET_MAX_SIZE); //Read the data request

String datReq(packetBuffer); //Convert char array packetBuffer into a string called datReq

if (datReq =="Temperature") { //Do the following if Temperature is requested

tempC = mySensor.readTemperature(); //Read the temperature

tempF = tempC*1.8 + 32; //Convert temp to F

Udp.beginPacket(Udp.remoteIP(), Udp.remotePort()); //Initialize packet send

Udp.print(tempF); //Send the temperature data

Udp.endPacket(); //End the packet

}

if (datReq== "Pressure") { //Do the following if Pressure is requested

Pressure=mySensor.readPressure(); //read the pressure

Udp.beginPacket(Udp.remoteIP(), Udp.remotePort()); //Initialize packet send

Udp.print(Pressure); //Send the Pressure data

Udp.endPacket(); //End the packet

}

memset(packetBuffer, 0, UDP_TX_PACKET_MAX_SIZE); //clear out the packetBuffer array

}

Once you have this on your arduino, and the arduino connected to the internet via an Ethernet cable, you can test by opening a command line in Windows. Then ping the address you have assigned to the Arduino. If it pings correctly and you get a reply, you are ready to develop the Python code. The Python will be the client. It will send the requests to the Arduino, and the Arduino will respond with data. Since our circuit can measure pressure or temperature, you can request either of those. When the arduino receives a request for temperature, it will go out, make the temperature measurement and then return the data to Python. Similarly, if you request Pressure the arduino will read the request, will make the Pressure measurement, and then return pressure reading to the client (Python).

from socket import *
import time

address= ( '10.1.15.243', 5000) #define server IP and port
client_socket =socket(AF_INET, SOCK_DGRAM) #Set up the Socket
client_socket.settimeout(1) #Only wait 1 second for a response

while(1):

    data = "Temperature" #Set data request to Temperature

    client_socket.sendto( data, address) #Send the data request

    try:

        rec_data, addr = client_socket.recvfrom(2048) #Read response from arduino
        temp = float(rec_data) #Convert string rec_data to float temp
        print "The Measured Temperature is ", temp, " degrees F." # Print the result

    except:
        pass

    time.sleep(2) #delay before sending next command

    data = "Pressure" #Set data request to Pressure

    client_socket.sendto( data, address) #Send the data request

    try:

        rec_data, addr = client_socket.recvfrom(2048) #Read response from arduino
        Pressure = float(rec_data) #Convert string rec_data to float temp
        print "The Measured Pressure is ", Pressure, " Pa." # Print the result

    except:
        pass

    time.sleep(2) #delay before sending next command

    print ""

from socket import *

import time

address= ( '10.1.15.243', 5000) #define server IP and port

client_socket =socket(AF_INET, SOCK_DGRAM) #Set up the Socket

client_socket.settimeout(1) #Only wait 1 second for a response

while(1):

data = "Temperature" #Set data request to Temperature

client_socket.sendto( data, address) #Send the data request

try:

rec_data, addr = client_socket.recvfrom(2048) #Read response from arduino

temp = float(rec_data) #Convert string rec_data to float temp

print "The Measured Temperature is ", temp, " degrees F." # Print the result

except:

pass

time.sleep(2) #delay before sending next command

data = "Pressure" #Set data request to Pressure

client_socket.sendto( data, address) #Send the data request

try:

rec_data, addr = client_socket.recvfrom(2048) #Read response from arduino

Pressure = float(rec_data) #Convert string rec_data to float temp

print "The Measured Pressure is ", Pressure, " Pa." # Print the result

except:

pass

time.sleep(2) #delay before sending next command

print ""

This python code will request Temperature, will then read the response, and then will print the data. It then requests Pressure, reads the response, and then prints it. If you look at our earlier lessons you can see graphical techniques to visually present the data. The hard part is getting the data passed back and forth, which we show how to do in this lesson.

Technology Tutorials

Category Archives: Tutorial

Beaglebone Black LESSON 9: Reading Analog Inputs from Python

Beaglebone Black LESSON 6: Control PWM Signals on Output Pins from Python

Comparing the Arduino, Raspberry Pi Model 2, and Beaglebone Black

Raspberry Pi LESSON 29: Configuring GPIO Pins as Inputs

Python with Arduino LESSON 17: Sending and Receiving Data Over Ethernet

Making The World a Better Place One High Tech Project at a Time. Enjoy!