PrettyPrint

mercoledì 3 luglio 2013

Raspberry Pi - Installare WiringPi e compilare il primo programma

Prima di generare il file eseguibile occorre installare, nel caso non sia già installata, la libreria WiringPi


L'installazione della libreria wiringPi


Lanciare in successione da shell i seguenti comandi:
sudo apt-get install git-core
sudo apt-get update
sudo apt-get upgrade
git clone git://git.drogon.net/wiringPi
Quindi:
cd wiringPi
git pull origin
Infine, senza spostarsi dalla directory wiringPi:
./build

Compilazione e collegamento


Compilazione e linking possono essere fatte contestualmente specificando con -l la libreria wiringPi (prestare attenzione alle maiuscole/minuscole).

pi@raspberrypi ~ $ gcc -o blink blink.c -lwiringPi

Esecuzione e interruzione del programma


L'accesso alla funzione wiringPiSetup() richiede privilegi di root. Quindi qualsiasi programma che sia stato scritto usando wiringPiSetup() deve essere lanciato mediante sudo :

pi@raspberrypi ~ $ sudo ./blink

E' sempre possibile eseguire il programma in background, ignorando però i messaggi di errore e sulla console (come eventuali printf() presenti nel programma.

pi@raspberrypi ~ $ sudo ./blink &> /dev/null

L'esecuzione del programma può essere terminata dal terminale  (mediante il classico Ctrl-C) o ancora, se il relativo processo è in background, con sudo killall blink

< Raspberry Pi - Il primo programma, far lampeggiare un LED




Risorse e strumenti usati:
[0] WiringPi, Download and Install 
[1] Blink

martedì 2 luglio 2013

Raspberry Pi - Il primo programma, far lampeggiare un LED

Far lampeggiare un LED è il primo programma che si affronta per conoscere meglio un computer interfacciato al mondo esterno


L'hardware


L'anodo del LED è collegato al pin fisico 11 del GPIO, mediante un resistore di limitazione R1 da 330 Ω ; il catodo è collegato alla massa del Raspberry (pin fisico 6). Il LED si accende quando si manda sul pin un bit 1 (corrispondente a circa 3,3V) e si spegne inviando un bit zero (circa 0V).



Per il calcolo della resistenza R1 di limitazione, si è assunta una tensione diretta del LED rosso pari a 1,8V. Per la corrente di uscita di un pin GPIO è bene mantenersi fra i 3mA e i 5mA; con 5mA il LED ha una luminosità sufficiente. Dunque, la resistenza di limitazione sarà facilmente calcolabile come:





Il software


Il programma in linguaggio C, usa le estensioni wiringPi, che consentono di facilitare le comuni operazioni di lettura, scrittura sul GPIO di Raspberry Pi

BLINK.C
#include <wiringPi.h>

#define LED_PIN 0                // LED rosso (0 WiringPI, GPIO17, pin 11)

int main (void)
{
  // --- Init
  wiringPiSetup() 
     
  pinMode (LED_PIN, OUTPUT);    // configura LED_PIN come pin di uscita
  
  // --- Loop
  while (1)
  {
    digitalWrite (LED_PIN, HIGH) ;  // Accendi LED
    delay (500) ;               // Tienilo acceso per 500ms
    digitalWrite (LED_PIN, LOW) ;   // Spegni LED
    delay (500) ;               // Tienilo spento per 500ms
  }

  return 0 ;
}


Analizziamo il programma.

#include <wiringPi.h>
Ogni programma che usi wiringPi ovviamente dovrà prevedere la direttiva di inclusione del file header.


#define LED_PIN 0

#define LED_PIN 0 è una direttiva al processore. Tutte le successive occorrenze di LED_PIN verranno sostituite con il numero 0.

Per i pin si può seguire il seguente schema di commento:
// Descrizione del pin (numero_pin WiringPI, GPIOxx, numero_pin_fisico)
ossia
// Led rosso 1 (0 WiringPI, GPIO17, pin 11)
In questo modo, di ciascun pin si saprà sempre la numerazione secondo i tre modi: wiringPi, GPIO e pin fisico, agevolando così la fase di montaggio e di debug.


  // --- Init
  if (wiringPiSetup() == -1)  
      exit(1);
  pinMode (LED_PIN, OUTPUT); // configura LED_PIN di uscita
Il primo gruppo di istruzioni che troviamo nella main() sono quelle raggruppate dal commento Init.

Esse vanno a inizializzare la libreria WiringPi e a configurare i pin utilizzati, se di ingresso o uscita mediante la funzione pinMode().

L'istruzione pinMode (LED_PIN, OUTPUT); consente di configurare il nostro LED_PIN, come pin di uscita sul quale potremo dunque inviare bit 0 e 1.

La chiamata alla funzione wiringPiSetup() va fatta una sola volta, comunque prima che si inizino a invocare le estensioni wiringPi , quindi è bene collocarla come prima istruzione in assoluto della main().



  // --- Loop
  while (1)
  {
    digitalWrite (LED, HIGH) ;  // Accendi LED
    delay (500) ;               // Tienilo acceso per 500ms
    digitalWrite (LED, LOW) ;   // Spegni LED
    delay (500) ;               // Tienilo spento per 500ms
  }
