Tavolo zero (renzo)

Da raspibo.
Jump to navigation Jump to search

Benvenuti al tavolo zero.

Zero come "qui si parte da zero".

Non sapete qualcosa? Benevenuti al tavolo zero.

E' come un Coder Dojo dove si fanno esperimenti di Making, ci sono esempi/tutorial ma poi fate cio' che volete... ma fate voi!

Novità! c'è una mailing list! tavolozero at liste.raspibo.org

Attività per la sera del 28 gennaio

Attività per la sera del 12 novembre

Esercizi proposti da Renzo:

0- installare VNC

1- accendere 'sto solito led (in bash, C e python)

2- creare un termostato o un crepuscolare.

per partecipare al gioco occorre:

  • un portatile
  • un cavo di rete (*)
  • un raspberry pi con alimentatore
  • una SD card possibilmente con rasbian precaricato
  • una breadboard (*)
  • un cavo di collegamento raspi-breadboard (*)
  • una resistenza da circa 270 ohm (*)
  • un transistor BC547 (*)
  • una resistenza da circa 1Kohm (*)
  • un diodo 1N4007 (*)
  • un relais (*)
  • un termometro ds18b10 (*)
  • un sensore di luminosita' (*)

Almeno una istanza di ogni oggetto contrassegnato con (*) la portero' io

(aggiungete please ulteriori esercizi proposti da voi)

Devo inserire qui gli esercizi ?

Unità UNO: [Misure ADC su JeeNode]

Obiettivi:
  • Usare il JeeNode come ADC (Analog to Digital Converter);
  • Verificare la corrispondenza tra Tensione in uscita da un Trimmer e valore Digitale;
  • Trasferire i dati letti da JeeNode su RaspberryPi attraverso la porta USB;
Prerequisiti:  

Strumenti :
  • Un Pc con l'IDE di Arduino Installato
  • Un JeeNode (o un Arduino)
  • Un Trimmer o un Potenziometro;
Primo Passo:

Caricare su JeeNode (o su Arduino) con l'IDE il seguente programma: 

const int PinPot = 14;  // AIO1 di JeeNode | 14 è la numerazione Arduino
float Vbit = 3.3/1024;  // il convertitore (Jee) lavora a 10 bit e a 3.3 Volt
int ValPot=0;           // variabile che legge la tensione su AIO1
void setup() {                
 Serial.begin(9600);
 while(!Serial);
 pinMode(PinPot, INPUT);  
}
void loop() {
   ValPot=analogRead(PinPot);  // legge valore ADC dal pin 14
   /* Mostra valore digitale e tensione
      su Monitor Arduino | più esattamente spedisce su USB */
   Serial.print("Valore Digitale: ");
   Serial.print(ValPot);
   Serial.print(" | Tensione=");
   Serial.println(ValPot*Vbit);
   // attende 2 secondi 
   delay(2000);
}

Secondo passo:

Realizzare sulla Port1 del JeeNode il seguente circuito con un trimmer da 10 kohm

Jee Trimmer.png

Provare il programma aprendo il monitor seriale di Arduino. Si dovrebbe notare quanto segue: Ruotando il trimmer se questo giunge ad un estremo, AIO1=GND si leggerà 0 digitale e 0 di tensione e ruotando in direzione opposta cresce fino all'altro estremo AIO=3.3volt, e si leggerà 1023 per una tensione di 3.3 Volt.

Esiste una proporzionalità diretta tra tensione sul pin AIO1 e valore digitale letto: 

3.3(Volt) : 1024  =   Vx(volt) : N_Dig  segue → Vx= 3.3 * N_Dig/1024

Jee Trimmer sch.png 

Terzo Passo:

Collegare con un Cavetto il JeeNode (così programmato) ad una delle porte USB di RASPY. Eseguire i seguenti comandi per installare il software (pyton-serial) se necessario su Raspy: 

pi@raspy$ sudo apt-get -u install python-serial

