# data[].attributes.body
vi carico qui il manuale di istruzioni del kit ELEGOO, che è contenuto all'interno del CD.
nel cd trovate anche i codici e le librerie da scaricare che servono per esempio per il display, motore e sensore ultrasuoni

# data[].attributes.headline
SIMULARE ARDUINO SENZA AVERE IL KIT A CASA

# data[].attributes.subject
SIMULARE ARDUINO SENZA AVERE IL KIT A CASA

# data[].attributes.body
per chi volesse provare i codici a casa, anche se non avete comprato il kit, basta andare sul sito di tinkercad.

www.tinkercad.com

quando si schiaccia su "codice", in alto c'è l'opzione "blocchi". Cliccando lì, si può scegliere di mettere "testo". in questo modo potete scrivere lì i codici di programmazione come quelli di Arduino!

# data[].attributes.body
accendiamo un led collegato al pin 12
mettere il led con la gamba corta a sinistra, che va collegata con una resistenza da 220 ohm e a sua volta alla terra (GND). la gamba di destra va collegata con il pin 12

void setup() {

pinMode(12, OUTPUT); }

void loop() {
digitalWrite(12, HIGH);}

# data[].attributes.body
facciamo lampeggiare il led ogni secondo.
nel delay si mette il tempo in millisecondi (1000ms= 1 secondo)

void setup() {
pinMode(12, OUTPUT);
}
void loop() {
digitalWrite(12, HIGH);
delay(1000);
digitalWrite(12, LOW);
delay(1000);
}

# data[].attributes.body
accendiamo un led collegato al pin 12 premendo un pulsante collegato al pin 2. rilasciando il pulsante, il led si spegne.

il pulsante va messo con le righe in verticale (girate il pulsante per vederle). la gamba di sinistra va collegata a terra (GND), la gamba di destra al pin 2.

per non occupare troppi pin GND ho messo in serie i collegamenti: le terre di led e pulsante si collegano alla riga in basso con il - , che a sua volta si collega con GND (vedi immagine).

int puls;
void setup() {
pinMode(2, INPUT_PULLUP);
pinMode(12,OUTPUT);
}
void loop() {
puls=digitalRead(2);
if (puls==0){
digitalWrite(12,HIGH);
}
else {digitalWrite(12,LOW);
}}

# data[].attributes.body
Si collegano tre led di colori diversi seguendo lo schema dell' esercizio 1, a tre Pin digitali diversi ( es 8,9,10). Ricordatevi le resistenze e il collegamento a terra.

void setup() {
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
}
void loop() {
digitalWrite(8, HIGH);
delay(1000);
digitalWrite(8, LOW);
delay(1000);
digitalWrite(9, HIGH);
delay(1000);
digitalWrite(9, LOW);
delay(1000);
digitalWrite(10, HIGH);
delay(1000);
digitalWrite(10, LOW);
delay(1000);
}

# data[].attributes.body
con questo codice comparirà una scritta nel monitor seriale (nella foto vi ho messo una freccia per indicare dove schiacciare per aprire il monitor seriale). cambiando il tempo del delay, la scritta comparirà con frequenza diversa.

una volta messo il codice, schiacciate il pulsante in alto a destra per aprire il monitor seriale

void setup() {
Serial.begin(9600);
}

void loop() {
Serial.println("ciao");
delay(500);
}

# data[].attributes.headline
6)se scrivi una lettera nel monitor seriale, accendi un led

# data[].attributes.subject
6)se scrivi una lettera nel monitor seriale, accendi un led

# data[].attributes.body
scrivendo H oppure h nel monitor seriale, accende un led (in questo caso la lucina che sta sotto al pin 13). se si scrive L oppure l, la luce si spegne.

int pinLed = 13;

void setup() {
pinMode(13, OUTPUT);
Serial.begin(9600);
}

void loop() {
if (Serial.available() > 0) {
char stato = Serial.read();
if (stato == 'H' || stato == 'h') {
digitalWrite(pinLed, HIGH);
Serial.println("LED ON");
}
if (stato == 'L' || stato == 'l') {
digitalWrite(pinLed, LOW);
Serial.println("LED OFF");
}
}
delay(50);
}

# data[].attributes.body
quando si collega il display, occorre utilizzare un trimmer (è una specie di pulsante con rotellina che serve a regolare il contrasto). ha tre gambe: una (quella singola) si collega al pin 3 del display, delle altre due, quella di destra va con i 5 volt di Arduino, quella di sinistra con GND.
ricordatevi anche di mettere una resistenza a ponte tra il pin 15(A) del display e i 5 volt della scheda Arduino.

all'inizio del codice bisogna includere la libreria "liquidCrystal", come scritto qui sotto:

#include <LiquidCrystal.h>
LiquidCrystal lcd(12,11,5,4,3,2);

void setup() {
// put your setup code here, to run once:
lcd.display();
delay(500);
lcd.begin(16,2);
lcd.setCursor(7,0);
lcd.print("ciao");
lcd.setCursor(5,1)
;
lcd.print("ragazzi!");

}
void loop () {

lcd.noDisplay();
delay(1000);
lcd.display();
delay(1000);}

