La scheda Multi-purpose Shield V1 codice KS1083 prodotta dalla Keyestudio è una scheda per l’apprendimento basata su Arduino. Non c’è bisogno di saldature o di eseguire collegamenti con cavi.
E’ sufficiente scaricare il programma demo o realizzare propri programmi, per completare i primi esperimenti.
Sullo shield sono presenti anche delle porte di estensione che aumentano il numero di esperimenti che possono essere eseguiti.
Indice
Principali caratteristiche
NOTA: la scheda è venduta da vari siti, anche senza logo e la si può trovare in rete con vari nomi , di seguito ne sono riportati alcuni:
- 9 in 1 sensor board Multifunction Expansion Board
- Multifunction Expansion Board DHT11 LM35 For Arduino
- Multifunction DHT11 LM35 Temperature Humidity Easy Module Shield for Arduino UNO
Il Multi-purpose Shield V1 è compatibile con le principali schede come UNO R3 e MEGA 2560. Sulla scheda troviamo:
- Due led, uno rosso e uno blu collegati alle porte D12 e D13 per mostrare lo stato del programma;
- Due pulsanti connessi alle porte D2 e D3;
- Sensore DHT11 per misurare la temperatura e l’umidità, connesso alla porta D4 (usa la libreria dht11.h )
- Potenziometro connesso all’ingresso analogico A0;
- Un buzzer passivo per allarme connesso alla porta D5;
- Un LED RGB a colori con resistenze limitatrici connesso alle porte D9, D10, D11;
- Una fotocellula per rilevare la luminosità della luce, connessa alla porta A1;
- Un sensore di temperatura LM35D, connesso alla porta A2;
- Ricevitore a infrarossi VS1838 per rilevare la funzione di ricezione IR con monitor rx Led1 (dati in=D6) (usa la libreria IRremote.h)
- 2 connettori a tre pin connessi alle porte digitali (D7 e D8)
- 1 connettore a tre pin connesso alla porta analogica (A3)
- Un connettore a 4 pin per interfaccia IIC (GND, VCC, SDA, SCL);
- Un connettore a 4 pin per interfaccia seriale TTL (TXD, RXD, VCC, GND)
Riassunto delle porte utilizzate e loro utilizzo
| Porta | Descrizione |
|---|---|
| D0 | Connettore Seriale TTL |
| D1 | Connettore Seriale TTL |
| D2 | Pulsante SW1 |
| D3 | Pulsante SW2 |
| D4 | Sensore DHT11 |
| D5 | Buzzer |
| D6 | Ricevitore IR |
| D7 | Connettore 3 pin - Digitale |
| D8 | Connettore 3 pin - Digitale |
| D9 | Led RGB |
| D10 | Led RGB |
| D11 | Led RGB |
| D12 | Led rosso |
| D13 | Led blu |
| A0 | Potenziometro |
| A1 | Fotocellula |
| A2 | Sensore LM35D |
| A3 | Connettore 3 pin - Analogico |
| A4 | Connettore I2C |
| A5 | Connettore I2C |
Posizione dei dispositivi
Come si collega il Multi-purpose Shield V1
Data la sua forma e la presenza dei connettori già saldati, l’installazione del Multi-purpose Shield V1 è molto semplice e sarà sufficiente inserire lo shield sulla scheda Arduino o un suo clone.
Occorre prestare attenzione che i pin siano inseriti correttamente e premere delicatamente.
Dove trovare la scheda
La scheda Multi-purpose Shield V1 si trova in vendita su molti siti, per esempio AliExpress uno di questi è la versione Easy module Shied V1 di keyestudio con il riferimento alla pagina wiki relativa al prodotto codice Ks0183
Schema elettrico delle scheda
Sotto è riportato lo schema della scheda (scarica pdf).
Nota: non si tratta dello schema originale ma una “ricostruzione” in base ai dati ricavati dalla scheda
Sensori e dispositivi presenti
Led di segnalazione
 |
 |
