Seemanta’s Blog

I am back from my hibernation, which almost lasted one whole year (the last post, as I recall, was made exactly a year ago on 25th April, 2010). But there are reasons for my protracted absence. I was too busy preparing for grad school and finally landed in the University of California San Diego during Fall of 2010 (September 12th, 2010 to be precise).The whole 18 month process starting right from preparing for GRE/TOEFL, selecting grad schools, talking to professors/students, applying to them and then accepting the admit and finally getting the Visa approved was the worst 18 months of my life ! But it is worth it, considering that I was able to get an admit into one of the top schools of US and devote my next 2 years in learning about embedded systems inside out!  I never felt satisfied earning my Bachelor’s degree to be frank, and this attempt going back to school is an attempt to learn all that I think I didn’t learn during my undergrad days. So three cheers to UCSD !

So far my stay at UCSD has been very good. Due to my passion for embedded systems and low power wireless, I am associated with the Synergy Lab here in the Computer Science and Engineering department. And working in this lab I also got my first publication also out. And recently submitted another one to SenSys 2011. Overall, I am pretty excited to be here!

And there is also GSoC 2011 which is something I am really looking forward to participate this summer. For GSoC, I would be working for the GNOME project, specifically for the GNOME debugger, Nemiver. My complete project proposal can be found here. The reason I chose this project is because I have previously contributed a patch to it so there is some familiarity with the code. Besides my proposal for GSoC 2011 is something which is very close to my heart because I had this idea more than a year back and would personally like to see it happen !

I also have a wonderful mentor, Dodji for GSoC, who I personally think is the best mentor I have ever encountered anywhere! I have just become a big fan how he patiently explains things to first timers about the project. I am sure I am going to have a lot of fun hacking on GNOME code this summer !

So here’s wishing to a wonderful summer!

admin Personal GSoC 2011, UCSD

It has been almost a year since I created my plugin to enqueue files into the Rhythmbox play queue from within Nautilus. I got feedback from several people across the globe regarding the plugin and the most common complaint that came across was that the plugin could not enqueue folders recursively. Also, when some files had embedded special characters, the plugin did not work as expected.

So, finally after a busy year, I sat down one evening and made the requested modifications to the plugin. Now it can handle folders recursively and also embedded special characters within file names. It is also intelligent enough to detect if a folder has zero music files and in that case the option to enqueue the folder itself would not come up. Another good  friend of mine gave a very good suggestion that the plugin should automatically detect the default player in Gnome and enqueue the files to that player. I think I shall take that up as an enhancement in the next version

So, here it is. Download and enjoy! Install instructions are same as before, which you can find in the original post. If you are already using the older version, then you just need to download this version, and replace the old one in your $HOME/.nautilus/python-extensions folder.

Last but not the least, I must thank all of you to have downloaded and tried my original plugin. But more thanks are due because of the fact that you took out time to give feedback. I know a year is late of me to have got back to you with the enhanced plugin, but things were quite hectic on my personal life as a result of which I got very little time for such activities.

admin Linux, Ubuntu Linux, Plugin, Python, Rhythmbox, Ubuntu

If there is anything that is considered a rite of passage among embedded hobbyists then it undoubtedly has to be the creation of a robot. A robot is not only challenging from the point of view of an embedded system designed to perform a particular function, but it also has mechanical and structural facets to it which makes it even more difficult.

But please do not assume the robots we hobbyists build would be even remotely smart and glamorous like R2D2 from Starwars or the three-laws-bound R. Daneel Olivaw from Asimov’s novels. In stead, our robots are from a much more humble origin; most of us are satisfied with simple line followers and object avoiders. Speaking of which, let me introduce you to my first robot, which I have christened, LFR - Line Following Robot - but you may call him Loafer in affection.

As the name says, this robot is programmed to follow a painted line on any plane surface using a sensing contraption. For LFR, I have used an ATmega32 - an ideal choice primarily because of its on chip debug interface. An endeavour as ambitious as robot building definitely warrants a good debug features.

For my sensor array, I have used two LDRs or Light Dependent Resistors and an LED to act as the light source which is used to shine the path of the robot. The light reflected from either side of the line is then measured and compared to decide which direction to turn the robot. The turning is achieved by using a differential drive i.e. a drive which turns the wheels independently of each other. An LM339 is used as a comparator chip and a ULQ2804A chip is used as the motor driver chip

