Hands on Beaglebone Introduction on beaglebone

Hands on Beaglebone Introduction on beaglebone
Using it’s IO and interface Work as web server

Hardware introduction
CPU spec What’s on beaglebone: Interfaces Software came with the board and others SW has been developped on beaglebone Make a original SD card PC environment set up Fist program on beagle How beaglebone IO is organized Pins muxing Mmap and Files Using Script languages Using Python on beaglebone. Python libraries on beaglebone Enviroment set up Install PyBBIO Edit through WinSCP digital pins Read ADC Using UART port PWM Web server Reference

A. Hardware introduction
Main feature on the CPU itself: The CPU on beaglebone is a truly powerful 720Mhz processor based on the ARM cortex-A8 Strong graphic support with SGX530 Graphics Engine support OPENGL ES 2.0 Integrated LCD controller Real-Time Clock (RTC) Up to Two USB 2.0 High-Speed OTG Ports with Integrated PHY 10/100/1000 Ethernet Switch Supporting Up to Two Ports Two Controller Area Network Ports (CAN) Six UARTs, Two McASPs, Two McSPI, and Three I2C Ports Up to Three Enhanced High-Resolution PWM Modules (eHRPWM) Up to Four Banks of General-Purpose IO (GPIO), 32 GPIOs per Bank (Multiplexed with Other Functional Pins) Crypto Hardware Accelerators (AES, SHA, PKA, RNG)

All IO are 3.3V except ADC is 1.8V
On beaglebone: Peripherial chips are added to make the board more handy to use. 256MB 400MHz TPS65217 power management IC USB hub Ethernet phy Micro SD slot Four Green LEDs that can be controlled via the SW by setting GPIO ports 2 46 pins expansions header (2.54): LCD GPMC bus(memory controller) MMC1 SPI x2 IIC x2 UART x4 ADC(1.8V max) GPIO x 66 CAN Bus x2 Timer output x4 PWM x 8 All IO are 3.3V except ADC is 1.8V

Summary Beaglebone is powerful for even android 4.0 system.
Beaglebone have necessary interface for embedded applications, covering most interfaces of common MCU. 3.3V interface make it easy to connect with most sensors. Full Ethernet capability make your system on line. USB host provides wider interfaces( mouse/keyboard/USB web cam) By the power of CPU, visual analysis is easy on beaglebone. USB debug interface: no need for special tool. If powered by USB only, cpu runs at 500Mhz