# data[].attributes.body
il termistore è quel componente piccolo, sottilissimo con la testa nera.
la gamba di sinistra è collegata con i 5V, la gamba destra è a ponte con una resistenza da 10 K ed è collegata a GND e al pin A0. guardate bene l'immagine per fare il collegamento.

con questo codice, comparirà sul monitor seriale il valore di temperatura misurato dal termistore

int ThermistorPin = 0;
int Vo;
float R1 = 10000;
float logR2, R2, T;
float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;

void setup() {
Serial.begin(9600);
}

void loop() {

Vo = analogRead(ThermistorPin);
R2 = R1 * (1023.0 / (float)Vo - 1.0);
logR2 = log(R2);
T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
T = T - 273.15;

Serial.println("Temp in gradi C= ");
Serial.println(T);

delay(500);
}

# data[].attributes.body
Il passive buzzer è un componente piccolo rotondo, che serve a fare i suoni.
con questo codice è possibile suonare note schiacciando pulsanti. ad ogni nota è associata un numero diverso.

per il collegamento fate attenzione a mettere la gambina del passive buzzer che si trova in corrispondenza con il + collegata con un pin a vostra scelta (in questo esercizio è stata collegata al 12) e l'altra gamba collegata al GND.

mettiamo due pulsanti 3 e 2, uno che suonerà la nota do e l'altro la nota re.

bool notado;
bool notare;

void setup() {
pinMode(2,INPUT_PULLUP);
pinMode(3,INPUT_PULLUP);
pinMode(12,OUTPUT);
}

void loop() {
notado=digitalRead(3);
notare=digitalRead(2);

while(notado==0){
tone(12,262);
notado=digitalRead(3);
}
noTone(12);

while(notare==0){
tone(12,294);
notare=digitalRead(2);
}
noTone(12);
}

# data[].attributes.body
l'RGB è un led che può fare tutti i colori. è quello bianco con 4 gambe: la più lunga si collega al GND senza resistenza (contrariamente agli altri led normali). le altre tre gambe vanno collegate ai pin 6,5,3 (ricordandosi di mettere per ciascuna gamba una resistenza).

con questo codice il led cambia colore ogni 2 secondi (il tempo può essere modificato cambiando il valore nel delay)

int portarossa = 6;
int portaverde = 5;
int portablu = 3;
void colore (unsigned char rosso, unsigned char verde, unsigned char blu)
{
analogWrite(portarossa, rosso);
analogWrite(portablu, blu);
analogWrite(portaverde, verde);
}

void setup()
{
pinMode(portarossa, OUTPUT);
pinMode(portaverde, OUTPUT);
pinMode(portablu, OUTPUT);
}

void loop()
{

colore(255, 0, 0);
delay(2000);
colore(0,255, 0);
delay(2000);
colore(0, 0, 255);
delay(2000);
colore(237,109,0);
delay(2000);
colore(255,215,0);
delay(2000);
colore(0,46,90);
delay(2000);
colore(128,0,128);
delay(2000);
colore(0,0,0);
delay(2000);
}

# data[].attributes.body
il codice è molto lungo da scrivere qui su padlet, vi ho messo direttamente il file che potete scaricare ed aprire con arduino.

con questo codice è possibile accendere e spegnere due led messi sui pin 2 e 5, schiacciando i pulsanti del telecomando che è dentro nel kit (dovrete scoprire voi quali..). nel codice è presente anche una parte sul motore, che però vi spiegherò in un'altra lezione.

per far funzionare il telecomando, bisogna collegare il ricevitore infrarossi presente nel kit (per ulteriori informazioni, guardate pag 93 del manuale Elegoo)

# data[].attributes.headline
10 bis)collegamento del ricevitore infrarossi per far funzionare il telecomando

# data[].attributes.subject
10 bis)collegamento del ricevitore infrarossi per far funzionare il telecomando

# data[].attributes.body
il servo motore è un motorino che può muoversi di 180 gradi.
il cavo marrone si collega con il GND, quello giallo con il pin 9, quello rosso in mezzo con il 5 volt.

ricordatevi di includere la libreria servo nel codice, altrimenti non lo riconosce

#include <Servo.h>

Servo myservo;

int pos = 0;

void setup() {
myservo.attach(9);
}

void loop() {
for (pos = 0; pos <= 180; pos += 1)
{
myservo.write(pos);
delay(15);
}
for (pos = 180; pos >= 0; pos -= 1)
myservo.write(pos);
delay(15);
}
}

# data[].attributes.body
Con il sensore a ultrasuoni è possibile misurare le distanze.
Si potrebbe progettare un dispositivo che quando la distanza è minore di una certa misura, accende un led oppure fa muovere un braccio meccanico...o emettere un suono.