Programma di test
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
#define redLed 12 #define blueLed 13 void setup() { pinMode(redLed, OUTPUT); pinMode(blueLed, OUTPUT); } void loop() { digitalWrite(redLed, HIGH); // turn the LED on (HIGH is the voltage level) digitalWrite(blueLed, LOW); // turn the LED off by making the voltage LOW delay(1000); digitalWrite(redLed, LOW); // turn the LED off by making the voltage LOW digitalWrite(blueLed, HIGH); // turn the LED on (HIGH is the voltage level) delay(1000); } |
Pulsanti
Sulla scheda sono presenti due pulsanti SW1 e SW2 connessi alla porte digitali D2 e D3. Nel circuito sono presenti anche due resistenze di Pull-Up.
Vedere anche l’articolo KY-004 Key switch module
 |
 |
Programma di test
Il programma permette di testare i due pulsanti. La pressione del pulsante farà accendere il led posto al suo fianco, presente sulla scheda.
|
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 |
const int button1Pin = 2; // the number of the pushbutton pin const int button2Pin = 3; const int led1Pin = 13; // the number of the LED pin const int led2Pin = 12; int button1State = 0; // variable for reading the pushbutton status int button2State = 0; void setup() { // initialize the LED pin as an output: pinMode(led1Pin, OUTPUT); pinMode(led2Pin, OUTPUT); pinMode(button1Pin, INPUT); pinMode(button2Pin, INPUT); } void loop() { // read the state of the pushbutton value: button1State = digitalRead(button1Pin); // check if the pushbutton is pressed. // if it is, the buttonState is LOW: if (button1State == LOW) { digitalWrite(led1Pin, HIGH); } else { digitalWrite(led1Pin, LOW); } // read the state of the pushbutton value: button2State = digitalRead(button2Pin); // check if the pushbutton is pressed. // if it is, the buttonState is LOW: if (button2State == LOW) { digitalWrite(led2Pin, HIGH); } else { digitalWrite(led2Pin, LOW); } } |
Sensore DHT11
Il sensore DHT11 è un sensore di temperatura e umidità con uscita dei dati in formato digitale. E’ di facile gestione con la scheda Arduino e schede simili. (Vedere anche DHT22 AM2302 Sensore Temperatura Umidità).
Il sensore utilizza una tecnica digitale esclusiva che, unita alla tecnologia di rilevamento dell’umidità, ne garantisce l’affidabilità e la stabilità.
I suoi elementi sensibili sono connessi con un processore 8-bit single-chip.
Ogni sensore di questo modello è compensato in temperatura e calibrato in un’apposita camera di calibrazione che determina in modo preciso il valore di calibrazione il cui coefficiente viene salvato all’interno della memoria OTP.
Le sue piccole dimensioni e il suo basso consumo, unite alla lunga distanza di trasmissione (20 m) permettono al sensore DHT11 di essere adatto per molti tipi di applicazioni. Il package con quattro pin in linea ne rendono facile la connessione.
Vedere anche l’articolo KY-015 Temperature and humidity module
Caratteristiche sensore DHT11
| Modello | DHT11 |
| Alimentazione | 3-5.5V DC |
| Segnale di uscita | digitale del segnale tramite single-bus |
| Elemento sensibile | Resistenza in Polimero |
| Campo di misura umidità | 20-90% di umidità relativa, temperatura di 0-50 gradi Celsius |
| Precisione | umidità + -4% RH (Max + -5% di umidità relativa) temperatura +-2.0 Celsius |
| Risoluzione o la sensibilità | umidità 1% di umidità relativa, temperatura 0.1 Celsius |
| Ripetibilità umidità | + -1% di umidità relativa temperatura +-1Celsius |
| Umidità isteresi | + -1% RH |
| Stabilità a lungo termine | + -0.5% UR / anno |
| Tempo di rilevazione | medio: 2s |
| Dimensioni | 12 * 15,5 * 5,5 millimetri |
Foto del sensore DHT11 |
 |
