[CarloRoma63]

Originalmente inviato da CarloRoma63

Arduino è una "scatola vuota", senza programma non sa fare nulla. Per istruirlo su cosa fare occorre scrivere un programma e caricarlo nella sua memoria.Carlo

Ecco il programma che uso sul Titanic. Fa molte cose:
- riceve i canali dalla radio, li interpreta e aziona i dispositivi di bordo
- controlla lo stato delle due batterie ed avvisa in caso di batterie scarche
- controlla il funzionamento dei bruciatori dei camini, avvisando in caso di assorbimenti anomali
- trasmette via seriale i dati di funzionamento (a scopo di debug)

il programma non è finito ma è funzionante. E' abbastanza commentato e quindi è comprensibile cosa fanno le varie parti

Carlo

/*
Programma di gestione del Titanic.
Gestisce l'argano salpa ancora, la sirena, il generatore di fumo ed il relativo ventilatore. misura le tensioni delle batterie, accende le luci di via e di sala.
In caso di problemi emette segnali acustici specifici.

*/



// ingressi analogici
byte sensorPin0 = A0; // Input per la misura della tensione della batteria motore
byte sensorPin1 = A1; // Input per la misura della tensione della batteria servizi
byte sensorPin2 = A2; // Input per la misura della tensione della corrente camini

// ingressi canali radio
byte pinCH1 = 2; // motore
byte pinCH2 = 4; // luci di via
byte pinCH3 = 12; // luci sala
byte pinCH4 = 7; // sirena
byte pinCH5 = 8; // salpa ancora
unsigned int durationCH1;
unsigned int durationCH2;
unsigned int durationCH3;
unsigned int durationCH4;
unsigned int durationCH5;

// Uscite pwm
byte pinVentola = 10; // Ventola
byte pinFumo = 11; // Generatore fumo
byte pinAncoraSu = 3; // Salpa ancora - polo positivo
byte pinAncoraGiu= 5; // Salpa ancora - polo negativo
byte pinBuzzer = 9; // altoparlantino

// Uscite digitali

byte pinSala = 6; // Luci di sala
byte pinVia = 13; // Luci di via

//

// Variabili e costanti
// sensori analogici
int sensorValue0 = 0; // tensione batteria motore
int sensorValue1 = 0; // tensione batteria servizi
int sensorValue2 = 0; // corrente camini
const float Trim0 = 0.78; //parametro di conversione tensione batteria motore
const float Trim1 = 1.19; //parametro di conversione tensione batteria servizi
const float Trim2 = 4.7; //parametro di conversione corrente camini.
const unsigned long massimo0 = 1000; // soglia massima della corrente assorbita dal generatore di fumo.
const unsigned long minimo0 = 600;// soglia minima della corrente assorbita dal generatore di fumo.
const unsigned long minimo1 = 900;// soglia di allarme per la tensione della batteria servizi
const unsigned long minimo2 = 600; // soglia di allarme per la tensione della batteria motore
// soglia di comando dei canali radio

const unsigned long sogliaCH2 = 1500;
const unsigned long sogliaCH3 = 1500;
const unsigned long sogliaCH4 = 1500;
const unsigned long sogliaCH5a = 1700; // salpa ancora in salita
const unsigned long sogliaCH5b = 1200; // salpa ancora in discesa

// variabili di appoggio generatore di fumo
int valFumo = 0;
int valFumoAtteso = 0;
int valVentola = 0;
int valMotore = 0;
int valMassimo = 220;
// variabile per contenere la velocità di funzionamento del salpa ancora.
int valAncora = 0;


void setup() {
// definisco i canai di input dalla radio
pinMode(pinCH1, INPUT); // clone del motore, usato per il generatore di fumo
pinMode(pinCH2, INPUT); // Luci di via
pinMode(pinCH3, INPUT); // luci saloni
pinMode(pinCH4, INPUT); // sirena
pinMode(pinCH5, INPUT); // salpa ancora

// stappo i condotti dell'aria azionando per tre secondi la ventola alla massima velocità.
analogWrite(pinVentola, 255);
analogWrite(pinFumo, 220); // regolare il valore per la corrente massima sopportata dai camini
delay (3000);
analogWrite(pinVentola, 0);
analogWrite(pinFumo, 0);
tone(pinBuzzer,500,100);
delay (100);
tone(pinBuzzer,600,100);
delay (100);
tone(pinBuzzer,700,100);
delay (100);
tone(pinBuzzer,800,100);
delay (100);
tone(pinBuzzer,900,100);
delay (100);
// inizializzo la seriale
Serial.begin(9600);
Serial.println("Sistema avviato.");

}

