Olinuxino A20 micro: a new toy in Garretlabs!

…Yeahhhh!!!! 🙂

I’m always happy when my lab “boards family” grows…. and this time I bought a very interesting single board computer from Olimex, a Bulgarian company: one Olinuxino A20 micro (without NAND flash).

This is the toy (photo from Olimex blog):

a20

As usual I bought the board from my favourite online shop: Robot Italy (this is not a commercial spot…but I would like to have some little discount from this company!).

With the board I ordered also the ad-hoc plexiglas box, some 40-pins flat cable (in order to connect some GPIO) and the SATA cable to connect a 2.5” hard disk to the board.

The board arrived in one day with Bartolini express courier (Robot Italy is very fast to ship), and these are my very first impressions about the board:

  1. The packaging is very beautiful (as we say -literally- in Italy: ” also the eye wants his part” 😉 )
  2. The board has a very solid appearance, and it seems very well designed and built
  3. The ad-hoc plexiglass box prefectly fits, and it’s very “chic”  (see point 1)

I downloaded the official Debian image from Olimex, I wrote it on a Kingston microSD (class 4) using the open source Win32 Disk Imager. Note that Olimex recommends to use a class 10 microSD…but I wanted to try with a cheaper choice. 😉

After this, I connected the HDMI cable to my 37” Panasonic TV, I connected to one USB connector the radio transmitter for my wireless cheap Trust keyboard + mouse (only 19 euros… but it’s a very good choice to be used on the sofa in order to seek youtube videos…. with the fingers by the chips and assorted fried food 😀 ) and I powered the board with the miniUSB connector.

Pushed the power ON button, first boot….a moment of real suspence….and all worked correctly!  …YES! 🙂

keep-calm-and-try-olinuxino

Ok, I tried some program preinstalled in the Debian image (such as Midori browser) and I noticed that all seems faster than same programs running on the Raspberry PI (ok, I know it’s obvious but I want to evidentiate this concept).

After this first boot I connected a wifi dongle (this dongle from Robot Italy, as usual) to the other USB connector and I rebooted the board.  The dongle is supported by Debian but, after the connection to my home WPA2 protected wifi network, I observed some problem tied to lost ping packets (approx 25% of the total number) .:-(

Mhhhhh… it could be tied to a too high power consuption, so in the next days I will try using a 6-16 volts external power supplier instead the miniUSB source (as recommended by Olimex in the user manual, in order to have the maximum efficiency with external peripherals).

For the moment that’s all, folks. After the first few steps with this board, Olinuxino A20 seems to be a great study opportunity for my natural born curiosity. 🙂

….Bye bye geeks!!!!

Advertisements

Arduino + Raspberry= Weather station with webcam (Part One: the I2C link)

Hi geek boys and girls!

After few more technical and obscure posts, finally I give some (original? I don’t think so…but it’s funny!) creative idea for your *ware open source projects.

With this post I would like to start building a open source meteo weather station.

In order to do this task I think you could connect together, such as a great cup of Mojito 🙂 :

  • A set of sensors (i.e. humidity, barometric pressure, temperature)
  • One little camera (i.e. we could start with an inexpensive webcam…if the weather conditions would permit its use!)
  • One Arduino UNO (or one Intel Galileo ;-))
  • One Raspberry PI Model B
  • One GSM module, or more simply, one less expensive USB internet key (to access via internet to your station)

Ok, first question: why Raspberry AND Arduino (and not only one board)?

Well… I would like to use Arduino to manage all sensors (especially if they would be analog sensors, since Raspberry doesn’t have analog inputs), and I would like to use Raspberry to manage the webcam and the communication with the external world via the GSM module (since it has  high-level functiona).

So I will use Arduino as acquisition board and Raspberry as data collector and as webserver.

Raspberry and Arduino can talk to each other using some different approaches, but I would like to use the I2C protocol, because it’s very simple and very well supported by Raspbian distribution and by native Arduino libraries.

I found this interesting post by Peter Mount in order to safely connect Arduino (as slave) and Raspberry (as master) using I2C.