The below schematic diagrams show how steering of the robot is achieved by using the LDR-LED sensor array. The diagrams show the cases when the robot moves in a straight line, turns left and turns right respectively. This is based on the amount of light reflected off the black painted line.

After the schematic diagrams, now here I present some actual pictures of LFR. Alas! I do not have any videos of this one. One issue which I found with LFR was that the entire circuitry along with its batteries was a bit too heavy for my motors to drive. So it moved rather sluggishly. This is one improvement which I have in mind for LFR 2.0 ;-). And in case you are wondering, for the line, I pasted some black insulation tape on my marble white floor.

So without further ado, here are some snaps of LFR. The first one is a labelled picture for the curious.

If you are curious,  click here to see the ATmega32 C source code for LFR. As usual, with ATmega32, the code is extremely convenient. I used the avr-gcc toolchain to compile this and my own homemade JTAG debugger to debug my code. And yes, if you have seen the code then your guess is probably right, I have used PWM to control the speed of the motors here . Oh and probably you might have also noticed the JTAG debugger interface on the top right hand corner of the main robot board.,

So that was all about LFR - my first robot. It does not follow any of the three laws of Asimov, but yes it is nice to build your own robot, for fun as well as learning!

I hope you enjoyed this post. Stay tuned for more! Until the next time, g’bye and take care! And please do not forget to comment if you like this post.

admin Embedded Hobbyist, Tech ATMega32, AVR, avr-gcc, Embedded Hobbyist, Robotics

It has been quite some time (more than year) since I created my gnuProload software to program AT89S52 microcontrollers over Linux after reverse engineering an existing software which ran only on windows. But a few months ago, I enhanced that software to enable it to program even Dallas DS5000T microcontrollers.

If you want to know how gnuProload itself came into being, please read this post first. It is quite interesting, in case you are passionate about software in general and open source in particular. It tells the story of how I refused to walk into the trap of closed source software and how I was forced to reverse engineer a piece of software which ran only on windows (prior to my reverse engineering) ;-). In case you are wondering, the name of that post is derived from the critically acclaimed movie by Stanley Kubrick, Dr. Strangelove ;-).

Ok, let’s not digress. What happened was that sometime around August, this year, I was contacted by a fellow from Brazil who visits various universities giving lectures on embedded development on Linux etc. So he wanted to present my software in one of his talks. I was flattered, naturally :-). So I went ahead and created a set of slides for him to present it in his talks. In this post, I am just providing those same slides for you to go through. I hope these bunch of slides will give you more information rather than my original post about gnuProload.

So here it is, download and enjoy! Oh and by the way, you would need OpenOffice.org to view these slides. And if you are too lazy to download it, here is a PDF copy of it ;-).

Enjoy! As usual, don’t hesitate to put in your comments. Have a nice day!

~Seemanta

admin Embedded Hobbyist, My Creations, Tech 8051, AT89S52, DS5000, Embedded Hobbyist

I have been fiddling with the Python programming language over the past few days.  And even though it has just been few weeks and I hardly have covered every aspect of the language in detail, I am already producing working code in python. In short, I am flying! Python really rocks!

So yesterday I thought it would be nice to be able to check my Gmail inbox for new incoming mails from the command line. So a little searching gave me this link.

This is a python script that does exactly what I wanted. But it runs from the command line and is interactive in that it asks for the user name and password from the user interactively. I went a step ahead and thought what if I can make this process automated and for every new mail, show up a notification. Speaking of notifications, you must be aware of the new OSD notification that is creating much buzz these days, especially in Ubuntu circles. This new notification system is designed to replace the existing notification system with a cooler UI and better usability. At least that’s what the canonical folks claim.

Anyway, I set out to create this cool notifier and in a few hours it was ready. Being a first timer to Python, it took some time as every now and then I would stop to see some documentation and then once I understood the concept, carried on hacking. Once complete, the next few minutes I spent in fine tuning the notifier, like add an image (the gmail logo of course!!).

Eureka!! It worked, Yippee !! That’s what I like most about Python. Even a complete newbie like me can create working code in such a short time! Having written the it, now I wanted to make it more user friendly. So the next day, I ended up writing a setup.py script to provide ease of installation. Believe me, writing this setup was far more difficult than the original notification script ! But because of this script, installation is super-easy. Just run the setup.py file, that’s it!