Scrivere con un editor qualsiasi il seguente programma python e salvarlo: 

pi@raspy$ nano ardu_adc.py

import serial
arduino=serial.Serial('/dev/ttyUSB0')
while 1:
    print arduino.readline()

Eseguire il programma: 

pi@raspy$ python ardu_adc.py

Se non ci sono errori e la USB è la /dev/ttyUSB0, sul monitor compariranno i valori che in precedenza mostrava il monitor di Arduino con il trimmer agli estremi.

Jee Trimmer raspy.png

E' evidente che manipolando opportunamente i valori ricevuti si potranno memorizzare o pubblicare i dati di qualsiasi misura.

Nota: Il codice caricato su JeeNode è a tutti gli effetti un codice Arduino e di conseguenza si potrebbe ottenere lo stesso risultato usando un Arduino al posto di JeeNode.

Unità DUE: [Misura ADC e Allarme LED su JeeNode]

Obiettivi:
  • Usare tutte le potenzialità di JeeNode in particolare la libreria JeeLib.
  • Conoscere la corrispondenza tra i PIN Arduino e i PIN JeeNode.
  • Collegare un Trimmer e un LED di allarme al JeeNode
Prerequisiti:
  • Come nell'unità UNO;
  • Conoscenza di base di Linux RaspberryPi (download, unzip file, copia);
Strumenti :
  • Un Pc con l'IDE di Arduino Installato
  • Un JeeNode
  • Un Trimmer, un LED, un resistore da 330 ohm
Primo Passo:

Scaricare la libreria JeeLib in formato tar.gz se si usa IDE in linux o in formato zip se si usa IDE in windows. Scompattare, Rinominare JeeLib e Copiare la libreria nella directory ../Libraries di Arduino. Se tutto Ok nella cartella Esempi dell'IDE di Arduino dovrebbe comparire la libreria JeeLib ed i relitivi esempi. Per vedere la corrispondenza dei Pin Arduino e JeeNode vedi: 

Secondo Passo:

Scrivere e Caricare il primo codice per JeeNode usando le funzioni di JeeLib. 

// inclusione della libreria
#include <JeeLib.h>
// (*) Definisce un oggetto Port di identificatore 'Uno'. 
// Il parametro '1' indica che ci riferiamo alla PORT1 di JeeNode
// per le altre porte analogamente Port Mia (3) - indica la PORT3.
Port Uno (1); 
void setup() {
 Serial.begin(9600);
 while(!Serial);
 Uno.mode(OUTPUT);    // (*)attiva in output la prota DIO1 
 Uno.mode2(INPUT);    // (*)attiva in input la prota AIO1 
}
void loop() {
 word val;
 val = Uno.anaRead();      // (*) legge il valore analogico su AIO1
 Serial.print("\nValore digitale:");
 Serial.println(val);
 if ( val>512 ) {
   Uno.digiWrite(HIGH);   // (*) pone ALTO il pin DIO1
   delay(500);
   Uno.digiWrite(LOW);    // (*) pone BASSO il pin DIO1
   delay(500);
 }
 delay(1000);
}

Nota: tutte le righe con (*) usano funzioni di JeeLib 

Terzo Passo:

Realizzare sul JeeNode il seguente circuito:

Jee Trimmer led.png

La Port1 ha le seguenti connessioni: 

AIO1 → pin centrale del Trimmer 10k
DIO1 → terminale positivo del LED
GND  → resistore da 470 ohm collegato al terminale negativo del LED

La Port2 (ha la sola funzione di alimentare il Trimmer): 

+    → alimentazione +3.3v del trimmer
GND  → massa del trimmer 

Quarto Passo:

Aprire il Monitor seriale di Arduino, dovrebbe comparire la scritta ciclica con valori digitali compresi tra 0 e 1023 a seconda della rotazione del trimmer:

Jee Trimmer led ser.png