In order to activate the I2C bus on Raspberry Peter reports five step on Raspbian:

  1. Open /etc/modprobe.d/raspi-blacklist.conf and comment the line reporting  i2c-bcm2708 (so, I2C is removed from blacklist)
  2. Add i2c-dev to the /etc/modules in order to activate the I2C driver at boot
  3. Install i2c-tools using thje well known apt-get install command
  4. Add the “pi” user to the i2c group (using the adduser pi i2c command) in order to let the user “pi” can access to I2C
  5. Reboot the Raspberry board.

In order to phisically connect Arduino and Raspberry via I2C:

  1. Connect SDA Raspberry pin (GPIO0) to SDA Arduino UNO pin (Digital IO 4)
  2. Connect SCL Raspberry pin (GPIO1) to SCL Arduino UNO pin (Digital IO 5)
  3. Connect the ground pins fo the two boards

Remember that Raspberry uses 3.3V as base voltage and Arduino UNO uses 5V…so pay attention: OR if you use a voltage converter in the I2C connection OR you are sure that you are using Arduino as slave I2C device and Raspberry as master I2C device. The first one choice is the best…but I love the risks (the risk in this cas is to have a “Raspberry flambé” 😉 ).

Ok, let’s go ahead. I used a little analog temperature sensor (the one provided in all starter kits by Analog Devices! 😉 ) connected to Arduino UNO (in the Analog input A0)  and then I modified the code provided on the Peter Mount blog in order to read the ambient temperature using Arduino and send it to Raspberry via I2C bus.

This is the simple circuit I used (zoom to better view the links):

20140411_084154

The code on Raspberry is the following (it’s directly taken from Peter Mount Blog, except for only one correction: I defined file as FILE* since declared as int raised a segmentation fault on fclose call….):

#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <linux/i2c-dev.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>

// The Arduino board i2c address
#define ADDRESS 0x04

//For V1 Model B you need i2c-0
//For V2 you need i2c-1(...in my case I have a V2 Raspberry Pi! :-) )
static const char *devName = "/dev/i2c-1"; //)

int main(int argc, char** argv) {
 if (argc == 1) {
   printf("Supply one or more commands to send to the Arduino\n");
   exit(1);
   }

 printf("I2C: Connecting\n");
 FILE* file;
 if ((file = open(devName, O_RDWR)) < 0) {
   fprintf(stderr, "I2C: Failed to access %d\n", devName);
   exit(1);
   }

 printf("I2C: acquiring buss to 0x%x\n", ADDRESS);
 if (ioctl(file, I2C_SLAVE, ADDRESS) < 0) {
   fprintf(stderr, "I2C: Failed to acquire bus access/talk to slave 0x%x\n", ADDRESS);
   exit(1);
   }

 int arg;
 for (arg = 1; arg < argc; arg++) {
   int val;
   unsigned char cmd[16];
   if (0 == sscanf(argv[arg], "%d", &val)) {
     fprintf(stderr, "Invalid parameter %d \"%s\"\n", arg, argv[arg]);
     exit(1);
     }

   printf("Sending %d\n", val);
   cmd[0] = val;
   if (write(file, cmd, 1) == 1) {
    // As we are not talking to direct hardware but a microcontroller we
    // need to wait a short while so that it can respond.
    // 1ms seems to be enough but it depends on what workload it has
    usleep(10000);
    char buf[1];
    if (read(file, buf, 1) == 1) {
      int temp = (int) buf[0];
      printf("Received %d\n", temp);
      }
   }

   // Now wait else you could crash the arduino by sending requests too fast
   usleep(10000);
  }
  fclose(file);
  return (EXIT_SUCCESS);
}

 

The code on Arduino UNO  is very simple and it is derived from the code taken from Peter Mount Blog:

#include <Wire.h>

#define SLAVE_ADDRESS 0x04

int number = 0; //command identifier (sent by Raspberry)
double temp; //variable used to store the temperature
const int sensorPin = A0; //pin where we read the temperature from the sensor
 
void setup() {
 // initialize i2c as slave
 Wire.begin(SLAVE_ADDRESS);
 // define callbacks for i2c 
 Wire.onReceive(receiveData);
 Wire.onRequest(sendData);
}
 
void loop() {
 delay(100);
 temp = GetTemp();
}
 