So finally, it was done. I did some minimal testing but it should work well. You may download this from here.

Steps to install:

0. First make sure you have the python bindings for notify-osd, the new notification system for Ubuntu. If not, then install it with the below command:

$ sudo apt-get install python-notify

1. Download, gunzip and untar the gmailnotifier.tar.gz file from the above link.
2. Go to the gmailnotifier folder so created and run the setup.py file.

$ ./setup.py

It will ask a few questions, like your gmail username, password, where you want to install the script and what should be the time interval in seconds to periodically check your mailbox for new mails. Make sure you answer those questions carefully and correctly. I have not added error checking for those questions yet :-|.

But if you feel anything is not correct, you may simply press Ctrl-C, abort the script and then run it from the beginning.

3. Now simply log off from gnome and then log back in. You are all set! That’s it. And don’t worry my setup script makes sure that the configuration file is not world-readable, since your Gmail password is there in plain text.

Enjoy ! In the event that you want to uninstall my script, you can do it manually(since uninstall option is not present in the setup.py script yet). Just open the file ~/.config/autostart/gmailnotifier.desktop in your favorite text editor. Note down the line which has an ‘Exec’ in it as the first word. That line would be something like:

Exec=/path/given/while/running/setup.py/gmailnotifier/gmailnotifier.py

Note down the path, excluding the gmailnotifier part. Here it would be

/path/given/while/running/setup.py

Go to that path and delete the gmailnotifier folder altogether. After that, close the ~/.config/autostart/gmailnotifier.desktop file and delete that also. That’s it.

And in case you are wondering how this looks like, here is a screenshot of it in my Ubuntu Jaunty installation. Look at the top right hand corner. It says I have 3 new mails.

Also, if you have not noticed by now, once installed my notifier script installs itself as a gnome startup program. If you go to ‘System->Preferences->Startup Applications’ you can see a new entry named ‘gmailnotifier’. Here is a screenshot of that too, just so that you don’t get surprised later when you see this new thing there all by itself.

Read on if you want to know the technical details of my notifier. Basically my notifier depends on chiefly two main libraries - glib and pynotify. Glib is a general purpose library that is the foundation for GTK+ but more than that, it is a very high quality general purpose library that you can use freely in your other programs. Pynotify, on the other hand gives python bindings to the libnotify library.

In my script I first create a glib main loop. A main loop is an event loop that waits for events waiting indefinitely. Yeah, you guessed it, a glib main loop is at the heart of all GTK+ GUI applications which are fundamentally event driven and respond to mouse clicks, drags/drops and key events. But before I start the loop, I register for a timer callback every n seconds. This n is the interval the script would check your inbox for new mails.

This is one of the values you supply while running the setup script. Anyway, whenever this timer expires, the timer callback is called and this callback logs in, checks the Gmail RSS feed and informs you if there are any new mails. The point to be noted here is that new mails here mean mails that are ‘new’ to the script not to your inbox. Since this script does not mark new mails as read after displaying them, it maintains its own 2 buffers of old mails and new mails respectively. Any mail that is present in the new mail buffer but not in the old mail buffer is flagged as new and this count is what is shown in the the pop up.

As usual, comments/suggestions/bug reports are welcome if you liked my gmailnotifier!

admin Linux, Ubuntu Gmail, notify-osd, Python, Ubuntu

Nautilus is the default file manager in Gnome for Linux. And Rhythmbox is the official Gnome music player.  Rhythmbox supports many advanced features like Internet Radio, Library management, support for Apple iPod, DAAP shares and MTP to name a few.

So the other day, I had an idea to find a way to directly enqueue an audio file into the rhythmbox play queue. If you have used Winamp over windows, it is akin to the ‘Enqueue in Winamp’ option that windows explorer provides for audio files if you have installed Winamp in your machine and right clicked over any audio file.

So first I searched if such a Nautilus plugin was really already available. To my happiness I found one plugin, written in python for a similar use but for enqueueing into the playlist of the Audacious, another music player on Linux. So, I downloaded it, and after a few minutes of hacking, it was ready for rhythmbox. So I can’t take entire credit for creating this plugin ;-).