Se la vite del Trimmer è oltre la metà corsa, segue che il valore Digitale vale più di 512 quindi il LED Lampeggia (Allarme). Se invece il valore digitale è minore di 512 il LED non si accende.

Unità TRE: [Misurare la Temperatura Ambiente con un NTC]

Obiettivi:
  • Usare un PIN ADC di JeeNode per misurare una temperatura.
  • Conoscere il funzionamento di un sensore NTC
  • Trasferire i dati via USB su un monitor di Raspy
  • Avviare lettura di T con Comando “trigger” inviato da Raspy (o PC) verso JeeNode
  • Memorizzare le misure su un File in Raspy o su PC linux
Prerequisiti:
  • Come nell'unità Due.
Strumenti :
  • Un Pc con l'IDE di Arduino Installato
  • Un JeeNode
  • Un sensore NTC, un resistore con R simile alla R nominale di NTC
Primo Passo:

Un sensore NTC (Negative Temperature Coefficient) è una resistenza molto sensibile alla variazione di temperatura. In particolare la resistenza ha un coefficiente negativo nel senso che la resistenza Diminuisce al Crescere della temperatura. La diminuzione di resistenza non è lineare ma decresce in modo esponenziale.

Ne consegue che non è possibile usare una semplice proporzione 'Tensione:Valore Digitale' per determinare la temperatura. I “manuali” consigliano di usare l'equazione di Stheinart per determinare la temperatura:

Vediamo come:

  • T è la temperatura in Kalvin misurata dal sensore
  • To è la temperatura ambiente nominale in Kalvin 25° = 298,5;
  • B è la costante caratteristica del Sensore NTC (Riportata nei fogli dati del sensore, di norma varia tra 3000 e 4000);
  • Ro è la resistenza di NTC a 25°;
  • Rt la resistenza di NTC all'istante t.
Secondo Passo:

Realizzare il seguente Circuito con il sensore NTC:

Nel circuito Ro=10000, Ri=10000 ohm, B=4000, To=298,5 → 25°

Il Pin ADC misura il valore digitale della caduta di tensione Vi ai capi di Ri indicata in figura con Dvi. Così la tensione Vcc corrisponde a Dvcc=1023 e la Vt corrisponde a Dvt=1023-Dvi. Si può scrivere la legge di ohm del partitore in figura usando i valori digitali al posto delle tensioni in volt. 

Vt/Vi=(1023-Dvi)/Dvi; 
dividendo Num e Den del 1° membro per I che attraversa il circuito si ottiene  
Rt/Ri=(1023-Dvi)/Dvi=1023/Dv1-1. 
Quindi Rt = Ri*(1023/Dvi -1)

Per realizzare l'algoritmo che calcola T si eseguiranno i seguenti passi: 

calcolo  Rt = Ri*(1023/Dvi -1)	// che coincide con   Rt 
calcolo   T = ln(Rt/Ro)	// T attuale è ln(Rt/Ro)
calcolo   T = T/B		// T attuale ln(Rt/Ro)/B
calcolo   T = 1/To +T		// T attuale è 1/T
finalmente T=1/T - 273.15;

Terzo Passo:

Codifica e Upload del firmware nel JeeNode: 