// callback for received data from I2C
void receiveData(int byteCount){
 while(Wire.available()) {
 number = Wire.read();
 
 //"2" is the command sent by Raspberry Pi in order to have the 
 // temperature as answer on I2C from Arduino
 if(number==2) { 
     number = (int)temp; //Arduino in this case sends the integer value of temperature
  }
 }
}
 
// callback for sending data on I2C
void sendData(){
 Wire.write(number);
}

float GetTemp(){
 // read the value on AnalogIn pin 0 
 // and store it in a variable
 int sensorVal = analogRead(sensorPin);

 // convert the ADC reading to voltage
 double voltage = (sensorVal/1024.0) * 5.0;
 
 // convert the voltage to temperature in degrees C
 // the sensor changes 10 mV per degree
 // the datasheet says there's a 500 mV offset
 // ((voltage - 500mV) times 100)
 double temperature = (voltage - .5) * 100;
 return temperature;
}

Ok… we can now download the cvode on Arduino and we can compile the client software on Raspberry Pi using the good old command:

gcc -o TakeTemp main.c

So, once powered on Arduino and verified using the Raspberry command

i2cdetect -y 1

that Arduino is correctly detected with I2C address 0x04, write in the Raspberry command line

./TakeTemp 2

Note that “2” is the I2C command used to receive from Arduino the acquired temperature (see the Arduino code above).

…If all will work correctly, you will read as output the integer value of the sensor temperature, acquired by Arduino and sent to Raspberry via I2C!

Yeah geek guys (and obviously geek gals)…”this is one small step for the human race”, but it’s also a good start to develop an open source meteo station. 😉

And now… a good relax!:-) That’s all folks (for this time)! 😉

…Bye bye!

The dark side of porting Arduino sketches on Intel Galileo (part two)

Hi geek friends ( female & male)!

This is the post of the “real dark side” of porting external hardware control from Arduino to Intel Galileo. And, it’s just an example, a little sketch of the real work.

…Are you ready? Before starting this dangerous “trip” I want you send a first warning: unfortunately the x86 (the architecture of Intel Quark, the CPU inside the Intel Galileo) is very different from the architecture of the AVR (the Arduino MCU). So, registers, memory spaces etc. are completely different (Monty Python docet!).

My (insane, very insane 🙂 ) idea was to port some “lower level” code from Arduino Mega to Intel Galileo, in order to verify on my skin the real hardware differences between the two platforms and also in order to compare the “hardware level” performances.

I opened the “Arduino on Android kit” (a very appreciated gift from Monica! ;-)) and I found two very interesting hardware components: two ht1632c bicolor (red/green) led displays.

What a cool find! 😉 I love the shifting dysplays in the chinese stuff stores! 😀

So… I googled for already working driver on Arduino for these devices. I found some very interesting solution. The first one library is here, and it is very powerful and fast in my little opinion.

I tried on the Arduino Mega all the library demo sketches and I verified the correct work for my two displays. Looking inside the code I saw that all the library is based on AVR registers programming (using in every instruction all the possible bit-field functions, bit masks, bitwise operators and so on…).

Weahhhh…ok, I know this is the correct mode to write a driver, and it’s true that I wanted to go to a “lower level”…. but not so low! 😀

Indeed, once ported the code inside the Intel Galileo IDE, a so high number of “undefined references”  gave me the real proof that NOT ALL the AVR architecture has been ported by the Intel team in the Galileo development environment…. so we have two natural choices: the first one is to rewrite all the library using the Quark registers instead the AVR registers (but we are inside a Linux environment, it’s no so simple to manipulate the low level hardware without interact with the Linux kernel) or, the second choice is try to write a library at an higher level, using only the basic functionalities  (so using the native APIs) of Arduino.

I preferred the second oprion (…you suspected it, I know! :-)), so  I started looking for a little simpler (and without too many functionalities) library working directly on Arduino GPIOs, in order to simplify the porting phases (and possibly without losing my love in microelectronics 😉 )

I found the code  and the circuit reported on Arduino Playground (I love this site…because it’s a made in Italy product. You know, we don’t have only corruption, not-so-effordable persons & politicants… and soccer 😉 )….and -oh, oh- it was exactly what I was looking for. 😀

