sabato 22 settembre 2018

Sensore di livello pellet per stufe con arduino

Salve a tutti, oggi vorrei proporvi un semplice progetto per la creazione di un sensore di livello del pellet per le stufe che ne sono sprovviste, iniziamo subito.

Materiale occorrente

  • Arduino nano  Ebay
  • Sensore ad ultrasuoni HC-SR04  Ebay
  • Buzzer
  • Led bar 10 segmenti Ebay  

  • 4 batterie AA

Lo schema è molto semplice, di seguito un riassunto dei collegamenti

BUZZER +    -->    pin 6
BUZZER -     -->   gnd

HC-SR04 TRIGGER    -->    pin 3
HC-SR04 ECHO           -->    pin 4

Pulsante     -->    pin 2

Led bar CLK    -->    pin 11
Led bar DIO     -->    pin 12


Funzionamento

Per poter compilare il codice sono necessarie alcune librerie

TM1651    Per il funzionamento della barra led
NewPing   Per il funzionamento del sensore ad ultrasuoni
EEPROM  Libreria inclusa in Arduino usata per il salvataggio dei dati all' interno della eeprom

Il sensore è stato pensato per essere attaccato alla parete interna del coperchio del pellet.
Il pulsante serve per settare il livello minimo del pellet all' interno della stufa, premendo il pulsante per 5 secondi si entra nel "setup mode" viene emesso un segnale luminoso tramite la barra led ed acustico, da quando si entra nel setup si hanno 30 secondi (Variabile TempoAttesa) per chiudere il coperchio e lasciare che il sensore venga calibrato con il livello minimo di pellet all' interno del serbatoio.
Passati i 30 secondi viene emesso un nuovo segnale luminoso ed acustico ed il valore letto viene salvato nella eeprom di Arduino, a questo punto sulla barra led vedremo il livello del pellet, la barra piena indica il livello massimo la barra vuota indica che il serbatoio è vuoto.

Ecco il codice:
Il codice è abbastanza commentato ma per qualsiasi chiarimento non esitate a contattarmi.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
#include <TM1651.h>
#include <NewPing.h>
#include <EEPROM.h>

int MemoryAddress = 1;
int ValoreSalvato = 0;

#define PIN_PULSANTE  2
#define PIN_BUZZER  6
#define PIN_TRIGGER  3
#define PIN_ECHO 4

#define TM1651_CLK 12//pins definitions for TM1651 and can be changed to other ports       
#define TM1651_DIO 11

int PulsanteState = 0;

unsigned long MomentoPressione = 0;
boolean SetupMode = false;

//tempo di attesa per il savataggio del valore minimo del sensore
int TempoAttesa = 30000;

NewPing sonar(PIN_TRIGGER, PIN_ECHO,500);

TM1651 batteryDisplay(TM1651_CLK, TM1651_DIO);

void setup()
{
 /*Imposto i pin della scheda*/
 pinMode(PIN_PULSANTE, INPUT);
 pinMode(PIN_BUZZER, OUTPUT);
 
 batteryDisplay.init();

 /*Imposto la porta seriale*/
 Serial.begin(9600);
 batteryDisplay.set(2);//BRIGHT_TYPICAL = 2,BRIGHT_DARKEST = 0,BRIGHTEST = 7;
 batteryDisplay.displayLevel(7);
 /*Leggo dalla memoria non volatile il valore della cella di memoria
 dove viene salvato il valore della distanza dell' allarme*/
 /*Il valore viene salvato diviso 10 quindi il valore recuperato deve essere moltiplicato * 10 */
 ValoreSalvato = EEPROM.read(MemoryAddress)*10; 
}