The only trouble I had was to find out which option to use with rhythmbox from the command line to import the audio file into the library AND enqueue it into tha play queue. The man page did not mention anything. Then I downloaded the entire rhythmbox source code and finally from the code was able to know how to achieve what I wanted.

So here it is. Click here to download the plugin, add-to-rhythmbox.py. Installing this plugin is really easy. Just follow the following steps:

1. First, install python-nautilus package which gives the python bindings for Nautilus:

sudo apt-get install python-nautilus

2. Create a folder called ‘python-extensions’ within .nautilus within your home folder. i.e if your home folder is /home/foobar then create /home/foobar/.nautilus/python-extensions.

3. Copy the downloaded script, `add-to-rhythmbox.py` into this python-extensions folder.

4. Restart nautilus with the command:

killall nautilus

That’s it. Now you can right click over any audio file and see the new option to enqueue that file into the rhythmbox play queue. Here is a screenshot of how it looks like:

Hope this plugin would prove useful to all you Linux/Gnome users. Ideally I should have written this using dbus but was too lazy to do so. Maybe next time I would do that and post version 0.2.

Until my next post, g’bye and take care!

admin Linux, Ubuntu Linux, Plugin, Python, Rhythmbox, Ubuntu

Some time last year, I got myself  a few serial EEPROMs. As the name suggests, they are accessed serially using some serial protocol(usually SPI or I2C). Hence these serial  EEPROMs don’t have a parallel data/address bus that we normally associate with EEPROMs in general. Here is a photo of my SPI based EEPROM, a 25AA256 from Microchip.

Memory is written to and read from the EEPROM using a serial protocol, which may be SPI or I2C. I already wrote a post back then when I interfaced a SPI based serial EEPROM with my arduino board. This time, I have interfaced that same SPI based serial EEPROM(the microchip 25AA256 to be precise) with my Dallas DS-5000T microcontroller development board which has a DS5000T in it and that is basically a variant of the classic 8051 core. But alas! the DS-5000T does not support hardware SPI!! Hardware SPI means that you don’t have to implement the SPI protocol in software and by just setting up a few registers you can simply copy the byte in the output register and the microcontroller takes care of encoding each bit within that byte and sending it across the SPI bus. So that means that I had more work to do. I had to in fact implement the SPI bus protocol in software, which is also known by the term bit-banging. But before we discuss further let us look at how an SPI bus looks like:

As you can see, SPI works on a master-slave paradigm. The master is the one which initiates all data transfers. There can be several slaves on the same bus and the master has to select the slave it wants to communicate with by asserting the chip select line(also called slave select or SS line) of that slave. Here, SCLK stands for slave clock. The master has to supply the slave with clock pulses for it to work. MOSI means master out-slave in and MISO means master in-slave out. The former is used to transmit data from the master to the slave and the latter is used to receive data from the slave into the master. SS means slave select as indicated earlier. The slave would be active only when SS is asserted by the master by pulling it low.(It is asserted by pulling it low since SS is active low, indicated by the bar on top).

For more details about SPI, you can take a look at this Wikipedia link. The way my system is designed is that my DS5000T board acts my master which issues the EEPROM read/write commands. And the EEPROM itself acts as a slave. In order to communicate with the DS5000T, I use the PC serial port. The software that runs on my DS5000T, I call SEAShell -  or Serial EEPROM Access Shell. It is a shell in the sense that it allows you to read/write a particular byte within the EEPROM. Although I have not created a file system of sorts within my EEPROM, but that is an eventual goal. It would be really cool to have my own seemFS or Serial EEPROM Embedded Micro File-System. (I must add, I continue to impress myself with my cool names ).

So here is how my SEAShell setup looks like:

The circuit schematic of the connections between the DS5000T and the serial EEPROM is also very simple for this setup. It is so simple that I am not going to bother creating another drawing for it. The connections between the DS5000T and the 8 pin 25AA256 Serial EEPROM can be done as follows:

a) Pin 2.0 of  DS5000T –> Pin 1 of 25AA256 (/CS)

b) Pin 2.1 of DS5000T –> Pin 2 of 25AA256 (SO)

c) Pin 2.2 of DS5000T –> Pin 3 of 25AA256(/WP)

d) Pin 2.3 of DS5000T –> Pin 7 of 25AA256(/HOLD)

e) Pin 2.4 of DS5000T –> Pin 6 of 25AA256(SCK)