Libreria del sensore
Per la gestione si utilizza una libreria DHT11.h che ne semplifica l’utilizzo. La libreria è presente all’interno del file della documentazione fornita dal venditore, oppure da questo link.
Nota: prima di compilare il codice, ricordarsi di aggiungere le librerie necessarie all’interno della directory delle librerie di Arduino IDE .
Vedere anche articolo Arduino – Tutorial, come installare una libreria
Programma di test
|
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 |
#include <dht11.h> dht11 DHT11; #define DHT11PIN 4 void setup() { Serial.begin(9600); Serial.println("DHT11 Programma TEST "); Serial.print("Versione libreria: "); Serial.println(DHT11LIB_VERSION); Serial.println(); } void loop() { Serial.println("\n"); int chk = DHT11.read(DHT11PIN); Serial.print("Lettura sensore: "); switch (chk) { case DHTLIB_OK: Serial.println("OK"); break; case DHTLIB_ERROR_CHECKSUM: Serial.println("Checksum error"); break; case DHTLIB_ERROR_TIMEOUT: Serial.println("Time out error"); break; default: Serial.println("Unknown error"); break; } Serial.print("Umidita' (%): "); Serial.println((float)DHT11.humidity, 1); Serial.print("Temperatura (°C): "); Serial.println((float)DHT11.temperature, 1); delay(2000); } |
Potenziometro
Il potenziometro è un dispositivo elettrico equivalente a un partitore di tensione resistivo variabile infatti una sua parte viene disposta in parallelo al carico utilizzatore.
Il partitore di tensione resistivo variabile è composto da due resistori collegati in serie, aventi la somma dei due valori di resistenza costante, ma di cui può variare il valore relativo.
 |
 |
Programma di test
Il programma di test leggerà il valore della tensione misurato dal potenziometro. Nell’intervallo 0-1023 e applicando la formula di conversione riporterà nella finestra del monitor seriale il valore di tensione in volt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
#define ldrPin A0 void setup() { // initialize serial communication at 9600 bits per second: Serial.begin(9600); } void loop() { // read the LDR on analog pin 1: float ldrValue = analogRead(ldrPin); // Convert the analog reading to a voltage float ldrVoltage = ldrValue * (5.0 / 1023.0); // print out the LDR value you read: Serial.print("LDR valore : "); Serial.print(ldrVoltage); Serial.println(" V"); delay(1000); } |
Buzzer passivo
Sulla scheda è presente un buzzer per l’emissione di segnali acustici. Il Buzzer ( in italiano cicalino), è un dispositivo audio di segnalazione, che può essere di tipo meccanico, elettromeccanico o piezoelettrico.
Il cuore dei segnalatori acustici piezoelettrici è un semplice disco piezoelettrico, consistente di una lastra ceramica e di uno strato metallico applicato.
Quando il disco viene pilotato da un circuito oscillatorio, si parla di un trasduttore piezoelettrico, quando il circuito oscillatorio è incorporato nella cassa si parla di un buzzer piezoelettrico.
Per non sovraccaricare la porta del processori, il buzzer è pilotato tramite un transistor NPN con la sigla J3Y (S8050 – datasheet), la cui base è alimentata tramite una resistenza di limitazione R13 da 1kΏ.
Vedere anche l’articolo Moduli buzzer attivi passivi: KY-006, KY-012, Ks0018, Ks0019
 |
 |
Programma di test
Una volta caricato il programma, ogni volta che si premerà il pulsante SW1, il buzzer emetterà un suono
|
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 |
#define buzzer 5 const int buttonPin = 2; // Porta SW1 unsigned char i; void setup() { pinMode(buzzer, OUTPUT); pinMode(buttonPin, INPUT); } void loop() { while (true) // ciclo infinito { if (digitalRead(buttonPin) == HIGH) { break; // esce dal ciclo se si preme il pulsante } test_buzzer(); // chiama la funzione che attiva il buzzer } } void test_buzzer() { //Frequency 1 for (i = 0; i < 80; i++) { digitalWrite (buzzer, HIGH) ; delay (1) ; digitalWrite (buzzer, LOW) ; delay (1) ; } //Frequency 2 for (i = 0; i < 100; i++) { digitalWrite (buzzer, HIGH) ; delay (2) ; digitalWrite (buzzer, LOW) ; delay (2) ; } } |
Led RGB
Sulla scheda è presente un led RGB tipo 5050 (datasheet), all’interno del chip sono presenti tre led che emettono ognuno un diverso colore primario: rosso, verde e blu. Combinando opportunamente tra loro i colori si possono ottenere le altre tonalità. Ogni led è dotato della propria resistenza limitatrice. I tre pin di controllo sono D9, D10 e D11.
Vedere anche l’articolo KY-009 RGB LED SMD
 |
 |
