Utente:Carbowski/Arduino

Conta marce Moto

Questo progetto realizza un conta marce per motoveicoli da 3 a 6 marce con display applicabile vicino alla strumentazione originale disponibile in vari colori (rosso, verde, blu).

Descrizione del progetto

Da ora non potrai più essere in dubbio su quale marcia hai appena ingranato! Usarlo è semplice: basta posizionarlo vicino alla strumentazione o dove vi rimane più comodo utilizzando il velcro in dotazione che mantiene salda la presa in ogni circostanza ambientale. Per installarlo non basterà che sostituire l'asticella del cambio utilizzando quella in dotazione e il gioco è fatto!

Al momento della vendita specificare il colore del display tra quelli disponibili (rosso, verde, blu); lunghezza dell'asticella del cambio della vostra moto e il numero di marce (esclusa la folle).

Schema elettrico

Lo schema elettrico è formato da un circuito programmabile basato su Arduino Uno. Di seguito la lista dei componenti:

Componenti utilizzati

componente	tipo	numero
Pulsanti	2 corti e 1 lungo	3
Display	anodo comune	1
Resistenze	220 Ω	5

Schema di montaggio

circuito Conta Marce Carbowski

I 3 pulsanti simulano il movimento dell'asticella del cambio. Il primo per aumentare la marcia, il secondo per decrementarla e il terzo per inserire la folle solo se si è in prima.

Dovendo progettare un vero conta marce verrebbe applicato un sensore in mezzo all'asticella del cambio che in base alla forza con cui viene premuto o tirato segnala l'avvenuto cambio di marcia. Quando si è in prima e vogliamo mettere la folle la corsa che fa la pedalina del cambio è minore rispetto a quando vogliamo ingranare la seconda e il sensore rivela questo movimento (in questo caso rappresentato dal terzo pulsante). Nel caso in cui una marcia non viene ingranata correttamente la corsa della pedalina è minore rispetto al perfetto cambio di marcia, quindi il sensore non lo rileverebbe e resterebbe nella marcia precedente fin quando non viene inserita correttamente quella successiva.

Codice

int pinA  = 2;                //
int pinB  = 3;                //
int pinC  = 4;                //
int pinD  = 5;                // assegna una lettera a ciascun pin collegato ad un certo segmento del display
int pinE  = 6;                //
int pinF  = 7;                //
int pinG  = 8;                //
int pinHButton = 9;           // pin del pulsante per aumentare la marcia
int pinLButton = 10;          // pin del pulsante per scalare la marcia
int pinFButton = 11;          // pin del pulsante per mettere la folle nel caso in cui siamo in prima
int counter = 0;
int valButtonOldH = LOW;      
int valButtonOldL = LOW;
int valButtonoldF = LOW;
int Result = 0;


void setup() {
  pinMode(pinA, OUTPUT);             //
  pinMode(pinB, OUTPUT);             //
  pinMode(pinC, OUTPUT);             // 
  pinMode(pinD, OUTPUT);             // definisci i pin del display in uscita
  pinMode(pinE, OUTPUT);             //
  pinMode(pinF, OUTPUT);             //
  pinMode(pinG, OUTPUT);             //
  
    pinMode(pinHButton, INPUT);      //
    pinMode(pinLButton, INPUT);      // definisci i pin dei pulsanti com input 
    pinMode(pinFButton, INPUT);      //
  }


