ARDUINO: PILOTARE IL REGOLATORE MST_K12 - 2



ITALIANO   ENGLISH    ESPAÑOL

 

IMPLEMENTAZIONE SOFTWARE

Ecco il codice per Arduino che può essere scaricato tramite il seguente link: Drive_MST_K12.zip Tramite l'interfaccia seriale del programma IDE di Arduino si inviano i comandi alla scheda che li traduce in comandi per il MST_K12:

I comandi sono:

a : accensione del regolatore al valore di regolazione fissato dal comando rxxx. Alla prima accensione bisogna aver impostato prima il valore di regolazione tramite il comando rxxx;

s : spegnimento del regolatore. Il valore di regolazione e' messo a zero mentre il valore impostato tramite il comando rxxx non viene perso ma memorizzato perché usato alla successiva accensione;

rxxx: imposta il valore di regolazione: xxx e' la percentuale di regolazione che può variare da 0 a 100; Quindi impostare il valore di regolazione senza aver mandato il comando di start non ha nessun effetto se non di aggiornare il valore di regolazione reso attivo solo dal comando di accensione.

q: ritorna lo status del motore e del livello di regolazione attuale;

/*PROGRAMMA CONTROLLO DEL REGOLATORE MST_K12 TRAMITE INTERFACCIA SERIALE BIDIREZIONALE
 Codice per pilotaggio del regolatore di velocità MST_K12. Collegando il pin 13 all'ingresso
 positivo VCNT del MST_K12 e l'ingresso negativo GND alla GND della scheda Arduino( MEGA) il regolatore potrà essere
 controllato inviando comandi tramite il monitor seriale della IDE dell'arduino con velocita settata a 9600.
 I comandi accettati sono i seguenti:

 a -  accende il MOTORE
 s -  spenge il MOTORE
 q - richiede lo stato del MOTORE.
     Possibili risposte:
     MOTORE acceso con regolazione xxx %
     MOTORE spento
     Regolazione impostata al xxx%
 r xxx - scrive un valore di regolazione in %. Possibili
 valori per "xxx" vanno da 0 a 100. Gli spazi sono ignorati.
 I caratteri accettati sono solo quelli numerici (da 0 a 9).
*/

//pin
const byte vcnt = 13; //pin di output pwm

//variabili globali
byte regolazione = 0;  //contiene il valore in % del pwm sul pin 13
int start =0;          // abilita la accensione del regolatore
void setup() {
 pinMode(vcnt,OUTPUT);
 analogWrite(vcnt, regolazione);
 Serial.begin(9600); // apro la seriale
 delay(1000); //attendo che l'utente faccia altrettanto
 Serial.println(F("Interfaccia Seriale Pronta ")); //sono pronto
 Serial.println(F(" a= accensione; s= spegnimento; rxxx = regolazione al xxx%; q= status motore"));
 
}

//programma principale
void loop() {
 int lettura; //contiene il valore di PWM letto dalla seriale
 unsigned long tempMillis; //serve per il timeout sulla ricezione del valore di PWM
 byte caratteri; //contiene il numero di caratteri ricevuti
 byte tempChar; //contiene il carattere letto

 //controllo se c'è qualcosa in arrivo sulla seriale
 if (Serial.available()) {
   byte command = Serial.read(); //leggo il primo byte
   switch (command) { //controllo che sia un comando valido
     case 'a': //accendo il MOTORE
       //;regolazione = 100;
       start =1;
       analogWrite(vcnt, start*regolazione*255/100);
       Serial.print(F("MOTORE"));
       Serial.print(F(" acceso con regolazione al "));
       Serial.print(regolazione, DEC);
       Serial.println("%");
       break;
     case 's': //spengo il MOTORE
       start=0;
       analogWrite(vcnt, 0);
       Serial.println(F("MOTORE spento"));
       break;
     case 'q': //l'utente vuole lo stato del MOTORE
       Serial.print(F("MOTORE "));
       if (start == 0) {
         Serial.print(F("spento"));
       } else if (start == 1) {
         Serial.print(F("acceso"));
       }
         Serial.print(F(" regolazione al "));
         Serial.print(regolazione, DEC);
         Serial.println("%");
      
       break;
     case 'r': //imposto il PWM sul MOTORE
       lettura = 0;
       tempMillis = millis();
       caratteri = 0;
       //mi servono altri caratteri
       do {
         if (Serial.available()) {
           tempChar = Serial.read();
           caratteri++;
           if ((tempChar >= 48) && (tempChar <= 57)) { //è un numero? ok
             lettura = (lettura * 10) + (tempChar - 48);
           } else if ((tempChar == 10) || (tempChar == 13)) {
             //con invio e/o nuova linea esco
             break;
           }
         }
         //esco per timeout, per un valore di PWM maggiore di 255
         //oppure per troppi caratteri senza senso ricevuti
       } while ((millis() - tempMillis < 500) && (lettura <= 100) && (caratteri < 10));
       //se il valore di PWM è valido, lo imposto sul pin
       if (lettura <= 100) {
         regolazione = lettura;
         analogWrite(vcnt, start*regolazione*255/100);
         Serial.print(F("regolazione impostata a "));
         Serial.print(regolazione, DEC);
         Serial.println("%");
        }
       break;
   }
   //svuoto il buffer da eventuali altri caratteri che non mi servono più
   while (Serial.available()) {
     byte a = Serial.read();
   }
 }
}

ACQUISTA

VIDEO

Il video seguente mostra la connessione del MST_K12 alla scheda Arduino Mega 2560 e il monitor del PC in cui gira il programma IDE di arduino nella modalità di monitor seriale per l'invio dei comandi