Programma di test
|
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 |
#define redLed 9 #define greenLed 10 #define blueLed 11 void setup() { pinMode(redLed, OUTPUT); pinMode(greenLed, OUTPUT); pinMode(blueLed, OUTPUT); } void loop() { for (int i=0; i <= 255; i++) { setColor(i, 0, 0); // red delay(10); } } void setColor(int red, int green, int blue) { analogWrite(redLed, red); analogWrite(greenLed, green); analogWrite(blueLed, blue); } |
Fotocellula
Il sensore di luce è formato da una semplice fotoresistenza, questi dispositivi sono sensibili alle radiazioni luminose, essi sono costituiti da materiali semiconduttori leggermente drogati come Solfuro di Cadmio (CdS), Solfuro di Piombo (PbS), Selenio (Se) e Antimoniuro di Indio (InSb).
In commercio si possono trovare diversi modelli di fotoresistenza, quella utilizzata ha queste caratteristiche:
- Resistenza (sensore illuminato) 1 K ohm, (sensore non illuminato) 10 K ohm
- Massima tensione di lavoro 150 Vcc
- Potenza dissipabile 100 mW
- Dimensioni 2 x 4x 5 mm
- Interasse Pins 4 mm
Nel circuito proposto, nel caso ideale, le due resistenze, di eguale valore, collegate come nello schema dividerebbero in parti uguali la tensione, nel punto di giunzione e si misurerebbe una tensione che sarebbe la metà di quella di alimentazione.
Nel circuito reale uno dei due elementi è variabile e cambia in funzione della luce che lo irradia.
Quando la fotoresistenza è colpita dalla massima luce, al punto di giunzione, si troverà la massima tensione +5V; quando ci sarà buio al punto si otterrà V/2 = 5v / 2 = 2,5v.
La tensione di uscita è misurata tramite una porta A1
Vedere anche l’articolo KY-018 Photo resistor module
  |
|
Programma di test
Il programma mostrerà nella finestra del monitor seriale, il valore della tensione letta in Volt. All’interno del programma è inserita la formula che trasforma la misura in uscita dal convertitore analogico nel corrispondente valore di tensione.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
#define ldrPin A0 void setup() { // initialize serial communication at 9600 bits per second: Serial.begin(9600); } void loop() { // read the LDR on analog pin 1: float ldrValue = analogRead(ldrPin); // Convert the analog reading to a voltage float ldrVoltage = ldrValue * (5.0 / 1023.0); // print out the LDR value you read: Serial.print("LDR valore : "); Serial.print(ldrVoltage); Serial.println(" V"); delay(1000); } |
Sensore LM35
Il sensore di temperatura LM35, presenta un contenitore di tipo TO92 analogo a quello di un normale transistor; necessita di un collegamento a una porta ADC per la lettura del valore di tensione fornito dal sensore, nel nostro caso è utilizzata la porta A2.
Il sensore si presenta con 3 terminali: uno per l’alimentazione, uno di massa e uno per l’uscita della tensione proporzionale alla temperatura rilevata che è pari a 10 mV per ogni grado centigrado, ed è calibrato in gradi Celsius.
Caratteristiche del sensore
| Altezza | 5.2mm |
| Profondità | 4.19mm |
| Lunghezza | 5.2mm |
| Package fornitore | TO-92 |
| Funzione | Sensore di temperatura |
| Pin Count | 3 |
| Precisione | ±0.6°C |
| Sensibilità | 10 mV/°C |
| Temperatura massima | 100°C |
| Temperatura minima | 0°C |
| Tensione tipica di funzionamento | 4-30V |
| Tipo uscita | Analogica |
 
|
 |