f) Pin 2.5 of DS5000T –> Pin 5 of 25AA256(SI)

g) Pin 4 of 25AA256 should be grounded.

h) Pin 8 of 25AA256 should be raised to VCC, +5 volts DC.

For more details about the 25AA256, you may refer to its official datasheet here.

The connection between the PC and the DS5000T board, of course uses the MAX232A level shifter(since RS232 voltage levels are not TTL compatible) and a few 10 uf capacitors. That is a standard connection and a bit of google can tell you how to interface a MAX232 IC with a serial port.

On the software side, I have written two programs for this:

a) SEAShell.asm  : An assembly language program for the 8051 that is burned into my DS5000T development board (using my very own gnuProload software, of course!). The job of this program is to provide an interface to the human user through the PC serial port to allow the human user to interactively (or in an automated way), read/write data into the Serial EEPROM. The source code for SEAShell.asm can be found here.

b) SEAShellUtil.c : A C language program that utilizes the automated mode of SEAShell.asm and can be used to read/write big files into the serial EEPROM. This is needed because we cannot expect a human user to type in several thousand bytes in case he/she wants to write them into the EEPROM. The source code for SEAShellUtil.c can be found here.

So my complete SEAShell setup comprises of the following  components:

a) The DS5000T development board. Note that any 8051 compatible microcontroller can be used because my SEAShell.asm uses only standard 8051 assembly language, no fancy 8051 variant specific things are used. Here I used my DS5000T because it was convenient for me. I could also have used my Atmel AT89S52 here.

b) The software consisting of SEAShell.asm and SEAShellUtil.c

c) The Serial EEPROM itself, which is a 25AA256. You can use any serial EEPROM which is based upon SPI. But you would have to modify the page size within the SEAShell.asm and SEAShellUtil.c code. Also find out whether the EEPROM accepts data MSB first or LSB first and then modify SEAShell.asm accordingly.

d) A simple serial port communication software like minicom (on Linux) or HyperTerminal(on Windows). Note that, SEAShellUtil.c would run only on Linux. However, you may try out the interactive mode of SEAShell.asm on any OS that has a serial port communication software(like minicom or HyperTerminal).

Here is a photo showing my hardware setup for SEAShell:

The EEPROM can be seen on the right hand side fitted in a small ZIF socket. My DS5000T board can be seen on the left. Still further to the left you can see the serial port DB9 connector which connects to the PC on the other end. Also above the serial port connector is the small USB connector that supplies power to the DS5000T development board directly from my PC.

And to clarify matters more, here is a screencast which shows SEAShell in action:

I hope you like this post about SEAShell. As usual, do write in your comments and suggestions. Your comments go a long way in inspiring me to create more such stuff !

Until next time, this is Seemanta saying good-bye to you all and take care!

admin Embedded Hobbyist, My Creations, Tech 8051, DS5000T, Embedded Hobbyist, Serial EEPROM, SPI

I started creating small embedded projects for fun about a year and a half back. Since then I have been hooked into it and today it takes the entirety of my free time. I started out with the humble 8051 and along the way have had the fortune of laying my eyes on the sexy Arduino, the powerful AVR and even the austere MSP430. A list of my embedded projects can be accessed here.

Here is a brief overview of the platforms that I own, as of this writing. By platform, I mean a hardware and software setup that allows me to write code in C or assembly, compile/assemble that code, ‘burn’ that binary into the target microcontroller and then possibly debug that ‘burned’ code.

1. AT89S52 development platform: This is the very first platform I ever owned. I purchased this from a company in Gujarat (a western province in India) called Sunrom. I am very satisfied with their product although a bit disappointed with the company for the lack of Linux support for its flashing software. I chose this as my first platform since I was most familiar with the architecture of the ATMEL AT89S52. AT89S52 has a 8-bit CISC architecture.

Type: Purchased
Approximate cost:  2250 INR (2006)
On Chip Debug support: No
Linux support: No. But I created a ‘reverse-engineered’  linux port for its flashing software. Look here.
Cons: Lack of Linux support from Sunrom and on chip debug.
Pros: Availability of some very good development tools like SDCC, ASEM51 etc.
My Comments: Best system to start embedded development at a minimum cost. Good value for money.
Overall Rating: 4.0/5