void loop()
{
 Serial.println("..");
 /*Se sono in setup*/
 if (SetupMode == true) {
  /*Attendo n secondi per il posizionamento del sensore*/
  int attesa = TempoAttesa / 8;
  batteryDisplay.displayLevel(7);
  delay(attesa);
  batteryDisplay.displayLevel(6);
  delay(attesa);
  batteryDisplay.displayLevel(5);
  delay(attesa);
  batteryDisplay.displayLevel(4);
  delay(attesa);
  batteryDisplay.displayLevel(3);
  delay(attesa);
  batteryDisplay.displayLevel(2);
  delay(attesa);
  batteryDisplay.displayLevel(1);
  delay(attesa);
  batteryDisplay.displayLevel(0);
  delay(attesa);

  /*Leggo la distanza dal sensore ultrasonico e salvo il valore letto nella variabile ValoreSalvato 
  e salvo il valore nella memoria*/
  int Us = sonar.ping_median(10);
  Serial.print("Ping: ");
  ValoreSalvato = Us / US_ROUNDTRIP_CM;
  Serial.print(ValoreSalvato);
  Serial.println("cm");
  /*dato che la memoria si pu� scrivere solo 100000 volte mi assicuro che il valore di distanza letto sia utile*/
  /*il valore di una cella di memoria pu� contenere valori da 0 a 255, quindi salvo il valore di distanza / 10*/
  int DatoDaSalvare = ValoreSalvato / 10;

  if (DatoDaSalvare != 0) {
   EEPROM.write(MemoryAddress, DatoDaSalvare);
  }

  SetupMode = false;
  /*Emetto un segnale per la conferma della fine del SetupMode*/
  BuzzerSetupModeComplete();
 }

 PulsanteState = digitalRead(PIN_PULSANTE);
        
 Serial.println("Stato Pulsante: " + PulsanteState);

 /*Se premo il pulsante*/
 if (PulsanteState == HIGH) {
  /*Se il valore di MomentoPressione � = 0 devo impostare il time della pressione del pulsante*/
  if (MomentoPressione == 0) {
   MomentoPressione = millis();
   Serial.println("Momento Pressione " + MomentoPressione);
  }
  /*Se il pulsante � stato premuto per 5 secondi*/
  if (millis() - MomentoPressione >= 5000) {
   SetupMode = true;
   Serial.println("Pulsante Premuto per 5 secondi");
   /*Faccio un suono dal Buzzer*/
   BuzzerSetupMode();
   PulsanteState = 0;
  }
 }

 
 
    /*Leggo la distanza dal sensore Ultrasuoni, se la distanza � > del valore letto dalla memoria allora devo mandare un allarme*/
  int Us = sonar.ping_median(10);
  Serial.print("Ping: ");
  int Cm = Us / US_ROUNDTRIP_CM;
  Serial.print(Cm);
  Serial.println("cm");
  Serial.print("ValoreSalvato: ");
  Serial.println(ValoreSalvato,10);
  if (Cm > ValoreSalvato) {
   batteryDisplay.displayLevel(0);
   //digitalWrite(PIN_BUZZER, LOW);
   //digitalWrite(PIN_BUZZER, HIGH);
   //delay(250);
   //digitalWrite(PIN_BUZZER, LOW);
   //delay(250);
   //digitalWrite(PIN_BUZZER, HIGH);
   //delay(250);
   //digitalWrite(PIN_BUZZER, LOW);
                }
         else {
    int frazione = ValoreSalvato / 8;
    Serial.print("frazione: ");
    Serial.println(frazione, 10);
    int qLed = Cm / frazione;
    Serial.print("qLed: ");
    Serial.println(qLed, 10);
    if (qLed > 7)  qLed = 7 ;
    qLed = qLed - 7;
    qLed = abs(qLed);
    batteryDisplay.displayLevel(qLed);
   }
}

void BuzzerSetupMode() {
 digitalWrite(PIN_BUZZER, LOW);
 digitalWrite(PIN_BUZZER, HIGH);
 delay(500);
 digitalWrite(PIN_BUZZER, LOW);
 delay(200);
 digitalWrite(PIN_BUZZER, HIGH);
 delay(500);
 digitalWrite(PIN_BUZZER, LOW);
}

void BuzzerSetupModeComplete() {
 batteryDisplay.displayLevel(0);
 digitalWrite(PIN_BUZZER, LOW);
 digitalWrite(PIN_BUZZER, HIGH);
 batteryDisplay.displayLevel(7);
 delay(250);
 digitalWrite(PIN_BUZZER, LOW);
 batteryDisplay.displayLevel(0);
 delay(250);
 digitalWrite(PIN_BUZZER, HIGH);
 batteryDisplay.displayLevel(7);
 delay(250);
 digitalWrite(PIN_BUZZER, LOW);
 batteryDisplay.displayLevel(0);
 delay(250);
 digitalWrite(PIN_BUZZER, HIGH);
 batteryDisplay.displayLevel(7);
 delay(250);
 digitalWrite(PIN_BUZZER, LOW);
 batteryDisplay.displayLevel(0);
}

venerdì 17 marzo 2017

Waveshare LCD (C) 1024x600 con Windows 10 iot e RaspberryPi 3

Schermo LCD Waveshare (C) 1024x600 con Windows 10 iot e Raspberry pi 3


Premessa, ho un progetto che include Raspberry pi 3 ed uno schermo lcd con touchscreen, ho preso su Amazon questo schermo.
Tutto contento sono andato a collegarlo al Raspberry pi 3 con una SD contenente l' ultima relase pubblica di Windows 10 IOT (14393) e... sullo schermo non compare niente,
Cercando qualche soluzione sui vari forum ho scoperto che la risoluzione dello schermo non è compatibile, infatti nella dashboard di windows 10 iot alla voce risoluzione schermo non compare la risoluzione 1024x600.