I took all the code and, after I removed the parts (code and hardware) related to the real time clock (because actually I don’t have a RTC!), I compiled the code in the Arduino IDE and I flashed it on my Arduino Mega. I obtained a “fixed hours and day” red and green clock on my two led displays. The draw of the displays is very fast (approx. immediate).

Ok, I ported the same code in the Galileo IDE and I obtained some compilation errors, tied to the hardware differences between Arduino and Galileo. This is the pinout for display I used:

ht1632_pinout

Mainly Galileo IDE doesn’t have the <avr/pgmspace.h>… it’s natural since it’s a x86 CPU…but it is also a problem, because the great majority of third party lins use this file and its definitions (especially to declare some variable directly in the program flash, since Arduino doesn’t have so much RAM).

But since Galileo has a lot of RAM, it isn’t necessary to save data in the flash program space.

So, following the defines reported in avr/pgmspace.h , I changed in the file font1.h definitions:

PGM_P CHL[] PROGMEM= [...]

in a simple

char* CHL[] = [...] .

After this, I removed the #include <avr/pgmspace.h> in the main .ino file,  and in the same file (function set_buffer()) I changed the line :

memcpy_P(buffer[j], (PGM_P)pgm_read_word(&(CHL[j+pos])), 8);

in

memcpy(buffer[j], (const char *)(&(CHL[j+pos])), 8);

Once resolved the errors, I compiled and flashed the code on Galileo.

I obtained a strange behavior: instead of the clock some strange character appeared on the two displays, with a very very (very! 😦 ) slow draw rate.

Ok, I think the strange characters are tied on a non perfect alignment on the memory in the x86 respect to the AVR  or to different sizes of some data type, especially due to the above memcpy porting  (but I didn’t investigated so much because I was worried by the displays slow draw rate). So, I changed the initial code in order to write a text on display pixel by pixel (note that this is the same approach of the original code), starting from drawing a single pixel in a certain (x,y) coordinate.

The differences between the initial code and my modified code can be easily found comparing the code in the page of Arduino Playground and the attached the zip file.

I attach the complete code as zip file since the code is too long for a blog post…and I think this post is already too long. But remember this is a “difficult” post. It MUST be long! 😉 Please excuse any commented code and some commentsin Italian…I know this is a lab “spaghetti code” . 😉

Ok, using this code the text is shown in the correct way on Intel Galileo (….to be investigated the strange drawing with the original code! 😉 ), but using Galileo the draw process took approx. 20 seconds (versus the Arduino result, which is minor than 1 second!!!) and with some different delay times between one pixel draw and the subsequent.

This is the final result (sorry for the up-down text, but I have very short wires between Galileo and the display…;-) ). In the background of the photo you can see two beautiful italian progressive rock cds by Maurizio di Tollo and by La Maschera di Cera (both my good friends), which have been the inspiration for my porting work. 🙂

20140330_104925

Any ideas for this behavior (the slow drawing process)? I have one…but I don’t know if it is the correct idea.

As you know, Intel Galileo runs the Arduino sketches as Linux user processes (so, all kernel calls, interrupts, threads etc. have a higher priority  than a user process and so they can interrupt the execution of the Arduino skecth), whereas in Arduino no operating system is used (the sketch is a well-known “bare metal” code), so a real time behavior is a “true real time” behavior, and the sketch runs at the highest speed without interruptions.

So… what can I say? Intel Galileo is a really fast machine (compared to Arduino Mega or UNO) but in my little opinion it has some little “real time” problem when using the Arduino IOs (also I know my code is not optimized at all!!! 😉 ). And you? What do you think? 😉

Please, express your geek thinkings, and find al my errors! I will appreciate each contribution, especially  tied to my errors….the knowledge is always a mindstorm! 😉

Bye bye folks, now I go on my sofa to drink my brandy.

Another day is passed…another post is written. 🙂

ML

 

…And now for something completely different: Raspberry PI and his mysterious NOOBS boot error

Hi geek friends!

Many thanks to Monty Python for the title of this post 🙂 …and many thanks also to you, for having patience with my highly -humoured posts.