Il ciclo while(1){} è il classico "loop senza fine" dei sistemi embedded: le istruzioni contenute nel corpo del while verranno eseguite ripetutamente, finché non si spegne/resetta il computer ovvero si interrompe in qualche modo l'esecuzione del programma (vedi pagina successiva). E' del tutto equivalente a for(;;).

La funzione digitalWrite() manda sul pin desiderato (specificato nel primo parametro) un bit 0 (LOW) o un bit 1 (HIGH). Per mantenere/acceso il LED si usa la funzione delay() che genera un ritardo pari al valore (espresso in ms) passato come argomento; quindi, nel nostro caso, il LED rimarrà acceso/spento per mezzo secondo.

La fase successiva sarà quella di generazione dell'eseguibile e della sua esecuzione ovviamente dopo aver installato la libreria WiringPi.

> Raspberry Pi - Installare WiringPi e compilare il primo programma




Risorse e strumenti utilizzati:
[0] Fritzing
[1] Editor online LaTeX
[2] Google Pretty Print
[3] FidoCadJ

giovedì 20 giugno 2013

Raspberry Pi - I pin fisici e virtuali del GPIO



Il Raspberry Pi dispone di un port di I/O digitale (GPIO), che gli consente di comunicare con il mondo esterno (sensori, attuatori ecc.)

Il GPIO è accessibile mediante un connettore maschio (riferimento sullo stampato "P1") da 26 pin, passo 100mil, disposti su due linee da 13 pin ciascuna.

Lo schema del connettore è riportato di seguito e si riferisce alla revisione attualmente in commercio (la n. 2):



Fonte: http://telpar.altervista.org/


• Pin fisici e pin virtuali


Una prima distinzione che bisogna fare è fra "pin fisici" e "pin virtuali".

I primi seguono la numerazione fisica del connettore, secondo la seguente convenzione: guardando il connettore dall'alto, in modo che la tacchetta di riferimento si trovi in basso a sinistra, il pin 1 è quello che si trova in corrispondenza della tacchetta stessa, il pin2, non si trova alla destra del pin 1, ma sulla linea opposta, di fronte, come riportato nell'immagine successiva:




Fonte: http://www.panu.it/raspberry/


Quindi, la convenzione "fisica" prevede che i pin inferiori siano numerati dispari: 1, 3, 5, ... , 25, mentre quelli superiori vengano numerati pari: 2, 4, 6, ... , 26

I pin virtuali, invece, sono numeri o nomi, usati per identificare i pin fisici nella programmazione o nell'accesso dalla shell.

Un esempio di convenzione virtuale è la numerazione dei pin adottata da WiringPI, una libreria C (e per altri linguaggi), che consente di programmare il Raspberry con una sintassi semplificata, simile a quella di Arduino.

I pin WiringPi sono riportati nell'immagine di sopra cerchiati di colore rosso; come si può vedere si usano 17 numeri (da 0 a 16) per identificare i pin di I/O; ad esempio il pin fisico 11, corrisponderà al pin virtuale 0 (secondo WiringPi) e al pin virtuale 17 (secondo la convenzione del produttore del chip).

La convenzione WiringPI ha un vantaggio non indifferente: è indipendente dalle revisioni delle schede (rev.1 e rev.2), quindi non occorre ridefinire i numeri dei pin nei sorgenti.

• Livelli di tensione e di corrente


I pin GPIO2 e GPIO3 sono internamente collegati a una resistenza di pull-up da 1,8kΩ (linee SDA/SCL della comunicazione I2C).

La massima corrente prelevabile dai pin di alimentazione 3,3V è 50mA, mentre dai rami +5V è 300mA (per la rev.2).

I valori di tensione nominali associati al livello alto e al livello basso sono, rispettivamente, 3,3V e 0V.

I circuiti interni non prevedono alcuna protezione per tensioni superiori a 3,3V, quindi, nel caso si debba applicare a un ingresso del GPIO una tensione superiore (es. 5V TTL) occorrerà utilizzare dei convertitori di livello (transistor, buffer/line driver ecc.), partitori di tensione o zener, per portare la tensione nell'intorno dei 3,3V (i livelli di tensione in ingresso sono: VIH > = 1,3V e VIL < = 0,8V)

Le impostazioni di default, infine, limitano la massima corrente a 8mA per pin, valore massimo che garantisce la corretta interpretazione del livello logico alto.

La rev.2 monta anche un secondo connettore (riferimento P5) che prevede altri 4 pin GPIO, nel caso i 17 pin del connettore P1 non fossero sufficienti.



Risorse consultate e strumenti utilizzati:
  1. http://elinux.org/RPi_Low-level_peripherals
  2. http://www.scribd.com/doc/101830961/GPIO-Pads-Control2
  3. http://www.thebox.myzen.co.uk/Raspberry/Understanding_Outputs.html
  4. http://www.raspberrypi.org/wp-content/uploads/2012/02/BCM2835-ARM-Peripherals.pdf (DS del SoC)
  5. FidoCadJ