Last week was the 4th Week of GSoC ’13 at Beagleboard.org !
Just like the previous week, this week we were working on getting demos working for the Bacon Cape. We now have the PWM, the ADC and the shift register working.
Basically that means that you can display different colors on the RGB LED, use the slider to get analog values and use the 7 segment LED to display your favorite single digit number 🙂 !
I started out with a little clean up of the previous weeks code and then went on to tackle the 7 segment bit. It was fairly easy as prpplague had already got the shift_out in place. Some of the useful bits were found in the Danger cape demo (an Arduino shield similar to the Bacon Cape) from Sparkfun. Apart from that panto has written a neat bash script to test all the features of the Bacon.
Using that script, the next thing I tackled was the PWMs (well I had said that I’d be doing ADC and hatguy would be doing PWM in my previous post, but then later on we traded our to dos). So I added 2 new functions, one the pwm_export function to load the PWM pins from init(). The other one was the analogWrite function in wiring_analog. It was a slight headache to get all the pins right ( the port pins, the pwm_pins, the ones from gpioDescription, the Arduino pins, etc etc).
Apart from that hatguy and prpplague got the ADC working. Also, prpplague tested some of our code on the Minnowboard and it worked fine ! So that’s a good indication that our code is generic enough and will support loads of other devices in the future.
This week we will be working on clean up and testing mostly. A lot needs to be straightened out. Some demos work as is for some people while some of the mentors are having trouble getting them to work. So we will be working on getting all the documentation right. mdp and bradfa will be helping us out with this part a lot. Me and Parav are already getting a lot of feedback from all 3 mentors about the stuff that’s already up, and this week we’ll be working on getting some more and straightening out the wiki, etc
All in all, a good week 🙂
Till next time !
Last week was the 3 week at GSoC ’13.
Most of the week was spent on clean up of the existing code that I had written for the sysfs functions. Apart from that I also added the set_direction pin for GPIO.
The second major thing was adding error control to the existing functions.
After this, we started working on demos for the Bacon board. hatguy whipped up a demo for the user button on the board, whereas I am working on the 7 segment LED. Arduino has a library for 7 segment LEDs, which we will adhere to, and there are a few demo scripts for Beacon board too. This requires device tree overlays, as this 2 of the 3 pins are not muxed as per required.
This week we will be working on getting more demos for the Bacon board, hatguy has already started working on the PWM for analog write (think RGB LEDs on the Bacon). I’d be most probably working on the ADC bit once I have 7 segment in the bag
Till next time !
The past week was my second one at GSoC 13.
To be honest, as compared to the first week, this week was slow. I lost the use of laptop, for some hitherto unknown reasons. It was a Dell Vostro 1520, which I was using for almost 4 years now. I still have no clue as to what happened, but I suspect a motherboard failure here (there was no LED activity at all).
So I spent the entire weekend fretting over that.
Luckily I now have access to another machine (a better one when it comes to specs) with almost everything I will be needing. I installed Ubuntu, instead of my usual Debian, to save time in configuring. I figure I have everything that’s needed now ( git repos, tool chains, ssh keys to devices, etc etc)
Before all of these distractions, I was working on setting up the basics for the blink code. Me and Parav have divided the work amongst ourselves for the blink part. I would be taking care of all the functions that will be required for accessing /sys/ as well as stuff like delay, etc. Also, communication over ssh is something else that I am taking care of.
Parav is working on the pin_mux as well as the Makefile. The makfile part is pretty cool. The aim is to enable anyone to just download the libraries and makefile and let them write code using the arduino like functions in their own IDE ( Emacs, Vim, etc). So basically this is for folks who are not exactly newb to programming in general, but are new to Embedded Linux and the BBB.
The testing part which I mentioned in my last post was good. I found out a few minor errors I’d done in my previous code ( value to be passed to the functions should be a char instead of int, among other things). Also, I pushed it here. If anyone would like to test the code, you can just clone the repo, setup ssh keys for your BBB using the instructions in the bash file. And run it as ./send_exec generic_function.c
The code will compile, upload and execute. Right now I have enough functionality to turn on/off a usr_led, export/unexport a gpio pin and set/get its value, direction, etc.
So the next thing I will be working on is the delay function which will allow me to blink a LED. I hope to get this up and running by Wednesday (for the weekly meeting). Once we have the core functionality up, we can tackle bigger things like pwm, adc, etc.
There exists an Internet of Things meetup in my city (Pune, IN), where Arduino hackers meet to work on awesome projects.
Most of the projects that are done here using the Arduino. But we also have a few Raspberry Pi enthusiasts amongst us.
So this week I gave a small demo of the BeagleBone Black (since I got it last week) and we had a nice discussion about the features of the Black, and the differences between the Arduino, Pi and the Black. I also talked about the userspace-arduino project and how we can use the same IDE and the same code/libraries for programming on the Black.
Till next week !
17th to 23rd June was the first week of GSoC.
This week I have been working on setting up a script to compile, upload and execute code over ssh to the BBB.
Apart from that, I wrote some basic C code for reading and writing values to /sys/class/ entries
Raw code is here
I haven’t yet pushed it anywhere, because I am still trying it out on various entries in /sys/ . That will be on the agenda for this week.
This week I received all the hardware that I need to get started with for my work with the arduino-like userspace libraries at BeagleBoard.org.
I’d like to shout-out to David Anders and the guys at CircuitCo for providing us with all the hardware to get going with this *awesome* project.
The fact that we are building a truly generic set of features for Embedded Linux boards inside the Energia ide is pretty mind-blowing, if you think of it. Any board (pcDuino, RaspberryPi, cubie, etc) could modify the work that we do and make it work for them ! So the same old Arduino-like environment will have a whole new plethora of ARM linux boards.
And I also received the GSoC welcome package ! Pretty classy diary Google 🙂 !
The green board is the Bacon cape, which is a really cool way to get started with the interfaces available on the BBB. The black board is the BeagleBone Black.
Till next week !
The number of ARM Linux boards is staggering. So is the number of people who are new to them. Actually the whole maker movement is gaining a lot of traction.
Most people start out with the Arduino, because of its simplicity, price, excellent documentation on the site as well as the quantity and quality of projects that have been done using the same. So all in all, the Arduino is the newbies de facto entry point.
A lot many projects have been started to make it easier to start embedded Linux development. Ours is a similar effort.
The project proposes to build a set of Arduino-like libraries for development on the BeagleBone Black. The libraries will be available inside of the familiar Arduino IDE( to be particular in the Energia IDE) . Also, we intend to work on various communication interfaces which will allows us to upload, execute and fetch the results of the code.
Look here for more details on that http://www.elinux.org/Userpace_Arduino
The major objectives that we have in mind are:
- Get the code for GPIO, I2C, PWM, SPI, ADC and Serial to work on the BeagleBone Black, as is. For example, it means a analogRead on a compatible pin on the BBB should work just like it would on the Arduino
- Ensure multiple methods of communication between the IDE and the board
- Ensure that enough documentation is there for someone to get started. It would mean creating or making things compatible to existing wikis.
I’ll be uploading a video with our objectives in detail soon enough.
Cheers till then !
I am one of the lucky seven to work with BeagleBoard.org for this year’s edition of Google Summer of Code.
BeagleBoard.org is a volunteer organization that seeks to advance the state of open-source software on open-source hardware platforms capable of running high-level languages and operating systems (primarily Linux) in embedded environments.
BeagleBoard.org is one of the coolest and widely used prototyping platform of makers and hackers all over the world.
Google Summer of Code is a global program that offers students stipends to write code for open source projects.
I am certainly looking forward to an awesome summer this year 🙂
Project details soon !
My approach towards the project would be to complete the implementation and testing for a library and then move on to the next one. In this way, I will try to complete as many libraries as possible by the last week and then focus on packaging them.
The project will target the BeagleBone Black and BeagleBoard-xM. I think it would be convenient to work on the 2 boards in parallel, with priority to BB Black. This would allow me to complete implementation and testing of a library for both and then move on to the next library.
|Libraries||Will Require the use/study of|
In the last week, I would focus all my work on packaging all the libraries that have been implemented. I think one week will be more than enough for this task given that I will have completed documentation(in the form of examples as well as comments) and testing by then.
A pkg-config file will be created for each library and will be stored /usr/lib. The libraries will be packaged so that we can install it using something like “opkg install libarduino”.