Alla fine, dopo lunghe nottate a provare a far andare lo schermo sono riuscito nell' impresa, ecco i passi che ho eseguito.

  • Creare una SD con l' immagine di windows 10 iot
  • Inserite la micro Sd nel Raspberry
  • Al primo avvio, collegate uno schermo standard, e seguite la procedura di configurazione.
  • Terminata la procedura, collegatevi al Raspberry tramite il browser del computer al seguente indirizzo <ip raspberry>:8080
  • Nella dashboard andate nella prima schermata e modificate la risoluzione dello schermo a 1024x768, scollegate il monitor del computer e collegate lo schermo della Waveshare.
  • Riavviate la scheda.
  • Al riavvio dovreste riuscire a vedere il caricamento di windows, ma noterete che la schermata sembra tagliata data la risoluzione impostata più alta.
  • Una volta terminato l' avvio, spegnete la scheda.
  • Prendete la scheda SD ed inseritela nel computer.
  • Aprite il file config.txt dalla cartella EFIESP dovrebbe essere simile a questo

init_uart_clock=16000000
kernel_old=1
safe_mode_gpio=8
max_usb_current=1
gpu_mem=32
hdmi_force_hotplug=1
core_freq=250
framebuffer_ignore_alpha=1
framebuffer_swap=1
disable_overscan=1
hdmi_group=2
display_rotate=0
hdmi_mode=16
  • modificate il file inserendo la riga
overscan_bottom=168

Il risultato sarà questo


init_uart_clock=16000000
kernel_old=1
safe_mode_gpio=8
max_usb_current=1
gpu_mem=32
hdmi_force_hotplug=1
core_freq=250
framebuffer_ignore_alpha=1
framebuffer_swap=1
disable_overscan=1
overscan_bottom=168
hdmi_group=2
display_rotate=0
hdmi_mode=16

  • salvate il file.
  • Rimettete la scheda sd nel raspberry ed avviate, questa volta dovreste vedere tutta la schermata di caricamento,

lunedì 20 maggio 2013

Iniziano ad arrivare i pezzi

Oggi sono arrivati i primi acquisti...

Sono arrivati i pezzi in plastica dalla spagna

Le cinghie GT2 con le pulegge dall'inghilterra
L'hotend Bhead e la RAMPS da Pisa
I driver Pololu black edition con i dissipatori

Ho iniziato subito a montare e non ho fatto nessuna foto... peccato... ora sto aspettando i cuscinetti lineari che dovrebbero arrivare la settimana prossima insieme all'arduino mega

Ecco una foto della stampante a metà del lavoro...

giovedì 16 maggio 2013

Pezzi per stampante 3d

Continuano gli acquisti per il progetto stampante 3D.

Nel post precedente ho scritto che avevo acquistato un pò di componenti per la stampante 3D, dopo un pò di ricerche ho acquistato qualche altro pezzo:

HotEnd: questa è la parte principale della macchina, senza questo non è possibile stampare niente, infatti questo componente si occupa di fondere il filamento di materiale plastico e depositarlo sul piatto di stampa. Leggendo sul Google groups di RepRapItalia ho trovato un bel progetto il Bhead, questo è un hotend fatto da un utente italiano, vi linko il suo blog icanbuild.it, nonostante lo stato ancora un pò sperimentale del progetto ho deciso comunque di prenderlo, mi attirava la semplicità della costruzione e il sistema di fissaggio dell'estrusore vero e proprio, se lo contattate potete chiedergli tutte le informazioni che volete, è molto diponibile. Costo 50€

Ramps 1.4: Questa la pagina sul Wiki. La scheda di controllo della stampante l'ho presa sempre da Salvatore di icanbuild dato che su RepRapItalia avevo trovato un post dove scriveva che ne aveva fatte un pò. Costo 49€

Arduino Mega: questo non penso che abbia bisogno di spiegazioni, è il vero cervello della stampante, ne ho preso uno compatibile su Ebay Costo 21.89 compresa spedizione

Motori: ho trovato un' offerta su ebay per 5 motori passo passo NEMA17 tipo 42BYGHW811 a 68.98 compresa spedizione.

Nel frattempo sono arrivati solo i cuscinetti tipo 608ZZ dalla germania di cui avevo parlato nel post precedente.

Sono in trepidante attesa di tutto il resto.

Progetto Stampante 3D


Partiamo con un nuovo progetto: costruiamo una stampante 3D o RepRap.

