In questi ultimi mesi sono stato occupato in un progetto che sto portando avanti con alcuni amici: lanciare un pallone sonda nella stratosfera (a oltre 38km di altutudine).
Sebbene non sia un progetto nuovo a livello mondiale, e nemmeno in italia (vedi il progetto Stratospera), crediamo vi sia una novità rispetto ad altri progetti simili.
In primo luogo il progetto è interamente Open Source, sia per quanto riguarda l’hardware che per quanto riguarda il software: ogni aspetto che man mano verrà fuori, sarà pubblicato sul sito ufficiale.
In secondo luogo, il “computer di bordo”, è realizzato interamente con Arduino, che si occuperà quindi della gestione della posizione, dei dati meteorologici, del datalogging, di una parte di comunicazione, e della gestione del “cut-off” di emergenza. Android si occuperà prevalentemente invece della gestione della posizione e dell’invio tramite rete cellulare dei dati in tempo reale (ovviamente quando sarà sotto copertura di rete, cioè realisticamente fino a 5-6km di altitudine).
Come terza novità c’è in previsione, non dal primo lancio ovviamente, la possibilità di recuperare il payload (contenente tutta l’attrezzatura elettronica), tramite un drone aliante, che dovrebbe autonomamente riportare il tutto al punto di lancio…
Dal punto di vista dello studio di fattibilità abbiamo finito, stiamo elaborando in questo momento il software per Arduino, e stiamo procedendo alla richiesta delle varie autorizzazioni, nonchè ad una raccolta fondi per le varie spese…
Siamo alla ricerca anche di persone che vogliano contribuire al progetto, non solo economicamente ma anche umanamente al progetto.
Inoltre se qualche azienda volesse sponsorizzarci con del materiale che può servire al progetto, saremo ben lieti.
Vi terrò aggiornati!!!
Ed ora un’altro interessante progettino.
Dopo aver visto vari progetti in rete, soprattutto basati sui microcontroller PIC, ho deciso di realizzare un caricabatterie per batterie NiMh gestito da un’Attiny85.
Per quale motivo, penserà qualcuno, serve un microcontrollore per gestire la carica di una batteria. La risposta è molto semplice… La maggior parte dei caricabatterie economici che ci sono in commercio, regolano la carica basandosi su un timer, cioè se devo caricare una batteria da 2500mAh, forniscono una corrente di carica ad esempio di 250mAh, continuando la carica per ad esempio 14 ore (una parte dell’energia se ne va a quel paese, 10 ore non sarebbero sufficienti).
Questo modo di caricare le batterie al Nichel (Mh o Cd), non è tanto funzionale. In primo luogo è un processo lento, e poi non garantisce la corretta carica precisa al 100% delle celle, oltre a presentare rischi di sovrraccarica.
I caricabatterie di tipo “smart” in commercio invece, caricano le batterie correttamente, ma oltre ad essere abbastanza costosi, hanno solitamente correnti di carica non elevatissime, con tempi quindi non sempre sopportabili.
Da qui, oltre che la curiosità e la voglia di creare qualcosa di mio, nasce questo progetto…
Ma andiamo con ordine, e cominciamo con il il video che mostra il progetto finito ed in funzione:
Cerchiamo ora di capire un’attimo il funzionamento.
Innanzitutto le batterie al Nichel necessitano di una corrente costante per essere caricate correttamente. In questo caso si è utilizzato un generatore di corrente costante basato su transistor, derivato da quello che abbiamo visto in un post precedente, e fin qui niente di particolare, ma come facciamo a capire quando la batteria è carica?
Dobbiamo leggere continuamente la tensione della batteria sotto carica, e quando questa presenterà dopo un picco massimo di tensione, una discesa repentina di circa 20mv, la batteria potrà considerarsi carica. Tale fenomeno (chiamato Negative Delta V) è legato alla chimica di questa tipologia di batteria, e permette di stabilire con precisione il momento corretto per terminare la carica.
Vediamo quindi lo schema del circuito:
Lo schema è abbastanza semplice. Il transistor dalington Q1 (TIP127), tramite il LED1 (che deve essere assolutamente ROSSO) e la resistenza R3 da 0,3Ω, crea una corrente costante che scorre in direzione della batteria a 6 celle (7.2V), mentre il diodo Schottky 1N5822 da 3A, serve per proteggere tutto il circuito nel caso che venga a mancare la tensione di ingresso con la batteria connessa. Il partitore di tensione R4-R5, serve per portare alla porta 7 dell’Attiny (A1) il voltaggio della batteria diminuito a circa 1/3, in maniera tale che possa funzionare con tensioni sino a 15V (l’ingresso analogico dell’Attiny non può superare i 5V). Il transistor Q2, pilotato dalla porta 5 dell’Attiny (D0), serve come interrutore per attivare o disattivare il LED1 e il transistor Q1. E’ fondamentale che il LED sia ROSSO, e questo non per una questione di estetica, ma perchè la potenza uscita è data dal rapporto tra la tensione del LED (nei led rossi è di circa 1,8-2,2V) e la resistenza R3. Usando un LED verde, la tensione di riferimento si alza, e di conseguenza anche la corrente si alza (e non di poco).
Il circuito così fornito, può erogare circa 1,5-2,5A, dovete eventualmente fare un po’ di prove con vari tipi di LED rosso, oppure variare la resistenza, che deve essere da 2W. Nel caso non abbiate a disposizione o non riusciate a trovare resistenze di valori così bassi, potete utilizzare 3 o 4 resistenze da 1Ω in parallelo.
Altra cosa da tenere in conto, è la potenza dissipata dal TIP127, che può arrivare anche a 20Watt (dipende dalla corrente e dalla differenza di tensione tra l’ingresso e la batteria), quindi va montato un dissipatore adeguato. Nel mio caso ho usato il case di alluminio che risulta essere sufficiente.
Ultimo appunto è il voltaggio di ingresso, che non deve essere troppo alto altrimenti si rischia di far bruciare il transistor, ma non deve essere nemmeno troppo basso, perchè altrimenti il dropout indotto dai vari componenti fa scendere troppo la corrente di carica. Consiglio all’incirca una differenza di circa 5V tra la tensione di ingresso ed il valore nominale della batteria. Ad esempio con 6 celle, il voltaggio consigliato è di 12,2V (va bene anche 12). Ovviamente si possono caricare anche meno celle, regolando opportunamente la tensione in ingresso. Per una cella, dovremmo alimentare il tutto con una tensione di circa 1,2+5 = 6,2V (va bene anche 6 o 7).
Vediamo ora il circuito stampato:
Da notare le due chicche che non erano visibili nello schema. Il connettore ICSP (quindi la possibilità di aggiornare il firmware sull’Attiny (via programmatore ad esempio UsbTinyISP), e il connettore debug, da collegare ad un convertitore TTL per potere leggere il voltaggio della batteria durante la carica.
Il connettore J1 invece è un jumper che deve essere sempre chiuso, tranne quando aggiorniamo il firmware dell’Attiny85.
A proposito di firmware… Il codice sorgente del firmware è il seguente:
/*
NiMh Charger 0.9
con AtTiny85 @ 1Mhz
by Luca Soltoggio
10/03/2012 - 20/04/2012
Usa il -dT per determinare la fine carica.
Funziona con batteerie NiMh e NiCd.
I valori di default sono per pacchi da 6 celle e 2500mAh
Necessita di qualche aggiustamento hardware/software per parametri differenti.
Vedi https://arduinoelettronica.wordpress.com/
*/
const int inputPin = A1;
const int outputPin = 0;
const int numReadings = 30; // numero di letture analogiche prima di fare il check della batteria
const int multi = 1614; // coefficiente di moltiplica per ottenere il voltaggio corretto dall'analogread
long interval = 1000; // intevallo del pulse charge - non modificare
long interval2 = 250; // intervalle pulse off - modificabile. Utlizzare 100 per 2-4Ah, 500 per 1-2Ah
long interval2b=interval2;
long previousMillis,currentMillis,currentMillis2,trickleMillis = 0;
unsigned int readingtemp;
unsigned int total = 0;
unsigned int average,medium,maxmedium = 0;
boolean executed,endcharge,trickle=false; // variabili di controllo
unsigned int myarray [7]; // arrray che memorizza le ultime 7 letture
int index,i = 0;
void setup()
{
Serial.begin(9600);
pinMode(0,OUTPUT);
// Alcune letture per un controllo iniziale
for (i=0;i<10;i++) {
readingtemp = analogRead(inputPin);
total=total+readingtemp;
}
average = (((float)total / 1023.0) * (float)multi) / 10.0 + 0.5;
if (average<=70) endcharge=true; // Se la batteria non è presente, termina la carica
Serial.println(average);
total=0;
average=0;
}
void pusharray() {
// push dell'array
for (i=0;i<=5;++i) {
myarray[i]=myarray[i+1];
}
myarray[6]=average;
}
void voltread() {
readingtemp = analogRead(inputPin); // legge l'input analogico
total= total + readingtemp;
index++;
// se è stato raggiunto "numReadings" calcola la media
if (index==numReadings) {
index=0;
average = (((float)total / 1023.0) * (float)multi) / numReadings + 0.5;
if (average<=70) endcharge=true; // termina la carica se la batteria viene scollegata
total=0;
pusharray(); // inserisce la nuova media nell'array
// calcola la media delle ultime 7 letture
medium=(float)(myarray[6]+myarray[5]+myarray[4]+myarray[3]+myarray[2]+myarray[1]+myarray[0])/7.0+0.5;
if (medium>maxmedium) maxmedium=medium; // salva il valore della media più alta in "maxmedium"
Serial.print(medium);
Serial.print(",");
Serial.print(maxmedium);
Serial.print(",");
Serial.println(myarray[6]);
// se la batteria è carica (la media dei voltaggi è scesa di 0.02v), ma non nei primi 11 minuti
if ( ((medium+1) < maxmedium) && ((millis()/60000)>=11) ) {
if (!trickle) trickleMillis=millis(); // parte il timer per la "trickle charge" finale
trickle=true; // parte la "trickle charge" finale
// se la batteria si è caricata nei primi 15 minuti, non utilizzare la "trickle charge" finale
// (probabilmente la batteria era già carica)
if ((millis()/60000)<=15) endcharge=true;
}
}
}
void loop() {
currentMillis = millis();
// esegui ogni "interval" millis
if(currentMillis - previousMillis > interval) {
voltread(); // chiama la funzione di lettura e controllo
digitalWrite(outputPin,LOW); // ferma temporaneamente la carica
previousMillis = currentMillis;
executed=false; // variabile per controlloare se è già stata riattivata la carica
// nei primi 10 minuti e negli utlimi 15 minuti effettua una "trickle charge"
// (modifica il tempo di OFF)
if ( ( (trickle) && (((millis()-trickleMillis)/60000)<15) ) || ((millis()/60000)<10) ) {
interval2=(interval-(interval-interval2b)/5);
// dopo la carica iniziale ripristina il valore corretto di interval2
} else if ((millis()/60000)>=10) interval2=interval2b;
// alla fine dell'ultima "trickle charge" termina la carica
if ( (trickle) && (((millis()-trickleMillis)/60000)>=15) ) endcharge=true;
}
currentMillis2 = millis();
// esegui "interval2" millis dopo aver fermato la carica
if ((currentMillis2 - previousMillis > interval2) && (!executed)) {
executed=true;
if (!endcharge) {
digitalWrite(outputPin,HIGH); // se la batteria non è carica, riabilita la carica
}
}
}
Finalmente dopo una lunga assenza, in cui ero immerso nella realizzazione finale di questo mio progetto, CE L’HO FATTA!!!
Dopo mesi di progettazione, studi, ricerche e ostacoli vari, la RGB LED Lamp 1.0 by Toggio è realtà.
Posto subito il video che mostra il risultato definitivo ottenuto:
Ed ora una breve cronistoria.
Una delle cose che mi ha attirato di più quando ho sentito parlare di Arduino, era la luce, e in particolar modo ho sempre avuto il sogno di realizzare una lampada a LED RGB.
Niente di difficile, si potrebbe pensare… Solo che lungo questo percorso ho trovato diversi ostacoli.
Innanzitutto non ho trovato progetti completi in rete… Si trova qualcosa, ma, a mio avviso, con algoritmi fatti male, con poche spiegazioni, con metodi elaborati.
Io volevo una cosa semplice da regalare alla persona che amo e che mi ha dato una bellissima figlia…
Volevo qualcosa che avesse una luce abbastanza potente, senza però scaldare troppo. Volevo qualcosa che avesse la possibilità di scegliere il colore e non una semplice “color cycler”. Volevo qualcosa che fungesse anche da lampada standard. Ed infine volevo qualcosa che fosse modulare e upgradabile in futuro.
Dopo queste riflessioni, ho cominciato a studiare innanzitutto l’hardware. Non volevo usare l’Arduino UNO perchè mi sembrava eccessivamente grande per il mio progetto. Ho deciso quindi (e qui si potrebbe aprire un’enorme parentesi) di utilizzare una board non tanto diffusa ma a mio avviso eccezionale (tant’è che ne ho comprate 4 o 5): la Arduino Mini Pro.
(Resta inteso che nel progetto di questo post, può essere tranquillamente sostituita con una UNO o qualsiasi altra Arduino board.)
E’ una board estremamente piccola (18mm x 33mm), compatibile al 100% con Arduino Dumilanove, e a basso consumo. Esiste in quattro versioni: con Atmega328 a 3.3V e 5V e con Atmega168 a 3.3 e 5V.
Ho quindi optato per questo progetto per la versione a 5V con Atmega168. In definitiva si tratta di una soluzione molto economica (costa circa la metà dell’Arduino UNO), alquanto compatta e bella da vedere.
Ho poi pensato di utilizzare delle comodissime Strip LED RGB, che offrono numerosi vantaggi rispetto ad utilizzare led di potenza a 1W o a 3W: non scaldano, si alimentano a 12V e offrono una potenza fino a 13-14W per metro lineare.
Ogni canale può essere alimentato da un’uscita PWM di Arduino tramite un semplice transistor (nel mio caso ho usato dei BC337, ma per potenze superiori si possono usare altri transistor o addirittura dei Mosfet).
Ho quindi provveduto a costruire una specie di shield per la mia board. In pratica ho realizzato un circuito in cui la Arduino Mini Pro possa inserirsi con dei connettori strip ed essere eventualmente rimossa per aggiornare il firmware. Il tutto è stato progettato con Fritzing e realizzato da Fritzing Fab.
Il risultato finale del circuito stampato è il seguente:
Si possono notare le due file di fori dove andrà montata la Mini Pro… Praticamente è una shield al contrario 🙂
Ma facciamo un passo indietro e vediamo lo schema di circuito:
Spero sia abbastanza chiaro anche se non l’ho disegnato proprio benissimo!
In ogni caso il funzionamento è il seguente: I due potenziometri da 10k posti tra i +5V e la massa, sono i due input analogici che permettono di regolare la luminosità e altri parametri stabiliti dal software. Il deviatore a 3 posizioni SW2, permette di selezionare tre funzioni diverse per la lampada. Le uscite digitali 3,5,6 vanno a pilotare tramite un resistore i 3 transistori BC337 che andranno a dare corrente alle 3 uscite negative R,G,B della striscia a LED. Il positivo comune va ai +12V, mentre l’Arduino è alimentato tramite porta RAW (ingresso da 7V a 13V) tramite un diodo che oltre a fornire protezione da eventuale inversione di polarità, abbassa leggermente la tensione. SW1 è semplicemente il ponte dove andrà collegato un normalissimo interuttore di accensione.
Una volta saldati i vari componenti, connettori e potenziometri, montato il circuito, incapsulata la board Arduino, e montato il tutto dentro una scatola da elettricista, il risultato è quello della foto seguente:
La dimensione della scatola è di circa 10cmx10cmx7cm.
Per la parte superiore, ho utilizzato circa 70cm di striscia led RGB, per una potenza totale di circa 10W. Per farla stare tutta l’ho arrotolata intorno al perno di supporto di una campana da CD. Ho tagliato con un taglierino tale perno e l’ho incollato con dei distanziatori sopra la scatola. Ho poi incollato con della colla a caldo la striscia a led avvolgendola sul perno… Insomma un lavoro un po’ artigianale ma il risultato alla fine è il seguente:
Il vetro che si vede sulla scrivania leggermente spostato rispetto alla lampada, è il pezzo finale che manca: la copertura in vetro di una lampada IKEA, opportunamente fatta tagliare da un vetraio locale, affinché rimanga vuota sui due lati. Questa coperturà verrà infine appoggiata sopra la scatola da elettricista ed incollata, ottenendo il seguento risultato:
Mica male vero?
Ovviamente manca ancora la ciliegina sulla torta, una parte non meno importante: il software.
Il codice autoesplicativo è il seguente:
/*
RGB Led Lamp 1.0a
by Luca Soltoggio
15/03/2012
https://arduinoelettronica.wordpress.com/
*/
int rpin = 3; // pin RED
int gpin = 5; // pin GREEN
int bpin = 6; // pin BLU
unsigned int r=0, g=0, b=0,bm=0; // valori rgb e coefficiente divisore del blu
unsigned int valh=0, vals=0, valv=0; // hue, saturation, value
unsigned int sensorValue; // variabile che memorizza il valore dei potenziometri
const int analogInPin = A0; // pin dei potenziometri
const int analogInPin2 = A1;
const int digitalInPin = 10; // pin del deviatore
const int digitalInPin2= 11;
int red[]={255,255,135}; // array con i valori RGB della funzione "Bianco"
int green[]={157,255,158};
int blue[]={51,255,255};
boolean DIG1, DIG2;
long previousMillis = 0;
int i=0,j=0;
int dl=0; // delay
void setup()
{
pinMode(digitalInPin,INPUT);
pinMode(digitalInPin2,INPUT);
}
void loop()
{
DIG1=digitalRead(digitalInPin);
DIG2=digitalRead(digitalInPin2);
if (DIG1) {
bm=1.1;
HSV_Game();
}
else if (DIG2) {
bm=1.9;
RAINBOW_Game();
}
else {
bm=2.4;
LIGHT_Game();
}
analogWrite(rpin, r/1.09); // ROSSO
analogWrite(gpin, g/1); // VERDE
analogWrite(bpin, b/bm); // BLUE
}
// funzione di armonizzazione dei valori analogici tramite media aritmetica
int SensorSmooth (int pin) {
sensorValue=0;
for (int i = 0; i<10; i++) { sensorValue+= analogRead(pin); } return int ((float)sensorValue/10+0.5); } // prima funzione: selezione del colore e della luminosità tramite potenziometri void HSV_Game() { valh = SensorSmooth(analogInPin); vals = 255; valv = SensorSmooth(analogInPin2); valh = map(valh,0,1023,0,359); valv = map(valv,0,1023,32,255); hsv2rgb(valh,vals,valv,r,g,b); } // seconda funzione: selezione di bianco caldo, bianco neutro e bianco freddo, oltre alla luminosità void LIGHT_Game() { valv = SensorSmooth(analogInPin2); valv = map(valv,0,1023,16,255); valh = SensorSmooth(analogInPin); if (valh=742) valh=2; if (valh>2) valh=1;
r=red[valh]*valv/255;
g=green[valh]*valv/255;
b=blue[valh]*valv/255;
}
// terza funzione: selezione della velocità di rotazione tra tutti i colori e della luminosità
void RAINBOW_Game() {
dl = SensorSmooth(analogInPin); // tempo di pausa
dl = map(dl,0,1023,1,100);
valv = SensorSmooth(analogInPin2);
valv = map(valv,0,1023,64,255);
unsigned long currentMillis = millis();
switch (j) {
case 0:
r=255*valv/255;
g=i*valv/255;
b=0*valv/255;
break;
case 1:
r=(255-i)*valv/255;
g=255*valv/255;
b=0*valv/255;
break;
case 2:
r=0*valv/255;
g=255*valv/255;
b=i*valv/255;
break;
case 3:
r=0*valv/255;
g=(255-i)*valv/255;
b=255*valv/255;
break;
case 4:
r=i*valv/255;
g=0*valv/255;
b=255*valv/255;
break;
case 5:
r=255*valv/255;
g=0*valv/255;
b=(255-i)*valv/255;
}
if (currentMillis-previousMillis > (long)(100-dl)) { // usa millis invece che delay
previousMillis=currentMillis;
i=i+1;
if (i==256) {
i=1;
j=j+1;
if (j==6) j=0;
}
}
}
/* Funzione che trasforma HSV in RGB
(c) Elco Jacobs, E-atelier Industrial Design TU/e, July 2011
http://code.google.com/p/shiftpwm/source/browse/trunk/examples/ShiftPWM_Example1/hsv2rgb.cpp?r=3
*/
void hsv2rgb(int hue, int sat, int val, unsigned int& r, unsigned int& g, unsigned int& b)
{
int H_accent = hue/60;
int bottom = ((255 - sat) * val)>>8;
int top = val;
int rising = ((top-bottom) *(hue%60 ) ) / 60 + bottom;
int falling = ((top-bottom) *(60-hue%60) ) / 60 + bottom;
switch(H_accent) {
case 0:
r = top;
g = rising;
b = bottom;
break;
case 1:
r = falling;
g = top;
b = bottom;
break;
case 2:
r = bottom;
g = top;
b = rising;
break;
case 3:
r = bottom;
g = falling;
b = top;
break;
case 4:
r = rising;
g = bottom;
b = top;
break;
case 5:
r = top;
g = bottom;
b = falling;
break;
}
}
Ecco qui un semplice inseguitore solare, realizzato con Arduino…
E’ solo una bozza, uno spunto da migliorare per creare nuovi progetti.
L’idea è molto semplice. Utilizzando due fotoresistenze (LDR), una che punta leggermente verso destra e l’altra leggermente verso sinistra, andiamo a leggerne i valori e muoviamo un servo a rotazione continua nella direzione della fotoresistenza che riceve più luce, finchè la luminosità non è circa uguale.
Il risultato finale è quello che vediamo nel seguente video:
Come potete vedere ho utilizzato Arduino Mini Pro come piattaforma, ma non cambia assolutamente nulla rispetto all’utlizzo con Arduino UNO. L’unica differenza è che nell’alimentare l’Arduino Pro Mini ho dovuto usare un regolatore esterno, perchè quello interno non è sufficiente per pilotare il servo.
Ma veniamo all’elenco dei materiali necessari:
1 – Una board Arduino UNO (o Duemilanove o qualsiasi altra board compatibile)
2 – Due fotoresistenze LDR da 20K (eventualmente con pochi aggiustamenti possono andare bene anche di altri valori)
3 – Due resistenze da 4.7K (eventualmente con condizione di luce differenti si possono usare valori differenti)
4 – Un servo a rotazione continua. (Difficili e/o costosi da trovare, ho modificato un servo standard seguendo le indicazioni che trovate a uno di questo link (http://www.gioblu.com/tutorials/azionamenti/188-modifica-rotazione-continua-microservi oppure http://robodroid.wordpress.com/2011/12/29/micro-servo-a-rotazione-continua/ oppure ancora http://www.robot-italy.com/article_info.php?articles_id=1)
5 – Una batteria da 9V, una breadboard, dei supporti di plastica e poco altro
I componenti vanno collegati nel seguente modo ad Arduino:
/*
ISArduino 0.1
Inseguitore Solare con Arduino
by Luca Soltoggio - 2012
https://arduinoelettronica.wordpress.com
*/
#include <Servo.h>
#include <Narcoleptic.h>
/*
Libreria che permette di mandare in standby il microcontrollore
nei momenti di inattività (delay), risparmiando parecchia energia.
Si può eventualmente anche non utilizzare (in tal caso va sostituita
l'ultima istruzione Narcoleptic.delay(15) con delay(15).
*/
Servo myservo;
int Value;
int Center=105;
/*
La variabile Center rappresenta il valore di centratatura
del servo a rotazione continua. Nel mio caso è 105, di solito è 90.
Con questo valore il servo deve restare fermo.
*/
void setup() {
Serial.begin(9600);
myservo.attach(9); // Collega il servo al PIN 9
}
void loop() {
int sensorValue = analogRead(A0); // Legge il valore del sensore LDR di sinistra
int sensorValue2 = analogRead(A1); // Legge il valore del sensore LDR di destra
Value=(sensorValue-sensorValue2)/10;
/*
Calcola la differenza tra i due sensori e li divide per 10,
in questo modo una differenza di 10 equivale a 1, una differenza
di 53 equivale a 5 e cosi via
*/
if (Value==0) myservo.detach(); else myservo.attach(9);
/*
Se la differenza è uguale a 0 scollega il servo altrimenti lo
collega (serve per risparmiare energia)
*/
if (Value>10) Value=10;
if (Value<-10) Value=-10;
/*
Limita la differenza massima tra -10 e + 10
(per evitare una velocità eccessiva)
*/
Serial.println(Value); // Debug - Visualizza il valore sulla seriale
myservo.write(Center+Value);
/*
Se il valore di Value è positivo, sposta il Servo a DX, se è negativo a SX.
La velocità è direttamente proporzionale al valore assoluto di Value
*/
Narcoleptic.delay(15);
/*
Invece che usare un semplice delay, usiamo questo, così risparmiamo energia.
Si può eventualmente sostituire con delay(15).
*/
}