Tag Archives: Tutorial

Beaglebone Black GPS LESSON 1: Hooking Up the Adafruit Ultimate GPS

Beaglebone GPS
Beaglebone Black connected to the Adafruit Ultimate GPS

If you went through our series of 12 lessons on the Beaglebone black you should be familiar with the basics of this microcontroller. We are now ready to move on to more advanced projects. In our earlier lessons on the Arduino, we built a GPS data logger and integrated it with Google Earth using the Arduino Uno and the Adafruit Ultimate GPS Breakout Board. While that was a great project, we finally ran out of horsepower with the arduino, and what we could do was limited by the memory limitations on the Arduino. Also, it is very hard to parse strings in the Arduino IDE, so interpreting the NMEA sentences is a rather large challenge with the limited string functionality in Arduino.

Python on the other hand makes quick work of string manipulation and the Beaglebone Black has plenty of horsepower for any manipulation of the NMEA sentences we might want to do.

In order to play along with this project, you will need a Beaglebone Black Rev C, which you can get HERE, and the Adafruit Ultimate GPS which you can get HERE. The video below takes you through the project step-by-step, as well as the description below.

Once you get your gear, you will want to hook up the following circuit:

Beaglebone GPS
Adafruit Ultimate GPS connected to the Beaglebone Black Rev C Microcontroller

Note that we are working off header P9 and we are using P9_1 as ground, P9_7 as VIN, we are using P9_24 as  Tx and P9_26 as Rx. Please note that you can see a detailed Diagram of the Beaglebone Black pinout HERE. Also notice that Tx on the Beaglebone is connected to Rx on the GPS, and Rx on the Beaglebone is connected to Tx on the GPS. Tx is like “talk” and Rx is like “listen, so you want to listen to the pin that is talking, and you want to talk to the pin that is listening.

Our goal in this first lesson is to establish a connection between the GPS and the Beaglebone, and to read in the data streaming from the GPS. We want to get a fix, and verify that we can read and print the NMEA sentences that contain the various position, altitude and velocity data.

The video takes you step-by-step through the code. The following simple code will get you streaming data from the GPS to your terminal window. In future lessons we will break the data down and show you how to get your position from the raw NMEA sentences streaming in.


Beaglebone Black LESSON 9: Reading Analog Inputs from Python

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:

A Simple Voltage Divider Using a Potentiometer

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.

 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.

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

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.

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

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.

 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:

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:

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:

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:

And always remember to clean up after yourself with:

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.

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

Beaglebone Black LESSON 1: Understanding Beaglebone Black Pinout

This is the first in a series of lessons on the Beaglebone Black. Hopefully you have been with us through our earlier series of lessons on the Arduino, Python, and the Raspberry Pi. If you have been through those lessons learning the Beaglebone will be a snap.

If you are going to follow along with us in these lessons, you can go ahead and order your Beaglebone HERE.

To get started, we need to first of all get our mind around all the different pins. I have put together the diagram below for the default pin assignments for the Beaglebone black.

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

You can see that the Beaglebone has a large number of pins. There are two headers. Make sure you orient your Beaglebone n the same direction as mine in the picture, with the five volt plug on the top. In this orientation, the pin header on the left is referred to as “P9” and the pin header on the right is referred to as “P8”.  The legend in the diagram above shows the funtions, or the possible functions of the various pins. First, we have shaded in red the various 5V, 3.3V, 1.8V and ground pins. Note that VDD_ADC is a 1.8 Volt supply and is used to provide a reference for Analog Read functions. The general purpose GPIO pins have been shaded in green. Note some of these green pins can also be used for UART serial communication. If you want to simmulate analog output, between 0 and 3.3 volts, you can use the PWM pins shaded in purple. The light blue pins can be used as analog in. Please note that the Analog In reads between 0 and 1.8 volts. You should not allow these pins to see higher voltages that 1.8 volts. When using these pins, use pins 32 and 34 as your voltage reference and ground, as pin 32 outputs a handy 1.8 volts.  The pins shaded in light orange can be used for I2C.  The dark orange pins are primarily used for LCD screen applications.

Raspberry Pi LESSON 32: Options for Analog Input on the Raspberry Pi

At this point we have learned how to write digital values to the GPIO pins, we have learned to simulate analog out using PWM, and we have learned how to do digital reads from the pins. If you are like me and came from the Arduino world, then you will likely be asking, “Now what about analog reads”. The arduino has pins A0-A5 that make quick and easy work of reading analog values from things like photometers, sensors and various other circuit elements.

The bottom line is, unfortunately, there are no analogous capabilities on the Raspberry Pi. There is no way to directly read analog voltages.

Some suggest incorporating various analog to digital converter chips into your circuits requiring analog reads. For me, my preferred solution is the simply add an Arduino to the Raspberry Pi circuit. There are many very small form factor versions of the Arduino. For example, the nano is very small, and there are some examples that are even smaller. Some of these small implementations can be found for under $10.

If you take this approach, then all you have to do is learn how to communicate between the Raspberry Pi and Arduino either over USB or over ethernet. I show you how to do both of these things in the Lesson series on this WEB site “Using Python with Arduino”. This shows how to communicate between python and arduino using the USB, using Ethernet, or using the Xbee radios. Since python runs on the Raspberry Pi, all the techniques taught in those lessons can be applied to the raspberry pi.

In our high altitude balloon instrumentation package, we actually run a raspberry pi that is controlling two arduino nano microcontrollers. The one arduino is controlling the 9-axis IMU, and the other arduino is running GPS, Temperature, Pressure, and other sensors. The raspberry pi and Arduinos communicate over a small onboard Ethernet switch. The system communicates back to the ground via 1 watt ubiquity bullet radios.

So, the Raspberry Pi should not be viewed as a replacement for the Arduino, it should be viewed as a complementary device that can work nicely alongside the Arduino.

Raspberry Pi LESSON 30: Controlling LEDs from Push Buttons

In this lesson we will show how you can control LED’s from push buttons. In order to get started, you will want to expand the circuit we built in LESSON 29 to include two LEDs. The schematic below shows how you will want to hook things up (Also, remember you can see the Raspberry Pi pinout in LESSON 25). Also, as we have mentioned before, if you want to follow along with us in these lessons you can get a kit that has all the gear you need HERE.

Raspberry Pi LED Circuit
This Circuit Controls two LED from Push Buttons Using the Raspberry Pi

In the video lesson, we take you through the code step-by-step. We use the techniques learned in LESSON 29 to detect if a button has been pushed. We introduce two new variables, BS1 and BS2, so indicate the state of the LED’s. A BS1=False means the LED1 is off. A BS1=True means the LED is on. This concept allows us to determine whether we should turn the LED on or off when the button is pushed. Basically, we want to put it in the opposite state when a button is pushed. The code is below. The video shows how it works.