#include <JeeLib.h>
// Ro Resistenza nominale di NTC
#define NTC_NOMINALE 10000      
// B coefficiente NTC 
#define NTC_B 4000
// Ri Resistenza in Serie Inserita
#define NTC_SERIE 10000
// Numero di misure per calcolare la media Dvi
#define N_MISURE 5
// Utilizzo la Port1 AIO1
Port NTC (1);
void setup(void) {
  Serial.begin(9600);
  while(!Serial);
  NTC.mode2(INPUT);    // AIO1 è posto in INPUT
}
void loop(void) {
  uint8_t i;
  float Dvi=0;
  float Rt=0;
  // legge N campioni ed esegue la media
  for (i=0; i< N_MISURE; i++) {
    Dvi += NTC.anaRead();	   // esecuzione ADC
    delay(10);
  }
  Dvi=Dvi/N_MISURE;
  Serial.print("Dvi: "); 
  Serial.println(Dvi);
  // Determino Rt
  Rt = NTC_SERIE*(1023 / Dvi - 1);
  Serial.print("Rt "); 
  Serial.println(Rt);
  // determino T
  float T;
  T=log(Rt/NTC_NOMINALE);          // ln(R/Ro)
  T = T/NTC_B;                     // 1/B * ln(R/Ro)
  T = T + 1.0 / (298.15);          // (1/To) + 1/B * ln(R/Ro)
  T = 1.0 / T - 273.15;            // Inverto e sottraggo Kalvin
  Serial.print("Temperatura "); 
  Serial.print(T,1);
  Serial.println(" *C");
  delay(3000);
}

Se si esegue il programma sul monitor dell'IDE di Arduino comparirà qualcosa di simile a: 

Quarto PASSO:

Semplifichiamo il programma e facciamo inviare, via seriale, da Raspy verso JeeNode un Carattere di 'Trigger' che avvia l'esecuzione della misurazione di T. Quindi da JeeNode inviamo a Raspy solo la temperatura T Misurata. Questo è il nuovo programma JeeNode avviato con un “trigger” Seriale. 

#include <JeeLib.h>
// Stesso codice precedente
// fino a loop()
// .... 
void loop(void) {
  uint8_t i;
  float Dvi=0;
  float Rt=0;
  int N=Serial.available();	
  // se arrivano uno o più caratteri di 'trigger'
  // da Monitor seriale o da RASPY 
  // vengono avviate le misure
  if (N>0) {																		
   while (N>0) {Serial.read();N--;}		// svuota il buffer
   delay(500);
   // legge N campioni ed esegue la media
   for (i=0; i< N_MISURE; i++) {
     Dvi += NTC.anaRead();
     delay(10);
  }
  Dvi=Dvi/N_MISURE;
  // Determino Rt
  Rt = NTC_SERIE*(1023 / Dvi - 1);
  // determino T
  float T;
  T=log(Rt/NTC_NOMINALE);          // ln(R/Ro)
  T = T/NTC_B;                     // 1/B * ln(R/Ro)
  T = T + 1.0 / (298.15);          // (1/To) + 1/B * ln(R/Ro)
  T = 1.0 / T - 273.15;            // Inverto e sottraggo Kalvin
  Serial.print(T,1);		    // T inviata è un float con un solo decimale
 }
 delay(500);
}

Si può provare il programma dal monitor seriale di Arduino: Se nel campo di Invio si inserisce un carattere qualsiasi e si preme Invia (trigger) si ottiene la misura di T come segue: 

Quinto Passo:

Collegare con un Cavetto il JeeNode (così programmato) ad una delle porte USB di RASPY.

Scrivere con un editor qualsiasi il seguente programma python e salvarlo: 

pi@raspy$ nano ardu_ADC_Dati.py

import time
from datetime import date
import serial
# intervallo di tempo tra le misure in secondi 
DSEC=60
# porta USB su cui avviene lo scambio tra Raspy e JeeNode
ser=serial.Serial('/dev/ttyUSB0', 9600)
TH=time.time()
print "Tra",DSEC,"secondi Misuro T"
while 1:
   # calcolo l'intervallo di tempo trascorso DT dall'avvio
   T1=time.time()
   DT=T1-TH
   # Memorizzo il tempo attuale
   Tattuale=time.strftime("%H:%M:%S")
   oggi=date.today()
   if (DT>=DSEC):	# se sono trascorsi DSEC effettua la misura
     TH=T1;
     # segnale di 'trigger' inviato da Raspi a JeeNode	
     ser.write("AA")
     ser.flushOutput()
     # legge su USB la misuta di 4 caratteri xx.x
     Temp=ser.read(4)
     # mostra a video i dati Temperatura – Data - Ora
     print (Temp);
     print oggi.strftime("%d/%m/%Y")
     print (Tattuale)
     print(' ')