Programma di test
Il programma mostrerà nella finestra del monitor seriale il valore della temperatura misurata.
Al suo interno è inserita la formula che trasforma la misura della tensione nel corrispondente valore di temperatura.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
int tempC; float temperatura; int tempPin = A2; void setup() { Serial.begin(9600); } void loop() { tempC = analogRead(tempPin); //read the value from the sensor temperatura = (5.0 * tempC * 100.0) / 1024.0; //convert the analog data to temperature Serial.print("Temperatura - "); Serial.print(temperatura, 1); Serial.println(" °C"); delay(1000); } |
IR Receiver
Il sensore per telecomando TSOP1836 ( o equivalente) è un ricevitore IR dotato di un filtro ottico che non permette il passaggio della luce eccetto che a quella di 980 nm di lunghezza d’onda al suo sensore a fotodiodo interno. Il rivelatore infrarosso ha anche un filtro elettronico che permette il passaggio solamente a segnali con una frequenza di 38 kHz, ma esistono anche sensori con frequenze che vanno dai 20 ai 40 kHz.
Analizziamo prima di tutto il loro funzionamento: nella foto sotto potete vedere lo schema a blocchi del ricevitore TSOP18XX.
Il segnale IR ricevuto, è prelevato dal diodo di rilevazione a infrarossi PIN, questo segnale è amplificato e limitato nel primo blocco di Input.
Nel blocco AGC il segnale è trattato in modo da ottenere un livello di impulso costante, indipendentemente dalla distanza del telecomando.
Il segnale AC è poi inviato al filtro Passa Banda (Band Pass) che è sintonizzato sulla frequenza di modulazione del telecomando.
Nel blocco demodulatore avviene la rilevazione della presenza della frequenza di modulazione e, se questa è presente, l’uscita sarà attivata e si avrà il segnale sul pin OUT.
 |
 |
Libreria del sensore
Per la gestione si utilizza una libreria IRremote.h che ne semplifica l’utilizzo. La libreria è presente all’interno del file della documentazione fornita dal venditore, oppure da questo link.
Nota: prima di compilare il codice, bisogna aggiungere le librerie necessarie all’interno della directory delle librerie di Arduino IDE .
Vedere anche articolo Arduino – Tutorial, come installare una libreria
Programma di test
Una volta caricato il programma, si dovrà aprire la finestra del monitor seriale. A questo punto premendo un tasto sul vostro telecomando, posto di fronte al sensore, dovrebbe apparire un numero.
Questo è il codice corrispondente al tasto premuto. Nel caso si tenga il tasto premuto troppo a lungo, appare un codice “FFFFFFFF”.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
#include <IRremote.h> int RECV_PIN = 6; //define input pin on Arduino IRrecv irrecv(RECV_PIN); decode_results results; void setup() { Serial.begin(9600); irrecv.enableIRIn(); // Start the receiver } void loop() { if (irrecv.decode(&results)) { Serial.println(results.value, HEX); irrecv.resume(); // Receive the next value } } |
Connettori
Sulla scheda sono presenti alcuni connettori tipo pin strip maschio. La loro funzione è:
- due connettori a 3 pin connessi alle porte digitali D7 e D8 a cui collegare per esempio sensori con uscita digitale, piccoli servomotori, relè, etc.
- un connettore a 3 pin connesso alla porta analogica A3 a cui collegare per esempio sensori con uscita analogica.
- un connettore a 4 pin connesso alle porte D0 e D1 a formare una porta per realizzare connessioni di tipo seriale
- un connettore a 4 pin connesso alle porte A4 (SDA) e A5 (SCL) a formare una porta per realizzare connessioni di tipo I2C
Pulsante RESET e LED alimentazione
Nella parte in basso a sinistra della scheda è presente il pulsante RESET che permette di riavviare la scheda. A lato è presente il led la cui accensione segnala la presenta dell’alimentazione.
Programma di test fornito con Multi-purpose Shield V1
Nella documentazione digitale fornita con il Multi-purpose Shield V1 è presente un programma di test che proverà tutti i vari componenti.
Come anticipato per il suo funzionamento, prima di compilare il codice, occorre aggiungere le librerie necessarie all’interno della directory delle librerie di Arduino IDE . Queste sono:
|
1 2 |
#include <IRremote.h> #include <dht11.h> |
Vedere anche articolo Arduino – Tutorial, come installare una libreria
Fatto il caricamento del codice sulla scheda, il led di alimentazione, posto a lato del pulsante RESET sarà normalmente acceso.
Sul monitor seriale si può verificare che sia impostato il baud rate a 9600. Utilizzando un qualunque telecomando IR, rivolto al ricevitore IR, premendo i pulsanti del telecomando, si dovrebbe vedere il valore di decodifica del pulsante che viene visualizzato sul monitor.
Non premere troppo a lungo, altrimenti appare l’errore di dati come FFFFFF.
Se si preme il pulsante SW1, il buzzer passivo emette un segnale acustico e quindi il LED RGB emette in sequenza la luce rossa, verde e blu. Anche il led rosso e il led blu si accendono, in modo circolare.
Se si preme il pulsante SW2, il buzzer passivo smette di suonare e i LED non si accendono.
Quindi aprire il monitor seriale e impostare il baud rate a 9600; premendo nuovamente il pulsante SW2, il monitor seriale visualizzerà i dati mostrati di seguito.
Dai dati mostrati sul monitor, è possibile ottenere i dettagli come segue:
La prima colonna è lo stato OK.
La seconda colonna è il valore di umidità misurato dal sensore DHT11;
La terza colonna è il valore di temperatura misurato dal sensore DHT11;
La quarta colonna è il valore analogico misurato dal potenziometro, nell’intervallo 0-1023;
La quinta colonna è il valore analogico misurato dalla fotocellula. Più forte è la luce, maggiore è il valore.
La sesta colonna è il valore analogico misurato dal sensore di temperatura LM35, che può essere utilizzato per calcolare il valore di temperatura specifico.
Codice di test
|
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 |
#include <IRremote.h> #include <dht11.h> dht11 DHT; #define DHT11_PIN 4 //buzzer pin int buzzer = 5; //button pins int KEY2 = 2; int KEY3 = 3; //pin definition of flowing light int led5 = 13; int led4 = 12; int led3 = 11; int led2 = 10; int led1 = 9; int RECV_PIN = 6; //define input pin on Arduino IRrecv irrecv(RECV_PIN); decode_results results; char i=0,flag=2; void setup () { Serial.begin(9600); irrecv.enableIRIn(); // Start the receiver attachInterrupt(0, falling0, FALLING); attachInterrupt(1, falling1, FALLING); pinMode(buzzer,OUTPUT); digitalWrite(buzzer,HIGH); pinMode(led1,OUTPUT); pinMode(led2,OUTPUT); pinMode(led3,OUTPUT); pinMode(led4,OUTPUT); pinMode(led5,OUTPUT); for(char i=9;i<14;i++) digitalWrite(i,LOW); } void loop() { if(flag==0) { buzzer_(); //testing buzzer led_display(); //testing LED } if(flag==1) { Serial.println("status, Hum(%), Tem(C) analog_val light_val lm35_val"); DHT11(); Serial.print(" "); analog(); //testing analog input Serial.print(" "); Light(); Serial.print(" "); LM35(); Serial.println(" "); delay(800); } if(flag!=0 & flag!=1) { if (irrecv.decode(&results)) { Serial.println(results.value, HEX); irrecv.resume(); // Receive the next value } } } void DHT11() { int chk; chk = DHT.read(DHT11_PIN); // READ DATA switch (chk) { case DHTLIB_OK: Serial.print("OK "); Serial.print(DHT.humidity,1); Serial.print(" "); Serial.print(DHT.temperature,1); break; case DHTLIB_ERROR_CHECKSUM: Serial.print("Checksum error "); break; case DHTLIB_ERROR_TIMEOUT: Serial.print("Time out error "); break; default: Serial.print("Unknown error "); break; } } void buzzer_(void) { char i; for(i=0;i<80;i++)// output a frequency sound { digitalWrite(buzzer,LOW);// sound delay(1);//delay1ms digitalWrite(buzzer,HIGH);//not sound delay(1);//ms delay } for(i=0;i<100;i++)// output a frequency sound { digitalWrite(buzzer,LOW);// sound digitalWrite(buzzer,HIGH);//not sound delay(2);//2ms delay } } void led_display() { digitalWrite(led1,HIGH); delay(500); digitalWrite(led1,LOW); digitalWrite(led2,HIGH); delay(500); digitalWrite(led2,LOW); digitalWrite(led3,HIGH); delay(500); digitalWrite(led3,LOW); digitalWrite(led4,HIGH); delay(500); digitalWrite(led4,LOW); digitalWrite(led5,HIGH); delay(500); digitalWrite(led5,LOW); } void analog() { int val; val=analogRead(A0); Serial.print(val); } void Light() { int val; val=analogRead(A1); Serial.print(val); } void LM35() { int val; val=analogRead(A2); Serial.print(val); } void falling0() { flag=0; } void falling1() { flag=1; } |