2. MSP430 EZ430-RF2500 USB development tool: I went to attend the MSP430 day conducted by Texas Instruments all over the globe and they gave this USB development tool as a free sample. This tool can be programmed via the IAR IDE that runs on windows through the PC USB. For the unitiatiated, MSP430 is a range of ultra low power microcontrollers from Texas Instruments. It has a 16-bit RISC architecture. Frankly speaking, I have never created any big project with the MSP430. Main reason being that for it to work, a separate 3.7 V power supply is needed for this ultra low power beast. Normal 5 volts that we use usually for other micros would fry it. But the circuit components would still need 3.7 volts. Thus, a kind of isolation would be needed to make sure that the 5V does not flow into the MSP430. This is one reason, I have never tried making anything with this platform. It just lies in my shelf, gathering dust till the moment of its beckoning comes.

A plus point however is that Texas Instruments have also created DIP version of this microcontroller which helps the hobbiyst who is occasional not well equipped to perform SMD soldering.

Type: Free Sample given by Texas Instruments for MSP430 day attendees.
Approximate cost: 40 USD, if I remember correctly.
On Chip Debug support: Yes
Linux support: GCC port of MSP430 seems to work in Linux, but have heard horror stories from people trying to make the USB tool which I have work in Linux. Problem is compounded by Texas Instruments not releasing the sources for the DLL needed to talk with the USB stick tool.
Cons: Lack of proper Linux support. IAR compiler does not work beyond 4k code size.
Pros: DIP version is hobbyist friendly and availability of MSP-GCC is a boon for those who cannot afford the IAR C compiler.
My Comments: Not recommended for newcomers.
Overall Rating: 2.5/5

3. Arduino: This tiny physical computing platform has taken the embedded hobby world by storm. There are thousands of websites all over the web with thousands of cool arduino projects. Arduino is easy to learn and easy to program. But while many people would recommend it for newcomers, I would really not do so. Arduino lets users program at a somewhat abstract level using its IDE which is based on processing. I firmly believe that someone should start with embedded development with the guts-first approach, i.e. learn the architecture from inside out and start programming in assembly language before graduating to high level languages like C or processing/wiring.

Type: Purchased
Approximate cost: 35 USD, back in 2008.
On Chip Debug support: No
Linux support: Yes. Arduino works out of the box with my laptop which has Ubuntu Intrepid Ibex.
Cons: Lack of on chip debug really makes creating complex stuff a pain in the butt.
Pros: Lots of sites on the web to start development.
My Comments: Not recommended for newcomers. But would readily recommend for experienced developers.
Overall Rating: 4.0/5

4. AVR ATmega: This is my latest acquisition in the world of embedded platforms. I hand made this myself after hours of backbreaking soldering sessions. But every minute of those sessions was wortwhile when I was able to use plain old GDB to perform hardware debugging of my target board. And did I mention, it works in windows too ? You just need to install win-avr and avr studio .

For the uninitiated, AVR is a RISC architecture from ATMEL and is wildly popular among hobbyists. The best thing about AVR is the availability of the completely free GNU tool chain for this arcthitecture which is why is it so much popular among students and hobbyists.

Type: Hand made
Approximate cost: 300 INR or 7.5 USD (Believe me !!)
On Chip Debug support: Yes.
Linux support: Yes. AVR ATmega is fully supported on Linux through AVaRice and the AVR port of the GNU toolchain.
Cons: Might be a bit daunting for the absolute noob to make this with bare hands, but then it can be also purchased from ATMEL but be ready to shell out in the range of 100 USD.
Pros: Very hacker friendly, and GNU/Linux friendly too. Works on windows along with win-avr and avr studio.
My Comments: Excellent  for newcomers. Also a great way to learn basics of soldering and embedded development.
Overall Rating: 4.5/5

So this completes my review. And no prizes for guessing who the winner is!. It is no doubt the AVR platform that steals the show. And why not? With its powerful on chip debug, 100% free GNU tool chain, GDB compatible software, Windows plus Linux compatibility, AVR really does steal the show.

That is all the time I have this time. Happy embedding!!
With this thought, I now take your leave and would see you all in my next post!

regards,
Seemanta

admin Embedded Hobbyist 8052, Arduino, AT89S52, ATmega, AVR, Embedded De, Embedded Hobbyist, MSP430