ARDUINO: PILOTARE IL REGOLATORE MST_K12 - 2

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