and_now_cleese

This time I can’t talk about Intel Galileo because I bought a Raspberry PI in order to play a little with also with him (yes, I love these electronic toys)…and I immediately encountered a strange problem on his installation and startup phase.

This post wasn’t foreseen but… I write it for you, because curiosity killed the cat (and I am very curious). 😉

Following the instructions on the Raspberry official site  I downloaded the NOOBS 1.3.4 distribution and I wrote the unzipped folder on my Kingston 8GB microsd.

After the power-on  a very appeared on the HDMI monitor. I decided to install the Raspbian distribution (because I love Debian too…).

After the installation process I clicked on OK to reboot the board and after few seconds the boot process stopped with a strange, very strange message. Something like this: PANIC- VFS Unable to mount root fs on unknown-block (179,2).

And (obviously) this produced an old, well known, KERNEL PANIC.

Yeah, I love Linux also for his way to express a problem (but I love also the Commodore Amiga with his GURU MEDITATION…do you remeber?).

After another forced reboot (power off + power on is always a good choice, especially when it is the only possible one 🙂 ) I entered the maintenance screen holding the shift key but… the only options are: reinstall a distribution or modify the command line. But any change on the command line has no effect  in this tool (it seems that the new command line isn’t saved).

No way. This is another damned Linux & Co. bug…. (as we say in Italy: “I know you, little mask!” -Ti conosco mascherina!-).

Ok, I extracted the SD card and I put it in my Linux computer. In the SD card Boot partition there is a very interesting file: cmdline.txt which has inside:

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

 keep-calm-and-debug-raspberry-pi
Mhhh… I saw that (in my opinion) /dev/mmcblk0p2 is too much small to execute a correct boot process (or to start it), then I googled around and I found that the instruction:

root=/dev/mmcblk0p2

should be changed in order to set the root to the SD partition 6 (I saw this is the SD partiton containing the largest amount of data):

root=/dev/mmcblk0p6
 
Ok, I saved the new cmdline.txt file then I unmounted the SD card from the PC and I reinserted the card in the Raspberry PI.

Power on…. and, as a magical trick, this time always worked (boot, hardware initialization and so on).

But…why?

Why this strange behavior?

And again..why the last July, when I used my first Raspberry PI, I dind’t encounter this problem? Ok, I used NOOBS 1.2.1 in July… but using the NOOBS 1.2.1 with the new Raspberry PI  the result was the same. The only other changed thing is the SD: in July I used a Sandisk SD class 4 8GB, this time I used a Kingston microSD (with adapter) class 4 8GB. Is it so important to Raspberry configuration?

I let the true Linux experts (I am only a part-time expert) to answer to these questions….

…Now I’m on my sofa, tired but happy, with a glass of good brandy in my hand (thanks Monica). 🙂

Bye bye geeks, it’s all for now.

Unpacking (and playing with) the Intel Galileo board: first impressions

Good morning to all you embedded freaks!

Let’s talk a little about Intel Galileo today. Just a “first impression post”… a very light chunk in order to smoothly introduce the argument.

I opened the box some day ago. In the box there is the board and a power cord with ALL possible plugs (so you can use the Galileo everywhere, but ALWAYS with a power socket on the wall! 🙂 ).

galileos

Is it an Arduino Uno or a Linux based embedded board? Mhhh…someone told me it’s a hybrid one between the two things.

But after some very basic experience on this board, I am at the moment very doubtful about the right answer.

In order to do the first (baby) steps with the Galileo board you must use the Quick Start Guide from Intel (you can download it from the official website). It’s a good starting point (since it it the -near- only one!).

After this…it’s up to you guys! 😉

Well, anyway, you must always remember three very important things (the first one is the most important, trust me: it’s veryveryvery important):

  1. You must connect the Galileo power plug BEFORE to connect his USB to the host PC (so, you must disconnect the USB from the host PC BEFORE to disconnect the Galileo power plug). It seems that a incorrect connection/disconnection order could break (…burn?) the Galileo hardware. Arghhhh…too dangerous! 🙂
  2. If you don’t boot the board from a Linux image installed on the microSD, any Arduino sketch downloaded using the IDE on the Galileo board, will be lost at the power off. In order to have a “persistent” sketch (wich it will start his execution after the Galileo boot, exactly as on the Arduino UNO) you must boot the Galileo board starting from the microSD, with the devoted Linux distribution installed on (because in this case the downloaded sketch will be saved in a filesystem folder called /sketches).
  3. All advanced functions, the network drivers and protocols (networl support, telnet and ssh in primis) will work only if booting the Galileo board from the microSD.