Eseguire il programma: 

pi@raspy$ python ardu_adc_Dati.py

Se non ci sono errori e la USB è la /dev/ttyUSB0, sul monitor compariranno i valori . 

Sesto Passo:

Modificare il programma python per memorizzare i dati un file DATI.txt. Modificare il precedente programma python e salvarlo (le righe azzurre sono aggiunte al precedente programma): 

pi@raspy$ nano ardu_adc_File.py

import time
from datetime import date
import serial
# file in cui memorizzo dati
nome_file="DATI.txt"
#intervallo di tempo tra le misure in secondi
DSEC=60
#porta USB su cui avviene lo scabio tra Raspy e JeeNode
ser=serial.Serial('/dev/ttyUSB0', 9600)
TH=time.time()
print "Ogni",DSEC,"secondi misuro T")
# apre il file cancellando i dati precedenti
out_file=open(nome_file,"w")
while 1:
  # calcolo l'intervallo di tempo trascorso DT dall'avvio
  T1=time.time()
  DT=T1-TH
  # Memorizzo il tempo attuale
  Tattuale=time.strftime("%H:%M:%S")
  oggi=date.today()
  if (DT>=DSEC):  # se e' trascorso DSEC effettua la misura
      TH=T1;
      # apre il file in modalita' append
      out_file=open(nome_file,"a")
      # segnale di 'trigger' inviato da Raspi a JeeNode
      ser.write("AA")
      ser.flushOutput()
      # legge su USB la misuta di 4 caratteri xx.x
      Temp=ser.read(4)
      # mostra sul monitor
      print (Temp);
      print oggi.strftime("%d/%m/%Y")
      print (Tattuale)
      print(' ')
      # appende nel file
      out_file.write(oggi.strftime("%d/%m/%Y"))
      out_file.write(", ")
      out_file.write(Tattuale)
      out_file.write(", ")
      out_file.write(Temp)
      out_file.write("\n")
      out_file.close()

Per vedere il file generato eseguire il comando : 

pi@raspy  cat DATI.txt

a video comparirà:

Unità QUATTRO: [Trasmettere da un JeeNode Locale ad un JeeNode Remoto]

Obiettivi:
  • Usare i comandi JeeNode di trasmissione wireless
  • Conoscere le variabili che memorizzano lo stato delle Porte JeeNode
  • Visualizzare i valori caratteristici dei pin DIO, e AIO delle varie porte
Prerequisiti:
  • Come nell'unità Due.
Strumenti :
  • Un Pc con l'IDE di Arduino Installato
  • DUE JeeNode
  • Opzionale un LED.

In attesa di inserimento

Unità CINQUE: [Rice/Trasmettere tra due JeeNode]

Obiettivi:
  • Usare i comandi JeeNode di trasmissione wireless;
  • Usare una modalità di ricetrasmissione interattiva tra due nodi;
  • Apprendere come si scambiano Dati, diversi dal semplice stato dei Nodi
Prerequisiti:
  • quelli dell'Unità QUATTRO.
Strumenti :
  • Un Pc con l'IDE di Arduino Installato
  • DUE JeeNode
  • Un LED.

In attesa di inserimento

Unità SEI: [Pubblicare Misure di temperatura (NTC) sul Web]

Obiettivi:
  • Usare una modalità di ricetrasmissione interattiva tra due JeeNode;
  • Salvare i dati su File di Raspy;
  • Pubblicare i dati sul Web
Prerequisiti:
  • quelli dell'Unità CINQUE.
Strumenti :
  • Un Pc con l'IDE di Arduino Installato
  • DUE JeeNode (uno alimentabile con Pile)
  • Un sensore NTC con resistore.

In attesa di inserimento

Estratto da "https://www.raspibo.org/wiki/index.php?title=Tavolo_zero_(renzo)&oldid=2313"