B. Software came with the board and some others
Beaglebone is an open sourced hardware, widly supported by several open source organization, serverail OS is ported on beaglebone. On the micro SD card comes with beaglebone, there is a Angstrom distribition linux. Angstrom linux distribution is specilized for embedded device, beaglebone releated release: TI also support an linux on beaglebone: Sitara Linux Software ( TI also support Android on it’s A8 process, including beaglebone. Currently upto Rowboat is an organization supports android on TI AM335x, AM35x, AM37x process, which included beaglebone, currently upto Win CE has also been ported to beaglebone.

Make a original micro SD card before starting:
This is normally done in ubuntu PC, like angstrom stated in the page: : But it’s also possible to work this out in windows: Prepare a micro SD or SD card reader, and install the driver correctly under windows.(Please choose a reliable card reader, some cheap card reader can cause error while writing to micro SD card) Prepare a micro SD card at least 4GB, we recommand Sandisk class 4 or class 6. (same reason as selecting SD card, and class 10 won’t be better than class 4 or 6) Since files are mostly zipped, 7-zip is recommanded. Download Win32 DiskImager (also known as the win32-image-writer) If you are using an old SD card, you will need tool to erase the SD card, “HP Formatting tool” is recommanded and can be down loaded from these loations: HP Format Tool Ver 2.18 HP Format Tool Ver 2.18 HP Format Tool Ver 2.18 HP Format Tool Ver 2.0.6 Down load the image of original one:From 12/18/2012 onward BeagleBone boards revision A6A are shipped with release, can be found here:

Unzip the compressed image file with 7-zip.
Run the HP formatter tool and format the SD card for FAT or FAT32 in order to remove partition from the card.(in windows 7 run this in adminstrator mode) After formated the SD card, close the formatter tools and start the Win32DiskImager. Select the decompressed image file and correct SD card location. MAKE SURE YOU SELECT THE CORRECT LOCATION OF THE SD CARD. Click on 'Write'. After the image writing is done, eject the SD card, now we can put the card into beaglebone to see if every thing works.

Summary Beaglebone cames with Angustrom linux, which was made for embedded system. You may also run Ubuntu,Android or WIN CE. Amgustrom release including lot of tools such as GCC compliers, Vim editor and some other tools we used in a common linux system. Opkg is used to manage the update and upgrade tools. It also comes with support to script languages, such as Python and bone script, Java script. Cloud9 IDE is also installed as a online programming tool.

C. PC enviroment set up The enviroment on PC for developing beaglebone is not necessary to be Linux(Ubuntu..etc), Mac and windows are also good for developping applications on beaglebone. Here after we will use Windows as example. 2 programs is recommand to be installed: A terminal, since windows has no longer hyper terminal with it, we recommand using PuTTY, it’s free and open sourced, easy to use. Can be down load here: it’s a exe file, no need to run installation, just click on it to run. File transfer tool: WinSCP, This is a graphic interface file transfer client(yes, there is a server on beaglebone) for windows support various protocols through ethernet. Can be down load here: Unless you wish to make a custom linux on beaglebone, other wise, above tools is enough for developping applications on beaglebone. USB connection and ethernet connection will be used in following pages. So you will need a router to connect beaglebone and PC.

Summary There are several ways of programming on beaglebone, you can use the on board IDE cloud 9. Using Vi or Vim editors and use gcc complier to comple and run program directly on beaglebone. In this case, you only need a terminal to login beaglebone’s angstrom linux to do above things. How ever, windows interface will be easier for us to work, WinSCP will take care of transfering file between PC and beaglebone, you can also install a prefered editor as you prefered.

Fist program on beagle Connecting beaglebone on USB make sure the micro SD card is correctly inserted. Use the provided USB cable to plug BeagleBone into your computer. This will both power the board and provide a development interface. BeagleBone will boot Linux from the provided microSD card and operates as a flash drive. This provides you with a local copy of the documentation and drivers. 2. You'll see the PWR LED lit steadily. Within 10 seconds, you should see the USR0 LED blinking in a heartbeat pattern. During accesses to the SD card, you should see the USR1 LED turning on. 3. From version A5 and later version, there is no need to install extra USB driver. The FTDI USB driver should be already included in windows. In case your does not have it, you can down load it here:

4. Windows will install the drivers, it will show up 2 USB devices, one is a flash drive, one as VCP(virtual com port) which can be seen under device manager. Note the comport Nr, we will need it later. If you don’t see the drive, check the LED status, SD card,USB cable, and press reset button.(small black one next to ethernet connector.)

5. Open the drive appears as “BeagleBone Getting Started
5. Open the drive appears as “BeagleBone Getting Started. in the Doc/hardware folder, there are reference manual, schemtic, pcb files, BOM..etc. reference manual is quite helpful, you can make a copy on your PC. In the Drivers are the beaglebone drivers for different system.

6. Open the README.htm with browser(beaglebone web recommand something else than IE), you will see a page contains most useful info, links.

7. Open your PuTTY, select “Serial” in the connection type
7. Open your PuTTY, select “Serial” in the connection type. Then typing the COM number your beaglebone appear in device management. Set speed to You can save the session, same beaglebone on same PC normally has the same COM number. Then hit the Open.

8. When PuTTY started, you may have black terminal, simply hit “Enter”, the login screen will appear. Type “root”, press “enter”(no password), wait a second, you are now login as root. Knowing some simple linux commands is usful: “ls” will show folders “cd” change dir “cd ..” upper dir “clear” you know it

From here you can operate your beaglebone as a linux PC, for example, type in “Vim” and press “Enter”, you can get into the editor. You will find it’s not that friendy to use, unless you have been trainned for this kind of command type editor. We are going to take another way. Connecting beaglebone through ethernet.

Connecting Beaglebone to router
Connect beaglebone to router which has internet access.(without internet access will not hurt at this moment.) Make sure the router has DHCP service and giving IP to beaglebone.

There are 2 ways to know the IP of beaglebone.
Logging into your router and check the DHCP table, and find the IP of beaglebone. Use PuTTY to login beaglebone through USB, type “ifconfig” and press enter. You will see the eth0 got an IP from your router.

Open your broswer, typing the address of your beaglebone, 192. 168. 1
Open your broswer, typing the address of your beaglebone, in the example, it will lead to a 20 slide Beagelboard 101 presentation. Which can be viewed by pressing page up and page down.

The beagle101 along may not be clear for beginning beaglebone, but there are some very useful pages such as expansion header state. So it’s recommanded to go through the 101 for a quick look

Cloud9 IDE In the broswer, open port 3000 with your beaglebone address, in our example :3000 Could 9 is running on beaglebone, and doing better by adding more examples and helps. It supports bonescrpt and node.js. This script IDE largely simplified programming on a linux beaglebone. We will experience with blinking a LED.

Click on the blinkled.js and the code will display on the right.
If you have been playing with Arduino, you will find the codes are so similar. This code will blink the user LED3 and pin P8_3 In page 10 of beagle 101, there is a note on how to connect a LED on P8_1 Press the “debug” on the top, wait a while, you will see the led besdie the reset button start to blink. Press “STOP” can stop the program.

Summary: After seeing this demo, you image how easy to program a 720Mhz ARM? Even simpler than a MCU? Well. That’s the target, bone script is not yet there to fill up all your imagnations. But you can see there is digital input, digital output, analog input and even a server examples. The idea of TI is to make beaglebone programming as simple as Arduino. In real world of embedded linux, blink a led is some how more complicate than defind pin, set pin mode and write pin high or low. We will explan on this later. But the potential of runnung script on embedded system will largely decrease the difficulty of writing a application program on embedded linux. We will see more with python. You will find out programming a 720Mhz beaglebone is not that difficult.

How beaglebone IO is organized
We have seen the simplicity of bonscript to blink the LED. But accessing a GPIO in a embedded linux system can be relatively complicate. Pin muxing refereing to Beaglebone System Reference manual 6.13(page 54), here it explains on those pins on header P8, you can see some pins are marked as timer, some are UART and some are GPIOs. These are the dafult setting on the Angustrom linux. Saying default means there are some other options. Yes, like some MCUs, a pin can have various functions depends on how you set up the usage in specific registers. Here with the angustrom linux on beaglebone, there are 8 possbilities(not every pin has 8 modes), called pin muxing. Unlike the MCU, the pin muxing here is SW related, not decided by the hardware. So, different linux could have different pin muxing. The developers of the Angstrom Linux image on the SD card selected their defaults to be the most commonly used ones by hobbyists, providing a good out-of-the-box experience. It’s possible to change the mux setting, since it’s control by linux, you may find them in the U-Boot configuration and some kernel modules, which is a very complicated job. fortunately it can be done another way with today’s linux.

Pin muxing table are table 9 and 10 for P8 and table 12 and 13 for P9 in the beaglebone reference manual

Mmap and files The Mmap stands for memory mapping, which is a technic used by linux, it makes a mapping of entire physcial memory as files under /dev/mem The BeagleBone is built around the TI AM3359 ARM Cortex-A8 microprocessor, and breaks out many of its I/O pins to two 2×23 pin female headers, including 4 UART ports, 7 ADC inputs, 4 PWM outputs, a whole bunch of GPIO pins and more. The use of these peripherals is very well documented in the AM335x Technical Reference Manual. The use of each module is done through reading and writing to different 16- and 32-bit memory registers, whose addresses are given in the manual. A Unix mmap can be used to create a memory map of the /dev/mem file, which allows read and write access to it through byte addressing. This way the module registers may be accessed by their addresses in section 2.1 of the AM335x reference manual. The most basic module to use is the GPIO module. Other modules get more complicated, but they are all very well documented in the Technical Reference Manual. The biggest difference is that many of the other modules have clocks which must be enabled before they can be used. This is done using the clock module registers, and is described in detail in chapter 8. Config of pins can be done through writing a file, changing a pin status or getting data from pins can also be done through reading specific file.

Knowing the principal, let’s take a look on how bonescript handle these blinking LEDs. Maybe you are not familiar with linux file commands, it doesn’t matter, here we wish you know the basic. Go back to the cloud9 and open the file in bonescript/node_modules/index.js

This table contains 3 important pieces of information:
the label that bonescript uses to identify the pins (P8_1, P8_2, etc) the GPIO pin number (P8_3 is gpio1+6, or 38) the mux label (P8_3 is gpmc_ad6) The GPIO pin number tells you the directory name you will use to read from or write to the pin. The mux label tells you the filename you will use to read or write the mux setting. Also open the file index.js, where the libraries of bonescript are: At the line 145(this could be different in different version, with the angustrom of beaglebone A6A version it’s lin 145, you may reach by seraching pinMode), here pinMode function take care of pinmuxing, line 150 and 151 shows you the files this function is writing to or reading from: var muxFile = '/sys/kernel/debug/omap_mux/' + pin.mux; var gpioFile = '/sys/class/gpio/gpio' + pin.gpio + '/value'; Line 179 you see it wirte a 0x07 to the file of pin mux: pinData |= (mux & 0x07); try { var fd = fs.openSync(muxFile, 'w'); fs.writeSync(fd, pinData.toString(16), null); }

Some where lower in the line 236 you can find the digitalWrite, which bonescript used to write GPIO:
digitalWrite = exports.digitalWrite = function(pin, value, callback) { var gpioFile = '/sys/class/gpio/gpio' + pin.gpio + '/value'; if(pin.led) { gpioFile = '/sys/class/leds/beaglebone::' + pin.led + '/brightness'; } if(callback) { fs.writeFile(gpioFile, '' + value, null, callback); } else { fs.writeFileSync(gpioFile, '' + value, null); return(true); Notice that the user led is a seperated file, as we explained, pins are SW related and can be arranged.

You can see it’s actually writing a value in to the gpioFile, but which one? The code to set that “path” property also in index.js, just below where the pin mux setting was done lin 207. The first thing it does is try to write to a file named “export”, specifically , “/sys/class/gpio/export”. The value written is the GPIO pin number, which you’ll recall was specified in the table earlier in index.js. For Port 8 Pin 3, it was defined as gpio1+6, or 38. The export file is a funky weird file: when you write a pin number to it, it (well, the kernel process which monitors that file) creates a directory and a bunch of files that provide interfaces for accessing the pin. The directory is created at/sys/class/gpio/export/gpioNN. In the case of Port 8 Pin 3, that’s/sys/class/gpio/export/gpio38. For the purpose of using a GPIO pin, the two most important files in the gpioNN directory are named direction and value.

The direction file determines whether the pin is going to be used for reading or writing. As mentioned earlier, you can’t use a pin for reading without setting flipping a bit in the mux mode setting, so our only choice at this point is output. The bonescript code writes the value “out” to the direction file (i.e. to /sys/class/gpio/export/gpio38/direction). The code then saves the path to the value file (i.e. /sys/class/gpio/export/gpio38/) in the pin’s path property. This is what this line does: fs.writeFile(gpioFile, '' + value, null, callback); It writes a 1 to the value file (i.e. /sys/class/gpio/export/gpio38/value) to set the pin high (and the turn the LED on) and a 0 to set it low (and the LED off). Beside these, bonescript also handle errors. That is what we saw below the catch(ex)

Summary We have saw the basic structure of beaglebone’s IO, and how it’s operated under linux using the technic of memory mapping. To make a interface function as we used to use in MCU, it required more understanding on how linux is operating, which still make the process relatively complicate. Fortunately these days script languages developped at speed of rocket. Using script language can largely reduce the effort, and leave developper to focus on their creation.

Using Script language Of course you can use C or C++ for programming an embedded linux, it has been done before, but required lots of works. We have demostrate how to make a pin works as GPIO without using script. And you also saw at beginning how easy it was to do the samething in bonescript. the words “script language” is something very difficult to translate into chinese, here is a descript on it: “ A high-level programming language that is interpreted by another program at runtime rather than compiled by the computer's processor as other programming languages (such as C and C++) are.” Yes, script language is running on a runtime. Program can run faster if written in C or C++, but the development and progress will take much more time than script language. Another advantage of using script language is that most of script languages have lots of libraries or functions shared between users. Which preventing from doing repeated work. And in most of case, with certain conditions, script language provide cross platform ability. For example Python program can work on windows, Mac OS, linux system even android. But hardware dependance still exists, for example, using uart on windows will have different configuration than using it on beaglebone. The angustrom linux on beaglebone has already Python 2.7 on it, and there are good libraries for using beaglebone’s IO. Here after we will start some real hands on with python on beaglebone.

Summary Script language has several advantages: Faster programming
Functions and library sharing Possibility of crossing plat form Easy to use for web application

Using Python on beaglebone
Before going depper on Python,let’s start with some partice on terminal, get your beaglebone linked with PC through USB and log in to beaglebone with PuTTY: Type in after # python –V and hit enter, it will reply Python , which is the version of python. There is Python 3.x already, but 2.7 and 3.x are some how different on some functions.

Key in python and hit enter, you will see a prompt as “>>>”, this is the python prompt. Under this prompt we can execute python command. Following picture shows a simple math. It seems like the old basic, but script language can do much more then is. Type in quit() will stop python. You can also use editor to make a file with extension “.py” and execute it with python xxx.py

It’s recommand to get a book for much better python
It’s recommand to get a book for much better python. It’s not easy to find books talk about python in chinese, here in Taiwan. Here we list 2 translation publish, for your reference: Head First Python(深入淺出 Python) O’REILLY 基峯資訊 Programming in Python (精通 Python)基峯資訊 Although it’s good to have a book on hand, but google is also a very handy tool when learning script language. There are plenty tutorial on net, if you can’t an answer on net, it would be also hard to find a good answer in books. Remember, these days, programming most open source stuff is not about only getting reference from others, participation on discussion and share your works with others are also important. After all , this is why we can progress together and faster. Python has also a systematic way to share codes between users, PyPI. We may not be skilled enough to create a useful library now, but please bear in mind, sharing is an important factor in progressing.

Python libraries on beaglebone
Most of script languages on beaglebone use the memory mapping (mmap) in linux system. There are serveral projects: Bonescrpt using javascript(node.js) PerlBone using Perl Rbone using Ruby Hwio usig Golang beagleboneIO and beaglebone-CLIB using C pyBBIO, mrBBIO and beaglelib using python Some others… All these are open sourced projects, I choose pyBBIO for my python experience on beaglebone, since the documentations are pretty clear, examples are not complicate and easy to use. Owner is intend to make the programming of beaglebone as similar as a MCU programming(arduino precisly). And most important, Owenr (Alexander Hiam ) keep on updating the library. This will make the library getting strong and complete. The library cover today from GPIO to web server, although SPI and IIC is still on the way, but you can already make amazing things with your imagination.

Enviroment set up we are going to do this programming in windows, the hardware connection is as following. Windows PC

you should have now PuTTY installed on your PC, we now need a file transfer tool which we have introduced previously WinSCP, download and install it. This tool is open source and have multi language version. For traditional chinese: remember how to get beaglebone IP address using PuTTY to log in as root? After log in, use ifconfig. Note down the eth0 IP adress( in this example)

Open your WinSCP type in the IP address of your beaglebone, user is root, leave the password blank. For the first connection, windows will pop up an warning, reply yes to approve the connection.

winSCP will locate the server on beaglebone, and log in as root
winSCP will locate the server on beaglebone, and log in as root. When password window pop up, leave the pass word blank and press yes. The default pass word is blank, if you wish you can add some other users and log in as other users with password. Which is as same as linux, using command as # useradd user1 # passwd user1 Then system will ask you to input 2 times of password. You can also add password to current root. #passwd And to input 2 times of password

Then you will see the WinSCP window as below:
on the right is the file system on beaglebone, left is the one of your PC. We will constantly use PuTTY and WinSCP these 2 windows.

Once setup, the last thing is to make sure that your beaglebone has access to internet.
To make sure it, you can ping a website. Google.com is what I used to use. Using PuTTY and type in ping google.com Then beaglebone is keeping pinging google.com, you can use Ctrl-C to stop it.

WinSCP has a built in editor, it also allow you to use you selection of editor. I’m using a GNU editor Emacs ( To add editor in to WinSCP, first install the editor of your choise on your PC. And find out where is it’s exe program. In WinSCP, under option/preference windows, select editors on the left side. Select add. Then select external editor and give the path of the exe file of the editor. You may also set the editor with releation to extension file name.

Install pyBBIO Make sure your beaglebone is up and connected to internet as previous descript. Log in as root through PuTTY. pyBBIO is a library of python on beaglebone, it use the technic of memory mapping, it also use other libraries of python, such as python-distutils(distribution utilty for update), python-mmap and python-pyserial, so the 1st step is to install these parts: Type in following command after #: # opkg update && opkg install python-distutils python-mmap python-pyserial It will start to down load from internet and install it, at the end you should see it’s configuring and back to prompt #

Then we will get the code from net:
# cd ~ # git clone git://github.com/alexanderhiam/PyBBIO.git The whole file system will be down loaded(cloned) to your beaglebone. You can use windows copy and past on PuTTY, copy the command from other windows, move to PuTTY, right click, the command is already on, then press enter.

After it’s done, type in # ls which is a list command, you will see there is a PyBBIO floder. Now we are going to install it: Change to PyBBIO dir: # cd PyBBIO The ls (ls), you will see a setup.py, .py is the extension file name of python file. Type in the following, this is normally how python program installed. # python setup.py install It should be correctly install as following pic

Let’s use one of the examples to see if the installation is correct.
Change to examples floder: # cd examples If you do #ls, you will see all the example of this pyBBIO version 0.5 As usual, we start with blink LED, command as following: # python blink.py Check the user led USR2 abd USR3, it will blink. And there is no prompt, now, to stop the blink program, use CTRL-C And # prompt should be back. Here is your first python program on beaglebone.

PyBBIO is a constantly updated library, the code is put on git,
So we can easy use git for update PyBBIO with few lines of command: # cd ~/PyBBIO # git pull # python setup.py install

Current pin configuration on beaglebone under PyBBIO

Editor through WinSCP Let’s check out how this blink.py looks like in pyBBIO, start your WinSCP, it should now have an additional folder “PyBBIO”

Click on the folder as operating in windows, go to: /PyBBIO/examples, and double click on blink.py, it would pop out the editor and open the file like this. (I have modified the editor option to use emacs.)

As you can see, the program is composed in 4 parts
As you can see, the program is composed in 4 parts. The target of PyBBIO library is to make a python library like a Java IDE “Arduino”, so it would have a very similar format and work on to get similar usage on most functions. Taking blink.py as example: 1st part: importing library or set up some constants… (# will remark the rest of the line) # Import PyBBIO library: from bbio import * 2nd part: define a setup() , the setup() is basically what you run once when the program started, so most pin define, or interface initial is here. (the function in python has no {}, it use colone nr to note this. So make sure you do the right indent as a good programmer should do. def setup(): # Set the two LEDs as outputs: pinMode(USR2, OUTPUT) pinMode(USR3, OUTPUT) # Start one high and one low: digitalWrite(USR2, HIGH) digitalWrite(USR3, LOW)

3rd part: the loop, where you put what need to done repeatedly.
# Create a main function: def loop(): # Toggle the two LEDs and sleep a few seconds: toggle(USR2) toggle(USR3) delay(500) 4th part: tell python to start with setup once and repeat loop # Start the loop: run(setup, loop) The program looks relatively simple, but as we have explained, there are a lot of open file read/write and close files and error management. But when accessing digital pin, PyBBIO use register access for read and write the pins. If you modify or write a file, and wish to save it through winSCP, when you press save for the first time, it will pop out a window asking for password, this window has to be answered, otherwise nothing will be saved.

Digital pins We have saw how to use digital pin to control LED, it pretty straight in PyBBIO, first, you define the pinMode, which include pin nr and direction. The simply use digitalWrite to set HIGH or LOW on the pin to control LED. With similar way, we can also read status of a pin, to be used as button in put. Still, with WinSCP, in PyBBIO/examples, you can find digitalRead.py double click to open it.

You see the program is pretty much the same as blink
You see the program is pretty much the same as blink.py in the loop you can find the use of digitalRead(GPIO1_6) to read the state and write to USR3 state = digitalRead(GPIO1_6) digitalWrite(USR3, state) OK, it seems pretty straight, but some how strange if you get used to use MCU. The state is a variable, but it was not declare, not in the loop nor in the setup nor else where. In Python, declare is not necessary, you can grape a variable and use it, no need to worry it’s data type, as long as you follow the naming rules. In consequence, there are a lot of functions in Python to convert data into the type you want. No worry if you wish to use certain data type, this python functions works both on PC and beaglebone, so you can easily test the program on PC before put it into beaglebone.(So as a lot of array/list functions)

Reading ADC The ADC on beaglebone is targeted to be used for touch panel, so the max voltage is set at 1.8V. There are 8 input through a multiplexer, the ADC is in 12bits (0~4095) . One is used internally. So there are AIN0~AIN6 on header P9, there are is also 1.8V on Pin32 of header P9 which can be used as VDD_ADC. Pin 34 is VDD_GND. When connecting anything, it’s recommended to turn off power. Use a Variable Resistor, like shown, and connect A to VDD_ADC 1.8V, and connect B to VDD_GND, W connect to AIN0 pin 39 of header P9. Take another one connect A and B as previous ones and connect W to AIN2 pin 37 on header P9. .

Find a example called: analog_test.py, let’s take a look on it.
In this example, we have set 2 constant variable for AIN0 and AIN2 only for more readilibity. # Import PyBBIO library: from bbio import * pot1 = AIN0 # pin 39 on header P9 pot2 = AIN2 # pin 37 on header P9 If we have nothing to do in the function setup(), we give it a pass command def setup(): # Nothing to do here pass In the loop(), we do 3 things: 1. Read out ADC values, it’s a 12 bits value, ranging 0~4095 # Get the ADC values: val1 = analogRead(pot1) val2 = analogRead(pot2)

2. Convert ADC value to voltage, which as a relation => 1
2. Convert ADC value to voltage, which as a relation => 1.8V in 4096 step, here we use a convenient function inVolts(), you can find the calculation in the bbio.py, try to find def inVolts. # And convert to voltages: voltage1 = inVolts(val1) voltage2 = inVolts(val2) 3.We do the print, to print out value from PuTTY terminal print " pot1 ADC value: %i - voltage: %fv" % (val1, voltage1) print " pot2 ADC value: %i - voltage: %fv\n" % (val2, voltage2)

Type in: (note: you type in few letters and press “Tab” linux will try to fill for you)
#python analog_test.py Terminal will out put as following, it print out ADC value and voltage in float! CTRL-C can interrupt the program.

In real world, you will need to filter your ADC value, since the reading can oscillate some how. And the ADC here is only 1.8V, it can be incluenced by other noise easly than a 5V ADC. There are several ways of filtering ADC value, some are using averaging(get certain amout of reading and do averge), some prefer to introduce a digital low pass filter to filterout certain frequency. Hardware low pass filter is also a good choise. Some simply right shift the reading of ADC to reduce the sensitivity.

Using UART port There are totally 6 UART on AM3359, one is used to connect to USB for our USB ternimal access. The other 5 can be found on the 2 headers. In PyBBIO the initial make Serial1, Serial2, Serial4 and Serial5 ready to be used. PyBBIO library make the uarts to be used as simple as possible, so there is no support on flow control such as CTS/RTS. Detail of usage of UART can be found here: The BeagleBone's UART modules use 3.3v logic levels; applying voltages greater than 3.3v to the UART pins can cause permanent damage! TX/RX is normally pulled high, so it’s easy to know the voltage of the signal line using meter. Pin location of UARTs: Header P9: Serial1 TX - P9.24 Serial1 RX - P9.26 Serial2 TX - P9.21 Serial2 RX - P9.22 Serial4 TX - P9.13 Serial4 RX - P9.11 Header P8: Serial5 TX - P8.37 Serial5 RX - P8.38

Let’s take a look on the example:serial_echo
Let’s take a look on the example:serial_echo.py to see how to use the library:

In the setup we start the serial port 2 with command Serial2
In the setup we start the serial port 2 with command Serial2.begin(), This command is included in bbio.py, it does pin muxing, and config the baud rate, port nr, timeout..etc. In PyBBIO, we use in fact the pyserial library of python, simply make it suit for beaglebone and simplify into few useful commands. def setup(): # Start Serial2 at 9600 baud: Serial2.begin(9600) In the loop, you see first we check if any thing received in UART buffer with the command Serial2.available() , the set up a empty array called data. In python data type in array can be mixed. if (Serial2.available()): # There's incoming data data = ''

We can use Serial2. read() to read out all the bytes in the buffer
We can use Serial2.read() to read out all the bytes in the buffer. The 5 us delay is not absolute necessary, but it would be nice to add for operation stability. data += Serial2.read() operate array just like the number in C, which means the old array appends a new byte into it. When there is no more byte in the buffer, we print it out from terminal and use Serial2.write(data) to send data out through serial2. while(Serial2.available()): # If multiple characters are being sent we want to catch # them all, so add received byte to our data string and # delay a little to give the next byte time to arrive: data += Serial2.read() delay(5) # Print what was sent: print "Data received:\n '%s'" % data # And write it back to the serial port: Serial2.write(data)

In previous example, we saw few very simple usage of serial, we init the uart port with Serial2.begin(9600), and use Serial2.available() to check if there is any thing arrived. Serial2.read() to read out 1 byte at time. And Serial2.write() can be used to send a array of bytes. There are also some functions for Serial, such as: Serialx.peek(): return the next byte in the buffer, but does not remove the byte from buffer. Serial.flush(): take out the bytes in the buffer. There are 3 ways to put data out through uart, if you are sending an byte array, write() is the good one to use. Writes given data to serial port. If data is list or string each element/character is sent sequentially. If data is float it is converted to an int, if data is int it is sent as a single byte (least significant if data > 1 byte). Returns the number of bytes written.

Serialx.prints() is easy to use when you wish to select the data formatting.
Prints string of given data to the serial port. Returns the numberof bytes written. The optional 'base' argument is used to format the data. Examples: Serialx.prints(78, BIN) gives " " Serialx.prints(78, OCT) gives "116" Serialx.prints(78, DEC) gives "78" Serialx.prints(78, HEX) gives "4E" Serialx.prints ( , 0) gives "1" Serialx.prints( , 2) gives "1.23" Serialx.prints( , 4) gives "1.2346“ Serialx.println() given data to the serial port. Returns the number of bytes written. The optional 'base' argument is used to format the data as previous one. To test uart, we will need another device on uart, such as a FTDI USB to Uart board, which you can connect to PC and open this uart with PuTTY. But make sure the one you have is 3.3V. And connect TX of FTDI to RX of beaglebone, RX of FTDI to TX of beaglebone. Or you can try to write a program usig 2 uart on beaglebone.

PWM Pulse-width modulation (PWM) is a commonly used technique for controlling power to inertial electrical devices, made practical by modern electronic power switches. Dimming LED is a very common usage, using H-bridge and 2 pwms, it’s easy to drive a DC motor.With some modification it can also control RC servos. The BeagleBone has 8 PWM outputs. These come from three EHRPWM modules (two output each) and two ECAP modules with one output each. The “EHR” part means Enhanced High Resolution(16 bit). ECAP= Enhanced Capture(32 bit). Today, PyBBIO supports 2 EHRPWM(1 and 2) module which allow us to use 4 3.3V 16-bit pwm out puts. PWM pins Header P8: P PWM2B P PWM2A Header P9: P PWM1A P PWM1B There are a variety of PWM settings exposed through the file system, as described in the PWM Driver’s Guide, but the two key ones are period_freq, which is the frequency in Hz, and duty_percent, the duty cycle setting.

PWM clock is init by linux kernel, PyBBIO using pwmWrite() or (analogWrite() same as pwmWrite())command to set resolution and duty cycle. pwmWrite(pwm_pin, value, resolution=RES_8BIT) Sets the duty cycle of the given PWM output using the given resolution. The resolution defaults to 8 bits, so if no resolution is given the values in the range Resolution may be one of the defined RES_8BIT: then the value need to be 0-255 RES_16BIT: the values is PERCENT: to set the duty cycle in percent, or any integer greater than 0. 'value' should be an integer. pwmFrequency(pwm_pin, freq_hz) Sets the frequency in Hertz of the given PWM pin's module. Each module can only run at a single frequency, so PWM1A and PWM1B will always be running at the same frequency, and likewise for PWM2A and PWM2B. If not called, the frequency of each module will default to 100kHz. A nice example is fade.py it dim a LED with + on PWM1A(P9.14). Please add a resistor of 100~300Ohm to limit current.

Let’s see the demo of fade.py
Prepare a LED with a 100~200Ohm resistor connect to LED serially. Longer leg of LED is positive lead, you can add the resistor to positive lead or negative lead. Connect the positive lead of LED to P9 pin14, which is PWM1A, and connect the negative lead to P9 pin2(or Pin1) which is GND In your terminal type in python fade.py , you will see the LED light up and fade away repeatly.

Servo control: RC servo is controlled mostly by a PWM signal at 50Hz, and change it’s angle depends on the signal high duration, mostly between 0.9ms to 2.2ms. But different servo could have different range for the signal high duration. PyBBIO also include a servo library to control servo motors by using PWM. Which means there are 4 pins, PWM1A, PWM1B, PWM2A or PWM2B, and PWM1A and 1B must run at same frequency. You can see an easy example in Servo_sweep.py, before set up, we import Servo: from Servo import * Then, it create a servo1, using mostly the default setting. # Create an instance of the Servo object: servo1 = Servo(PWM1A) # We could have left out the PWM pin here and used # Servo.attach(PWM1A) in setup() instead. And run servo1.write(angle) If you look in to the code of servo library, it use 50Hz as deafult frequency, 0.5ms as min position, 2.4 as max position. And map to 180 degree. Your servo may not fit this spec, you can fine tune the max_ms and min_ms to get it work with your servo.

Testing the servo library need a RC servo and some attention
Testing the servo library need a RC servo and some attention. General RC servo take 5 V power, and 5V signal. The signal level of beaglebone’s PWM is 3.3V, which is just enough for 5V logic to read as a high(5*0.6=3.0). On beaglebone P9, pin 5 and pin 6 are VDD_5V, which is connected to the 5V power jack on board. We can connect servo power line to these 2 pins, but these servos some how need big current to make it works, so you will need to plug in a 5V adapter with enough current to make sure the servo works. Nornal or small size servo without load, 5V 2A should be fine. The brown line of servo is GND connected to P9pin2, red one is 5V connected to P9pin6, orange one is singal connected to P9pin14. In terminal Type in: python Servo_sweep.py You will see the servo sweeping around.

Web service We have see most MCU-like function on PyBBIO, PyBBIO also contain a simple interface to make your own web service. So that you can access your beaglebone with a browser on a device in the same network. Under Python, create a web service is not very difficult, Python comes with a web server in http.server, SimpleHTTPserver library. These webserver are mostly HTTP/1.1-compliant, WSGI (web server gateway interface) or CGI (common gateway interface). Once the web server is built, we will need UI on your web, it should be done in HTML, but we are not going into that part. Once you get familiar with web service you will be able to make fancy web service with some other web service frame work on beaglebone. such as Flask, Cherry Py and some other template engine. There are plenty of them. Let’s start with simple one in PyBBIO and see how we can access our beaglebone from an other internet device and control things connected to beaglebone IO.

BBIOServer library BBIOServer create webservice and provide RequestHandler to handle BBIO function calls. And the UI templete is quite simple but clear, it has a title on the top, a total pages menu on the left. Right side is where you put your contains. For the contain, there are 4 major functions to be used: you can add text to tell message, add a button to do something. Or add a monitor to show something. And of course you can also add text input.

Structure of BBIOServer in program:
BBIOServer is acturally a parallel program running on beaglebone once it’s called. So it only need to be call once, So it would be placed in setup() not loop(). We will go through the BBIOServertest.py example, but let’s see first what has to be done. 1st thing to do is to import the library, since BBIOServer is written seperately, so we need to import it. Create an instance of BBIOServer class. Create pages, and adding what we wish to add in the page. Start the server. Let’s see how these are done in the BBIOServer_test.py: you can see we do the 1st and the 2nd thing by these lines: # First we must import PyBBIO: from bbio import * # Then we can import BBIOServer: from BBIOServer import * # Now we create a server instance: server = BBIOServer()

server = BBIOServer() create an instance of BBIOServer
BBIOServer() has some options: BBIOServer(port=8000, verbose=False, blocking=True) The port argument may be used to run the server on a port other than the default of If verbose = True a log of every request will be printed. If blocking = False the server will run in non-blocking mode, meaning the main loop() routine will be executed as normal while the server runs in the background. blocking=True will not run loop(). You can of course selecting some other port Nr, but some port Nr are used for some services, and you may need to use these port for other application on your beaglebone, such port 22 is what we used for shell in winSCP. Some more interesting port Nr information can be found here:

1st Page: Then in the file you can see we created 1st page call home with title "PyBBIO Test"and added a text on that page # Create our first page with the title 'PyBBIO Test’ home = Page("PyBBIO Test") # Add some text to the page: home.add_text("This is a test of the BBIOServer library for PyBBIO."+\ " Follow the links at the left to test the different pages.")

2nd page: A 2nd page is created, page name is text with title ”Text Input”. As you can see the name of the page will be serve to create add_text or add something else. And the text in the Page() will be show as title on top of the page and page list on the left. # Create a new page to test the text input: text = Page("Text Input") text.add_text("Press submit to send the text in entry box:") # Create the text entry box on a new line; button will say 'Submit', # and when submitted the text in the box will be sent to print_entry(): text.add_entry(lambda text: print_entry(text), "Submit", newline=True) .add_text seems pretty straight, let take a look of .add_entry in bbioserver library: def add_entry(self, function, submit_label, newline=False): Add a text entry box and a submit button with the given label to the current position in the page. When submitted, the given function will be called, passing it the text currently in the entry. The function must take take a value, e.g.: 'lambda s: print s'. If newline=True the text will be put on a new line, otherwise it will be stacked on the current line. So lambda text:print_entry(text) is the function. What lambda does is putting the text(what you type in the entry) in to the function print_enrty() . Lambda is a function of python, you can google for more detail.

Here is how the page 2 looks like:

3rd page is created with name=io and title is “I/O” at about line 55.
io = Page("I/O") # Make a LED control section using a heading: io.add_heading("LED Control") io.add_text("Control the on-board LEDs", newline=True) . io.add_heading("ADC Readings") Here you can see we add a heading “LED Control” and “ADC Readings”, it’s slightly different from add-text on the web.

On 3rd page, we add a button to toggle LED USR2 and USR3, and add a monitor to show the status of LEDs. In the red circuit you see a button of toggle LED and current state, is infact 2 functions in the code, and only 2 lines of code. # Add a button on a new line with the label 'Toggle USR2 LED' that will # call 'toggle(USR2)' when pressed: io.add_button(lambda: toggle(USR2), "Toggle USR2 LED", newline=True) # Add a monitor which will continually call 'pinState(USR2)' and # display the return value in the form: 'current state: [value]': io.add_monitor(lambda: pinState(USR2), "current state:")

Let’s see how it’s done to toggle the LED:
io.add_button(lambda: toggle(USR2), "Toggle USR2 LED", newline=True) add_button(function, label, newline=False) Creates a button with the given label at the current location on the page. function must be a callable object, and will be called when the button is pressed. If newline = True it will be forced to the next line, otherwise it will stack to the right of the previous object if there is room on the page. The whole explaination seems ok beside this: function lambda: toggle(USR2) seems strange. Well, lambda is a powerful tool in python to create anonymous functions (i.e. functions that are not bound to a name) at runtime. You can find toggle() in BBIO.py, but here we use it without attached to a name(anonymous functions ). What is a function attached to a name? For example, add_button() is a function in BBIOServer, and we use it as io.add_button(……). And here we wish to use the toggle() without attached to a name, so we introduce lambda as construct. To creat a function and call it at same time.

For knowing the LED curent status in line 66:
# Add a monitor which will continually call 'pinState(USR2)' and # display the return value in the form: 'current state: [value]': io.add_monitor(lambda: pinState(USR2), "current state:") Page.add_monitor(function, label, units='', newline=False) Adds a label to the current position on the page in the form: "label value units" where value is the latest return value of the callable object function which will be repeatedly called. If newline = True it will be forced to the next line, otherwise it will stack to the right of the previous object if there is room on the page. Value is being updated about every 200ms. Again, pinState() is a function of BBIO, here we use lambda to use it. As you can see, if necessary you can also add ‘units’ at the end of it, simple put the unit(like ‘degree’,’second’) in it.

Once you understand how the LED control works, the ADC reading is simply adding some add_monitor(), the only thing change is the function called through lambda. io.add_monitor(lambda: analogRead(AIN1), "AIN1 value:", newline=True) io.add_monitor(lambda: voltage(AIN1), "voltage:", units="v") At the end of setup(), we will user server.start to start the webserver with the pages we created. server.start(home, text, io) We have created the server instance in blocking mode: server = BBIOServer() So, server will keep running when we use run(setup, loop) to start the program. It will stop when we use CTRL-C. At which point it will continue on to loop(), so if we want our program to stop completely we need to use the PyBBIO stop() function. Or we leave nothing in our loop() function, we need to use the pass statement to keep Python happy.

In pratical usage, you will run the server in non-blacking mode, and do some input reading(ADC, GPIO, UART, SPI…etc), processing some calculation, and finally do some out put(GPIO/UART/PWM…etc). As you understand now, A program in PyBBIO is composed by several programs( such as web server, setup(), loop()), it’s also important to know how to pass variables from one to another. The simple way(maybe not always the good one) is to use global variable. We will come back for this. Let’s try out the webserver we just explained.

I added a VR like we explained in previous section ADC,
Red to P9pin32, VDD_ADC. Back to P9pin34, VDD_GND. White to P9pin39, AIN0. You can also hoop up a second on on AIN1,P9pin40.

Log in to your beaglebone, go to PyBBIO/examples/
Then type in: python BBIOServer_test.py Perss Enter Now, the prompt is dispeared, the server is already running. If some wrong, python will pop out the error message, then you need to check out the code.

Now, take a PC or tablet connected to the same router,start your borwser, IE is not recommanded, chrome,firefox and others are fine. Remember the how to get the IP address of your beaglebone? Here we put in it’s IP address and assign port 8000(where we start the webservice) In my example the address of beaglebone is , here is what I put: :8000 It would redirect you to the home page of our PyBBIO Test

Go to Text Input page but clicking the menu on the left.
In this page we used add_entry() to create a text input area, and call lambda text: print_entry(text) to print the text to teminal when the Submit button is pressed.

Type in some thing, press Submit, you will find what you type in the PuTTY terminal.
Now you have a templete to input data/info to your beaglebone from web, to do some thing more complicate.

Click to the I/O page, you can conrol the USR2 and USR3 LED with these 2 buttons. Truning the VR , we will see the AIN0 value changes.

The web service demo is done in 3 pages, but covered mostly basic usages. You can do your webservice with your model, view and control. There is another webservice example, which is serial_server.py It shows you how to use webservice to access UART on beaglebone. Which is very useful in the aera of automation, internet of thing. You can use the uart of beaglebone to connect to automation unit through RS485, or connect zigbee coordinator to form a IOT network. There are many good examples on internet using beaglebone for these type of application, and mostly are open source, it’s also helpful to see how others do the job. is a very good example… The only limitation is your imagination.

Additional information:
Basic function of PyBIO. these functions are written in bbio/bbio.py, we used some of them, here are some more detail. 1. GPIO: pinMode(gpio_pin, direction, pull=0) Sets the direction of the given digital pin as either INPUT or OUTPUT. The optional 'pull' argument can be used to set either a pull-up or pull-down resistor on the pin if setting it as an input: pull = -1 for a pull-down, pull = 1 for a pull-up, and the default of pull = 0 for neither. digitalWrite(gpio_pin, state) Sets the state of the given digital pin to either HIGH or LOW. The pin should already be configured as an output. toggle(gpio_pin) Sets the state of the given digital pin to the opposite of its current state. The pin should already be configured as an output. digitalRead(gpio_pin) Reads and returns the state of the given digital pin as either HIGH or LOW. The pin should already be configured as an input. pinState(digital_pin) Returns the current state of a the given digital pin if it is configured as an output, or None if it is configured as an input.

2. ADC functions: analogRead(analog_pin) Takes a reading of the given analog pin and returns the 12-bit value. inVolts(adc_value, bits=12, vRef=1.8) Converts the given ADC value to a voltage, according to the given number of bits and reference voltage, and returns it. The default values match the built-in ADC. 3. PWM functions: analogWrite(pwm_pin, value, resolution=RES_8BIT) Sets the duty cycle of the given PWM output using the given resolution. The resolution defaults to 8 bits, so if no resolution is given it acts like Arduino's analogWrite(), taking values in the range Resolution may be one of the defined RES_8BIT, RES_16BIT to take advantage of the 16-bit timer (values of ), PERCENT to set the duty cycle in percent, or any integer greater than 0. 'value' should be an integer. pwmWrite(pwm_pin, value, resolution=RES_8BIT) Exactly the same as analogWrite(); for those who don't like 'analog' in the name. pwmFrequency(pwm_pin, freq_hz) Sets the frequency in Hertz of the given PWM pin's module. Each module can only run at a single frequency, so PWM1A and PWM1B will always be running at the same frequency, and likewise for PWM2A and PWM2B. If not called, the frequency of each module will default to 100kHz.

pwmEnable(pwm_pin) Enables the given pin for output. Called automatically by analogWrite(), so shouldn't generally need to be called. pwmDisable(pwm_pin) Disables given PWM pin. Unlike calling analogWrite(pwm_pin, 0), calling this will relinquish control of the pin, allowing it to be used by another process. 3. Serial begin(baud, timeout=1) Initializes the serial port at the given baud rate. The optional timeout argument is the number of seconds to wait when reading from the RX line before giving up if no data is present. If timeout = 0 then read() will block until data is received. This method must be called before any of the below methods will work. end() Closes the serial port. This should be called prior to reinitializing at a new baud rate. available() Returns the number of bytes available in the receiving buffer. read() Returns the next byte from the receiving buffer, or -1 if the timeout set in begin() is reached before any data is present.

peek() Returns the next byte from the receive buffer without removing it, or -1 if no data is available. flush() Removes all data from both the TX and RX buffers. prints(data, base=None) The equivalent of Arduino's Serial.print(), but the print symbol is reserved in Python. Prints the given data to the TX line. If the data is a string it is printed as-is. If it is an integer then it may be formatted by passing one of the formatting constants listed below as base, where the default is DEC. If it is a float then base should an integer of the number of decimal points to be printed, where the default is 2. If data is of any other type, e.g. a list or dictionary, it is converted to a string then written. println(data, base=None) This behaves the same as prints(), but the data is followed by a carriage return (**\r**) and a new line (**\n**). write(data) If data is a number it is written as the the least significant byte of its integer value. If it is a string, list or tuple, each value is written sequentially, left-to-right, following the same rule if they are numbers. Returns the number of bytes written, or 0 if given an unsupported type.

4. Software SPI: shiftIn(data_pin, clk_pin, bit_order, n_bits=8, edge=FALLING) Receives the given number of bits from a slave device, generating the clock signal on clk_pin and reading data from data_pin, and returns as an integer. bit_order sets the endianess of the data, and should be either MSBFIRST or LSBFIRST. edge is the edge which triggers the device to write the next bit. shiftOut(data_pin, clk_pin, bit_order, data, edge=FALLING) Sends the given data to the slave, generating the clock signal on clk_pin and reading data from data_pin. bit_order sets the endianess of the data, and should be either MSBFIRST or LSBFIRST. edge is the edge which triggers the device to write the next bit. 5. time related: millis() Returns roughly the number of milliseconds passed since run() was called. micros() Returns roughly the number of microseconds passed since run() was called. delay(ms) This pauses a program for the given number of milliseconds. delayMicroseconds(us) This pauses a program for the given number of microseconds.

Other library in PyBBIO
PyBBIO provide some basic functions, Beside the BBIOServer and Servo libraries we demonstrated, there are coming up with some new ones, you may also develop some to contribute! ADS786x library ADS7866~ADS7868, ADS7886 are analog to digital converters of TI, SPI interface. This series of ADC has different voltage range(1.2~3.6~5.25V), and different resolutions(8-12 bits). DACx311 library ADC5311~DAC8311 are different resolution (8-14bits) digital to analog converter. Allow you to out put a voltage out put. MAX31855 library MAX31855 is a chip used to convert thermocouples to digital temperature information.

2 more things are helpful when you go for real design in Python:
Global variable In our program, it’s composed of setup() and loop(), it’s infact 2 different program, so if we need to pass data from one to the other, we will need to process with global variable. It’s not difficult, there is an example on it: switch.py Before setup(), we set 2 global variable with initial value. LED_STATE = 0 # 0=green LED lit, 1=red LED lit. SW_STATE = 0 # =1 when switch pressed; only change LED_STATE once per press Then when using them in loop() or some where, simple declare on the first line these are global: def main(): global LED_STATE, SW_STATE # Python requires you explicitely declare all global variables # that you want to change within a code block using the global # statement; see: #

2. multiprocessing Our beaglebone is running linux, and you are capable to run some different program at same time. You can do this in linux with job management. If you want to run different things in the same program, then Python provide a very powerful tool called multiprocessing . PyBBIO based on this, make a easier to use interface(so called wrapper). With clear explanation, it would be helpful when you need to run multiprocessing. SafeProcess

Reference: http://beagleboard.org/static/beaglebone/latest/README.htm
Design materials System Reference Manual Schematics (PDF) Schematics (Orcad) Bill of materials PCB design files PCB manufacturing files

Backup http://www.gigamegablog.com/tag/beaglebone/

Hands on Beaglebone Introduction on beaglebone

Similar presentations

Presentation on theme: "Hands on Beaglebone Introduction on beaglebone"— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Hands on Beaglebone Introduction on beaglebone

Similar presentations

Presentation on theme: "Hands on Beaglebone Introduction on beaglebone"— Presentation transcript:

Similar presentations

About project

Feedback