void loop()
{
Result = constrain (counter,0,5);     // Vincola il numero delle marce ad essere da 1 a 6

//*********************************************
int valButtonF = digitalRead(pinFButton);

  if(valButtonF==HIGH && valButtonoldF ==LOW)
  { 
  digitalWrite(pinA,LOW);
  digitalWrite(pinB,HIGH);
  digitalWrite(pinC,HIGH);
  digitalWrite(pinD,HIGH);                        // Stampa F sul display 
  digitalWrite(pinE,LOW);
  digitalWrite(pinF,LOW);
  digitalWrite(pinG,LOW); 
  }
  valButtonoldF = valButtonF; 

//***********************************************
int valButtonH = digitalRead(pinHButton);
  
  if(valButtonH==HIGH && valButtonOldH==LOW)
  {                                                 //aumenta le marce      
counter = Result+1;
  }
  valButtonOldH = valButtonH; 
  
//***********************************************
  int valButtonL = digitalRead(pinLButton);
  
  if(valButtonL==HIGH && valButtonOldL==LOW)
  {                                                //decrementa le marce   
  counter = Result-1;
  }
  valButtonOldL = valButtonL;
  
//***********************************************                                                
  if(counter==0)
  {
  digitalWrite(pinA,HIGH);
  digitalWrite(pinB,LOW);
  digitalWrite(pinC,LOW);
  digitalWrite(pinD,HIGH);  // Stampa 1 sul display
  digitalWrite(pinE,HIGH);
  digitalWrite(pinF,HIGH);
  digitalWrite(pinG,HIGH);
  }
  
  else if(counter==1)
   {
  digitalWrite(pinA,LOW);
  digitalWrite(pinB,LOW);
  digitalWrite(pinC,HIGH);
  digitalWrite(pinD,LOW);  // Stampa 2 sul display
  digitalWrite(pinE,LOW);
  digitalWrite(pinF,HIGH);
  digitalWrite(pinG,LOW);
  }

  else if(counter==2)
  {
  digitalWrite(pinA,LOW);
  digitalWrite(pinB,LOW);
  digitalWrite(pinC,LOW);
  digitalWrite(pinD,LOW);  // Stampa 3 sul display
  digitalWrite(pinE,HIGH);
  digitalWrite(pinF,HIGH);
  digitalWrite(pinG,LOW);
  }

  else if(counter==3)
  {   
  digitalWrite(pinA,HIGH);
  digitalWrite(pinB,LOW);
  digitalWrite(pinC,LOW);
  digitalWrite(pinD,HIGH);  // Stampa 4 sul display
  digitalWrite(pinE,HIGH);
  digitalWrite(pinF,LOW);
  digitalWrite(pinG,LOW);
  }
  
  else if(counter==4)
  {
  digitalWrite(pinA,LOW);
  digitalWrite(pinB,HIGH);
  digitalWrite(pinC,LOW);
  digitalWrite(pinD,LOW);   // Stampa 5 sul display
  digitalWrite(pinE,HIGH);
  digitalWrite(pinF,LOW);
  digitalWrite(pinG,LOW);
  }
  
  else if(counter==5)
  {
  digitalWrite(pinA,LOW);
  digitalWrite(pinB,HIGH);
  digitalWrite(pinC,LOW);
  digitalWrite(pinD,LOW);   // Stampa 6 sul display
  digitalWrite(pinE,LOW);
  digitalWrite(pinF,LOW);
  digitalWrite(pinG,LOW);
  }
   }

Conclusioni

Questo è il contamarce per ogni tipo di moto, personalizzabile per ogni tipo di rider!

Sbarra parcheggio ad infrarossi

Questo progetto realizza il circuito di una sbarra per regolare l'entrata/uscita da un parcheggio regolato da un sorvegliante.

Descrizione del progetto