L'idea è quella di costruire la mia prima stampante 3D e leggendo un pò qua un pò là ho optato per questo modello Prusa Mendel I2 mi è sembrato il più completo sotto il punto di vista della documentazione e della semplicità della costruzione.

Questo modello si compone di alcuni componenti in plastica (che quindi possono essere replicati dalla stampante da qui il nome RepRap) e di altri che devono essere acquistati, qui sotto una lista dei materiali necessari.

Questa lista di materiali è stata presa dal wiki RepRap.org

Parti stampate


Quantity   ↓STL file   ↓CommentsPicture
8bar-clamp.stl
3bearing-guide.stl2 for y axis idlers, 1 for x idler
4belt-clamp.stl
4belt-clamp-nut-holder.stl
2coupling.stlTwo parts are in one STL, print twice.
3endstop-holder.stl
2frame-vertex.stl
4frame-vertex-foot.stl
2rod-clamp.stl
1x-carriage.stlPictured part fits LM8UU bearings
1x-end-idler.stlPictured part fits LM8UU bearings
1x-end-motor.stlPictured part fits LM8UU bearings
1ybrac-t.stl
3y-bushing.stlPictured part fits LM8UU bearings
2z-motor-mount.stl
Questi i componenti stampati per il Wade's extruder 
QuantitySTL filePicture
1wade.stl
1wade-big.stl
1wade-small.stl

venerdì 3 maggio 2013

Arduino primi passi: Display LCD + MCP23017

Iniziamo, comincio a muovere i primi passi nel mondo Arduino, il mio primo progetto consiste nel far funzionare un display LCD HD44780 compatibile con soli due pin di Arduino.

Per fare questo devo ricorrere al sistema di comunicazione I2C e dato che non ho trovato nessuna info sul web per farlo ho deciso di scrivere questa pagina.

Per prima cosa vediamo l'occorrente per il progetto:

1x Arduino UNO
1x IC MCP23017
2x resistenza 4.7K ohm
1x resistenza 22 ohm

L' MCP23017 è un port-expander 16bit con interfaccia I2C come si vede dall'immagine del datasheet sono presenti 2 gruppi da 8 pin ciascuno.
A0-A1-A2 sono i pin per definire l'indirizzo


questo è lo schema


Sono necessarie due resistenze di Pull-up per il bus I2C io le ho messe da 4.7K
Il potenziometro serve per il contrasto io ne ho messo uno da 10K
La resistenza sul pin 15 del'LCD l'ho messa per abbassare un pò la tensione in ingresso alla retroilluminazione

Ed ecco la vista breadboard




da Arduino preleviamo i segnali SDA ed SCL rispettivamente i pin A4 ed A5 e li colleghiamo ai rispettivi pin del MCP23017.

Per interfacciare l'IC al display ho usato le librerie LiquidTWI2 leggendo la libreria ho trovato questo codice

//MCP23017 - Adafruit RGB LCD Shield
// bit pattern for the burstBits function is
//
//  B7 B6   B5  B4 B3 B2 B1 B0 A7 A6 A5 A4 A3 A2 A1 A0 - MCP23017 
//  RS RW EN D4 D5 D6 D7 B    G   R B4  B3  B2 B1 B0 
//  15 14 13 12 11 10 9  8  7  6  5  4  3  2  1  0  

Nella libreria è stato definito il codice per interfacciare la Adafruit RGB LCD shield, io non ho fatto altro che seguire i collegamenti segnati evitando di collegare i pin B0 A7 A6 del MCP23017 che nello shield sono collegati ai vari led della retroilluminazione.

Ed ecco una foto dello schermo funzionante






sabato 20 aprile 2013

Robot semiautonomo (Arduino-Raspberry Pi)

Da un pò sto guardando come creare qualcosa che si muove con un pò di programmazione e finalmente mi sono deciso a comprare qualcosa per crearlo.
Sto pensando ad un robot semiautonomo utilizzando Arduino e Raspberry pi, oggi ho comprato i primi componenti per realizzarlo, appena arrivano inizierò a fare qualche esperimento e terrò aggiornato questo blog tenendo una sorta di diario dei progressi che verranno.

Intanto vi lascio la lista della spesa:


In casa avevo gia l' Arduino UNO e mia sorella al mio compleanno mi ha regalato il Raspberry pi model B.

Non sto a spiegarvi cosa sia Arduino penso che sia già abbastanza famoso.

Il Raspberry pi invece si tratta di un computer completo, con CPU da 700 Mhz e 512 Mb di ram e dal costo molto contenuto circa 35€, sul sito del progetto potrete approfondire.