I think that these three aspects (especially the first one) will be corrected by Intel in the next release (if there will be…).

The last thing I’ve noticed after two hours of play is very interesting: the Intel Galileo doesn’t have a video output (differently from other embedded Linux solutions such as Raspberry PI). My colleague and friend Paolo noticed it after 5 minutes on the web…but it is more skilled than me on embedded hardware! 😀

Ok, I think it isn’t so necessary but it could be funny. One solution (pay attention: now I’m talking with no idea if it is really possibile/feasible, and how great would be the effort to up’n’run this solution!) to have a video output with a graphic environment could be the use of a X remote screen connecting Galileo to a Linux desktop machine…. it could be one really good idea for a case study (I think I will try in the future)!

Another thing. An annoying thing for me, especially to execute portings from Arduino UNO to Intel Galileo. The hard reality of facts is that … String class doens’t work correctly in the modified Arduino IDE from Intel.

Ok, if no one yet revealed to you this secret (I know it’s a “Pulcinella’s secret” -a very well known secret-, as we say in Italy)… I’m proud to do it. 🙂

The use of String class of Arduino IDE is strongly deprecated (by me, but also by some other desperate people -like me- on internet…) because the String operations such as “+” (concatenation) don’t work. So… if you want to print on the serial output of Arduino side some slightly complicated string….I think you should use only combinations of Serial.print and Serial.println functions. Or, you can try to use the old “C” functions dedicated to string manipulation: strcpy, strcmp, sprintf and so on (as usual defined in the file stdio.h). I’ve done a little tour with these functions and they seem to work (also if I think they are really terrible to be used in 2014…) so, good luck guys!

Well, in the next post we’ll go more into concrete spaces (with some code, I know you love it!). So, have no fear (possibly, have a beer)! 😉

Galileo, Galileo… and me.

…Gooooood morning people!!!

My name is Marco Lastri (ML), I am an italian pro system-software engineer and also a pro-am musician.

I work as software engineering manager in scientific areas tied to artificial satellites. I have approx. 25 years of experience in computer science, algorithms, architectures and programming (I started to program my first computer at 12)…and I play any kind of software and hardware synthesizer. And also a little of drums! 🙂

I am interested in the music-electronics-software interaction (because I am not a good piano player! 🙂 ), so I tried to study Arduino (Intel Galileo), Raspberry PI platform and some other ARM based boards in order to create projects often tied to wearable musical instruments (yes, I love all old-style “keytars” such as Moog Liberation!!! 🙂 ).

2014-02-24 07.45.14

So I decided to try this experience: a personal blog dedicated to my projects and to my ideas, based on open source hardware and software solutions.

…You will find here also tips’n’tricks found during my studies on these “black boxes” (damn’ lack of documentation!) called “embedded boards” !

This blog has been created in collaboration with the SirsLab of Università di Siena and with SirsLab official blog (many thanks to professors Domenico Prattichizzo and Monica Malvezzi), in order to share with the SirsLab people experiences on the wearable controller devices.

Firstly… why Arduino? Because it’s an italian product, an italian (good) idea. Because Italia is not only “spaghetti, pizza, mandolinoand corruption. 😉

…Why open source? Because I think it is the only way to create low price new ideas, also created by unexperienced people (but with great mental strenght!).

…Why an english blog? Beacuse, also if my english is poor, I think it’s a simpler way to share with the internet my ideas and my experience.

…Finally, why this blog is called “ML Garret Labs“? Because at the moment my lab is  in my garret…. 🙂

Bye bye tech-geeks…and stay tuned!

PS: in the photo with Galileo, Galileo and me…  there was also Figaro Magnifico (cit. Queen), but it was too on the right 🙂