Prima di eseguire questo codice, controllate di aver installato la libreria <Ultrasonic.h>  altrimenti il sensore non funziona.
(per scaricare le librerie, bisogna andare su sketch-->gestione librerie

con questo codice, se la distanza tra la mano e il sensore è minore di 10 cm si accende il led 13, altrimenti si spegne. intanto schiacciando nel monitor seriale compare la distanza misurata in cm.

#include <Ultrasonic.h>

Ultrasonic ultrasonic (12, 11);
int distanza;

void setup() {

Serial.begin(9600);
pinMode(13,OUTPUT);
}

void loop() {
distanza = ultrasonic.read();
if (distanza<10){
digitalWrite(13,HIGH);
Serial.println(distanza);
delay(500);
}
else  {digitalWrite(13,LOW);
Serial.println(distanza);
delay(500);
}}

# data[].attributes.body
guardate bene come è stato collegato il sensore di luminosità, perchè è particolare.. una gamba va sui 5V, sull'altra bisogna mettere a ponte anche una resistenza da 1K. Seguite bene lo schema di montaggio.
il led collegato all'11 invece ha una resistenza normale da 220.

con questo codice, se la luminosità percepita dal sensore è maggiore di un certo valore (Facciamo 50), il led rimane spento. Se si copre il sensore con un dito (e quindi la luminosità viene percepita minore di 50), si accende il led.

il valore di luminosità potete leggerlo nel monitor seriale.

int luce=A0;
int valore;

void setup() {
pinMode(11,OUTPUT);
Serial.begin(9600);
}

void loop() {
valore=analogRead(luce);
if (valore>050){
digitalWrite(11,LOW);
Serial.println(valore);
delay(500);
}
else{
digitalWrite(11,HIGH);
}
}

# data[].attributes.body
const int pinPA=13;
const int pinPB=0;
const int pinStart=8;
const int pinBuzzer=9;
const int pinLA=10;
const int pinLB=6;
const int pinLstart=7;
bool PA;
bool PB;
bool Pstart;
int totWinA=0;
int totWinB=0;
int nota;

void vincitore (int winner);

void setup() {
// put your setup code here, to run once:

pinMode(13,INPUT_PULLUP);  //pulsante giocatore A
pinMode(0,INPUT_PULLUP); //pulsante giocatore B
pinMode(8,INPUT_PULLUP); //pulsante start
pinMode(9,OUTPUT); //buzzer
pinMode(10,OUTPUT); // luce del giocatore A
pinMode(6,OUTPUT);// luce giocatore B
pinMode(7,OUTPUT); //luce dello start

randomSeed(analogRead(0)); //inizializza la funzione random, leggendo del rumore sul pin scollegato analog input 0
Serial.begin(9600);
}
void loop() {
digitalWrite(pinLstart,HIGH);
do{
Pstart=digitalRead(pinStart);
}
while (Pstart==1);
digitalWrite(pinLstart,LOW);
delay(random(3000,8000));
PA=digitalRead(pinPA);
PB=digitalRead(pinPB);
tone(pinBuzzer,262);
digitalWrite(pinLstart,HIGH);

if (PA==0 || PB==0)
{
if (PA==0 && PB==1) //Se premi A vince B
vincitore(pinLB);
if (PA==1 && PB==0)  //Se premi B vince A
vincitore(pinLA);
if (PA==0 && PB==0)
Serial.println("gara non valida");
}
else {
do{
PA= digitalRead(pinPA);
PB=digitalRead(pinPB);
}while (PA && PB);

if (PA==0){
vincitore(pinLA);
}
if (PB==0)
vincitore(pinLB);
}
noTone(pinBuzzer);
}
void vincitore (int winner){
digitalWrite(pinLstart,LOW);
if (winner==pinLA){

Serial.println("ha vinto A");
totWinA++;
nota=440;

}

if (winner==pinLB){
Serial.println("ha vinto B");
totWinB++;
nota=587;

}
Serial.print("punti totali    A:");
Serial.print(totWinA);
Serial.print("    B:");
Serial.println(totWinB);

for (int cont=1; cont<=5; cont++)
{

tone (pinBuzzer,nota);
digitalWrite(winner,HIGH);
delay(500);
noTone(pinBuzzer);
digitalWrite(winner,LOW);
delay(500);
}
}

# data[].attributes.body
produci dei suoni muovendo le mani sopra un fotosensore.

int sensorValue;
int sensorLow=1023;
int sensorHigh=0;

const int ledPin = 13;

void setup() {
pinMode(ledPin,OUTPUT);
digitalWrite(ledPin,HIGH);

while (millis()<5000){
sensorValue=analogRead(A0);
if (sensorValue> sensorHigh){
sensorHigh=sensorValue;
}
if (sensorValue<sensorLow)
{sensorLow=sensorValue;
}

}
digitalWrite(ledPin,LOW);}

void loop() {
sensorValue=analogRead(A0);

int pitch=
map(sensorValue,sensorLow, sensorHigh, 40,4000);
tone (8, pitch,20);
delay(10);
// put your main code here, to run repeatedly:

}

# data[].attributes.body
si collegano il display seguendo lo schema classico con retroilluminazione regolata da potenziometro, led verde sul pin 7, led rosso sul pin 8, buzzer sul pin 9.

si inserisce un codice su monitor seriale, se il codice è corretto sul display compare la scritta open, si accende il led verde e il buzzer fa un suono