Il sorvegliante del parcheggio ora può comodamente star seduto in cabina ad autorizzare l'entrata e l'uscita dei veicoli con un semplice telecomando! Infatti, questo sistema utilizza i segnali ad infrarossi per far aprire e chiudere la sbarra utilizzando solamente due pulsanti. il primo pulsante (freccia verso l'alto) alza la sbarra del cancello seguita dall'accensione di una luce verde che da il via libera al conducente del veicolo ad entrare. Premendo la freccia verso il basso, invece, la luce verde si spegne e si accende quella rossa con la conseguente chiusura della sbarra.

Schema elettrico

Lo schema elettrico è formato da un circuito programmabile basato su Arduino Uno. Di seguito la lista dei componenti:

Componenti utilizzati

Componente	Tipo
Diodi led	Verde e Rosso
Resistenza	$220~\Omega$
Servomotore	5 V
Ricevitore IR	VS1838B
Telecomando	IR

Codice

#include <IRremote.h>             //includi libreria per sensore di ricezione IR
#include <Servo.h>                //includi libreria per servomotore
const int sensore = 7;            //pin a cui è collegato il sensore
IRrecv ricezione (sensore);       //definisci la ricezione del sensore
decode_results risultato;         //decodifica i dati ottenuti
Servo servo;                      //crea l'oggetto servomotore (richiesto dalla libreria)
int x = 90;                       //angolo del range della sbarra



void setup() {
 Serial.begin(9600);              //inizializza la porta seriale
 ricezione.enableIRIn();          //abilita il sensore IR a ricevere segnali
 ricezione.blink13(true);         //ogni volta che riceve un segnale a 16MHz il led sul pin 13 lampeggia
 servo.attach (9);                //pin dove è collegato il servomotore
 servo.write (0);                 //valore che indica al servo a che gradi deve posizionarsi inizialmente (0°)
 delay (1000);                    //applica un delay per il posizionamento
 pinMode (12, OUTPUT);            //pin dove è collegato il led verde
 pinMode (11, OUTPUT);            //pin dove è collegato il pin rosso
 
}

void loop() {
 if (ricezione.decode(&risultato)) {        //decodifica il valore ricevuto dal sensore 
  Serial.println(risultato.value, HEX);     //se ricevi un segnale scrivilo nella porta seriale 
  ricezione.resume();                       //se non ricevi alcun segnale torna all'inizio dell'if

 if (risultato.value == 0x5EA119E6){        //se il risultato della decodifica del segnale è il codice pre assegnato (corrispondente ad un tasto particolare del telecomando)
  digitalWrite (12, HIGH);                  //accendi il led verde
  digitalWrite (11, LOW);                   //spegni il led rosso
 for (int i = 0; i < x; i++){               //definisci il movimento verso l'alto della sbarra
  servo.write (i);                          //esegui il movimento
  delay (40);                               //ritardo per impostare la velocità del servomotore
 }
}
 if (risultato.value == 0x5EA19966) {       //se il risultato della decodifica del segnale è il codice pre assegnato (corrispondente ad un tasto particolare del telecomando)
  digitalWrite (12, LOW);                   //spegni il led verde
  digitalWrite (11, HIGH);                  //accendi il led rosso
  delay (5000);                             //ritardo utile al sorvegliante per bloccare la discesa della sbarra in caso ci sia un veicolo fermo sotto di essa
  for (int i = x; i >=0; i--){              //definisci il movimento verso il basso della sbarra
  servo.write (i);                          //esegui il movimento
  delay (40); }                             //ritardo per impostare la velocità del servomotore
  } 
 }
}

Conclusioni

Ricapitolando, questo è tutto il necessario per facilitare la vita al sorvegliante potendo alzare e abbassare la sbarra del parcheggio semplicemente con un telecomando o telefono dotato di trasmettitore ad infrarossi|

Boiler Elettrico

Questo progetto mira a creare un impianto completo di riscaldamento elettrico per piccoli ambienti, utilizzando la piattaforma programmabile Arduino. Si ha il completo controllo sulla temperatura ambiente e sull' umidità grazie ad un potenziometro ed uno schermo lcd. E' inoltre dotato di sistemi di sicurezza sulla temperatura dell'acqua interna, in modo da evitare in qualsiasi caso il contatto dell'acqua con l'apparato elettrico.

Descrizione del progetto

Questo progetto ricrea un impianto di riscaldamento completamente elettrico, in grado di scaldare l'acqua per i servizi e anche quella a circuito chiuso per i radiatori. Tutto è basato sulla board Arduino Uno e una resistenza solitamente usata per riscaldare gli acquari, opportunamente modificata. Grazie a una sonda riusciamo a misurare la temperatura dell'acqua, che viene riportata sullo schermo lcd (è impostato un limite massimo di 60 gradi, onde evitare il surriscaldamento dell'impianto). Il termostato cablato può essere sistemato in qualsiasi parte della stanza e misura temperatura e umidità relativi a quell'ambiente, una volta impostato il valore di temperatura richiesto il sistema si aziona e rimane in funzione fino al raggiungimento della temperatura impostata.

Schema di Montaggio

Schema su Thinkercad

Codice

#include <Adafruit_Sensor.h>
#include <DHT.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 2       // PIN sonda acqua (ricordati di colegarlo al positivo con una resistenza)
#define temp_min    10       // Temperatura minima
#define bit_min      3       // valore min potenziometro
#define temp_max    35       // Temperatura massima
#define bit_max   1020       // valore max potenziometro
#define pin_dht      8       // PIN sensore DTH
#define ritardo    100       // Intervallo in millisecondi tra acquisizioni
#define potenz      A0       // PIN potenziometro

OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature sensors (&oneWire);


// Inizializza il sensore di temperatura e umidità
DHT dht (pin_dht, DHT11);

// Inizializza il display I2C
LiquidCrystal_I2C lcd(0x27, 16, 2);

int tp = 0;

int vecchia = 0;



void setup() {

  //SENSORE IR
  Serial.begin(9600);


  //DISPLAY I2C
  dht.begin();

  sensors.begin();

  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("t");
  lcd.setCursor(0, 1);
  lcd.print("h");

}

void loop() {
  int t = dht.readTemperature();
  int h = dht.readHumidity();

  sensors.requestTemperatures();



  // Posizionamento a inizio display
  lcd.setCursor(0, 0);

  // Acquisisce il valore del potenziometro (0 - 1023)
  int p = analogRead (potenz);
  Serial.println (p);
  
  // Converte il valore del potenziometro nel mio range di temperature (lo converte da 3 a 1020)
  tp = map (p, bit_min, bit_max, temp_min, temp_max);
  delay (ritardo);




  if (abs(tp - vecchia) > 0.001) {
    lcd.clear();
    lcd.setCursor (0, 0);
    lcd.print ("Temp. impostata:");
    lcd.setCursor (0, 1);
    lcd.print ("      " + String(tp) + char(0xDF) + "C      " );
    vecchia = tp;
    delay (ritardo);
  }

  else {
    lcd.setCursor (0, 0);
    lcd.print("Temp.: " + String(t) + char(0xDF) + "C  " + String (byte(sensors.getTempCByIndex(0))) + char(0xDF) );
    lcd.setCursor(0, 1);
    lcd.print("Umid.: " + String(h) + "%");
  }

}

Dmx controllo luci

In questo progetto andremo a progettare ed assemblare un mini controller per luci da palco, eventi o discoteche, programmabile in base alle esigenze del cliente.

descrizione del progetto

Il progetto mira a creare un impianto completo in grado di dare la giusta atmosfera in base ai bpm della musica riprodotta (bpm = battiti per minuto). Imposteremo quindi una luce soffusa per musica classica con bassi valori di bpm, mentre con alti valori (da 130 in su) lampi luminosi di luce in modo intermittente. Saranno presenti luci gialle di atmosfera e luci blu e rosse che si accendono alternativamente

schema di montaggio

codice

int lucentezza = 0;
int incremento = 5;

int ledPin = 9;  //Il led è connesso al pin 13
int pulsante = 7;  //Il pulsante è connesso al pin 7
int val = 0;

void setup ()
{
  pinMode (9, OUTPUT); // definisce la porta 9 come porta di output

  pinMode(pulsante, INPUT);  //Il pin del pulsante è un'entrata
}
void loop()
{
  val = digitalRead(pulsante);  //Lettura del pulsante

  if (val == 1) { //Se il valore del pulsante è 1

    analogWrite (9, lucentezza); // invia alla porta 9 una tensione pari a (5/255) * lucentezza
    lucentezza = lucentezza + incremento; // modifica il valore di lucentezza
    if (lucentezza == 0 || lucentezza == 255) {
      incremento = incremento * -1;
    }
    delay (30); //attende 30 millisecondi prima di ricominciare il ciclo
  }

  else {
    digitalWrite(ledPin, LOW);  //Spegni il led
  }
}

conclusioni

Grazie a questo circuito pilotato da arduino siamo in grado di controllare luci per l'atmosfera di feste ed eventi in modo semplice ed efficace, in grado di essere sepre a tempo con la musica. è possibilie programmare il tempo in cui le luci devono rimanere accese dopo che il èpulsante viene premuto, utilizzando semplicemente un pc.

VOLTOMETRO DA 0v A 30v DC CON ARDUINO

Descrizione del progetto

Questo progetto mira a creare un voltometro in grado di leggere tensioni superiori a 5V utilizzando un semplice sistema di resistenze. Infatti in questo caso riusciamo ad avere un valore di lettura di tensione in DC da 0 a 30V senza creare ovviamente nessun tipo di danno al microcontrollore. Il tutto verrà trasmesso su un display LCD in modo da visualizzare la lettura della tensione in tempo reale. nel caso in cui non sia possibile utilizzare il display possiamo comunque leggere i valori nella porta seriale dwell'interfaccia di arduino collegandolo ad un computer.

schema di montaggio

voltometro con arduino

Codice

#include <LiquidCrystal.h>                  //includiamo la libreria per il controllo del display
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);      //pin collegati allo schermo LCD
  int analogInput = 0;
float vout = 0.0;
float vin = 0.0;
float R1 = 100000.0;                        // inseriamo il valore esatto della resistenza R1 (espressa in ohm)
float R2 = 10000.0;                         // inseriamo il valore esatto della resistenza R2 (espressa in ohm)
int value = 0;

void setup(){
   pinMode(analogInput, INPUT);             //input del voltaggio da leggere    
   lcd.begin(16, 2);                        //indica colonna e righe del nostro LCD
   lcd.print("VOLTMETRO DC");               //scrivi "VOLTOMETRO DC" sulla prima
   Serial.begin(9600);                      //inizializza la porta seriale
}
void loop(){
   value = analogRead(analogInput);
   
   vout = (value * 5.0) / 1024.0; 
   
   vin = vout / (R2/(R1+R2));               //legge il valore di tensione del partitore
   if (vin<0.09) {
   vin=0.0;                                 //nel caso di una tensione troppo bassa il voltometro segna 0V
} 
lcd.setCursor(0, 1);                        //imposta il cursore nella prima riga
lcd.print("INPUT V= ");                     //scrive nella seconda riga "INPUT V="
lcd.print(vin);                             //scrive il valore letto
delay(500);                                 
}

Conclusioni

Concludendo abbiamo realizzato uno strumento utile per misurare in modo preciso (utilizzando resistenze con una tolleranza molto bassa, consiglio quelle con valore 1% o inferiori) delle tensioni corrente continua da 0 a 30V, facilmente leggibili dal display LCD o in caso di mancaza di esso dalla porta seriale dall'IDE di arduino.