void loop() {
// Leggo i valori dei sensori:
sensorValue0 = analogRead(sensorPin0);
sensorValue0=sensorValue0*Trim0;
sensorValue1 = analogRead(sensorPin1);
sensorValue1=sensorValue1*Trim1;
sensorValue2 = analogRead(sensorPin2);
sensorValue2=sensorValue2*Trim2;

// verifico le tensioni di batteria

// Batteria motore: carica a 8,4V e scarica a 6,0V
if ( sensorValue0<600){
// beep per Batteria motore scarica
tone(pinBuzzer,1000,100);
delay(100);
Serial.println("Batteria motore scarica!");
}

// batteria servizi, carica a 12,6V e scarica a 9,0V
if ( sensorValue1<900){
// beep per Batteria servizi scarica
tone(pinBuzzer,1500,100);
delay(100);
Serial.println("Batteria servizi scarica!");

}

// leggo i canali radio
durationCH1 = pulseIn(pinCH1, HIGH);
if ( durationCH1>0){ // verifico che la radio sia accesa.
durationCH2 = pulseIn(pinCH2, HIGH);
durationCH3 = pulseIn(pinCH3, HIGH);
durationCH4 = pulseIn(pinCH4, HIGH);
durationCH5 = pulseIn(pinCH5, HIGH);


// Potenza del generatore di fumo
// Riceve il canale del motore (ch1, clone del ch8 se abilitato dallo switch ELE, altrimenti fisso a -100) e lo usa per regolare la potenza erogata
// riceve il segnale della corrente assorbita (sensore 2)
// comanda sia il generatore che la ventola
if ( durationCH1>1000){ // verifico che il fumo sia abilitato

/* if (valFumo>0 and sensorValue2<50){ // verifico se il generatore di fumo assorbe corrente. In caso negativo emetto segnale acustico come allarme.
tone(pinBuzzer,2500,100);
Serial.println("Generatore di fumo guasto!");
delay(100);
}
*/
if (valFumo>0 and sensorValue2>massimo0){ // verifico se il generatore di fumo assorbe troppa corrente. In caso positivo abbasso il valore massimo del pwm.
valMassimo=valMassimo-1;
}
valMotore = durationCH1 - 1455;
valFumoAtteso = abs(valMotore);
valVentola = map(valFumoAtteso,0,100,100,250); // verificare valori delle formule in base ai dati reali
if (valVentola > 255) { valVentola=255; }
valFumo = map(valFumoAtteso,0,100,70,valMassimo); //sostituire con la riga precedente quando verrà attivato il sensore di corrente.
if (valFumo > valMassimo) { valFumo=valMassimo; }

analogWrite(pinVentola, valVentola);
analogWrite(pinFumo, valFumo);

}else{ // Interrutto ELE in OFF, fumo spento.

analogWrite(pinVentola, 0);
analogWrite(pinFumo, 0);
}



// Salpa ancora. E' pilotato dal CH5, confrontato con le due soglie sogliaCH5a e sogliaCH5b

// imposto a OFF entrambi i canali del ponte ad H
analogWrite(pinAncoraSu, 0);
analogWrite(pinAncoraGiu, 0);

// calcolo la velocità di rotazione dell'argano in funzione del valore proveniente dalla radio.
// in questo modo posso regolare la velocità senza dover ricompilare lo sketch
valAncora = durationCH5 - 1455;

// eseguo la comparazione ed attivo il corrispondente canale del ponte ad H
if (durationCH5>sogliaCH5a) { // Ancora su.
analogWrite(pinAncoraSu, abs(valAncora)/10);
Serial.println("Ancora SU!");
};
if (durationCH5<sogliaCH5b) { // Ancora giù.
analogWrite(pinAncoraGiu, abs(valAncora)/10);
Serial.println("Ancora GIU!");
};



// sirena
if (durationCH4>sogliaCH4) { // Sirena.
tone(pinBuzzer,300);
}else{
noTone(pinBuzzer);
};


// luci di via
if (durationCH2>sogliaCH2) { // luci di via.
analogWrite(pinVia, 255);
}else{
analogWrite(pinVia, 0);
};


// luci di sala
if (durationCH3>sogliaCH3) { // luci di sala.
analogWrite(pinSala, 255);
}else{
analogWrite(pinSala, 0);
};

}else{
// beep per radio spenta
tone(pinBuzzer,2000,10);
delay(1000);
Serial.println("Radio spenta!");
}

// Serial monitor
if (false) {
Serial.print("Batteria Motore: ");
Serial.println(sensorValue0);
Serial.print("Batteria Servizi: ");
Serial.println(sensorValue1);
Serial.print("Corrente camini: ");
Serial.println(sensorValue2);
Serial.print("Ch1: ");
Serial.println(durationCH1);
Serial.print("Ch2: ");
Serial.println(durationCH2);
Serial.print("Ch3: ");
Serial.println(durationCH3);
Serial.print("Ch4: ");
Serial.println(durationCH4);
Serial.print("Ch5: ");
Serial.println(durationCH5);
Serial.print("valVentola: ");
Serial.println(valVentola);
Serial.print("valFumoAtteso: ");
Serial.println(valFumoAtteso);
Serial.print("valFumo: ");
Serial.println(valFumo);
}
delay(100);
}