Das VUSBduino-Logging-Keyboard       

 

/*
 Virtuelles Keyboard. Liest im einstellbaren Takt max. 4 Analog-Kanäle aus
 und schreibt die ADC-Werte ins aktuelle Fenster auf dem PC.

 Hardware: VUSB-ATtiny84

 Bedienkonzept: 3 Tasten; Konfigurationsdialog-Ausgabe per Keyboard.

 Zuordnung der Pins (erst Arduino-Notation, dann ATtiny-Hardware):

 Analog in:           A2 ... A5   PinA.2 ... PinC.5
 Aufnahme-Anzeige     Digital 8   PinB.2
 Tasten:
 Minus  Cancel        Digital 6   PinA.6
 Plus  Start          Digital 7   PinA.7
 Menue                Digital 8   PinB.2

 Menuepunkte:
        1: Anzahl Kanaele
        2: Multiplikator
        3: Zeit-Basiswert
        4: Start/Cancel
*/


#include <VUSB_Keyboard.h>
#include <Metro.h>

#define minus 6
#define cancel 6
#define plus 7
#define start 7
#define menu 8
#define led 8

Metro Timer = Metro(100);             // Wert ist in ms

unsigned char i;
unsigned char menue;
unsigned char mult_menue;
unsigned char chan;
unsigned char maxChan = 1 ;
unsigned char plusminus = 1;
unsigned int aVal[4] = {0};
unsigned int timerTicks;              // max. 12h -> 60 * 60 * 12 = 43200 -> unsigned int reicht
unsigned int timerInterval;
unsigned int base = 1;
unsigned int multiplicator = 1 ;
unsigned char timerIntervalSet;

void setup() {

  analogReference(DEFAULT);
  pinMode (minus, INPUT_PULLUP);
  pinMode (plus, INPUT_PULLUP);
  pinMode(menu, INPUT_PULLUP);

  VUSB_Keyboard.delay(2000);
}


void configure() {

  if (digitalRead(menu) == 0) {
    menue++;
    if (menue > 4) {
      menue = 1;
    }
    VUSB_Keyboard.delay (200);
  }

  switch (menue) {

    case 1:
      VUSB_Keyboard.println (F( "Menue Anyahl analoge Inputs" ));
      while (digitalRead(menu) == 1) {
        menu_analog_inputs() ;
      }
      break;
    case 2:
      VUSB_Keyboard.println (F( "Menue Multiplikator" ));
      while (digitalRead(menu) == 1) {
        menu_multiplicator() ;
      }
      break;
    case 3:
      VUSB_Keyboard.println (F( "Menue Basisyeit" ));
      while (digitalRead(menu) == 1) {
        menu_basiszeit() ;
      }
      break;
    case 4:
      VUSB_Keyboard.println (F( "Menue Messung" ));
      while (digitalRead(menu) == 1) {
        measure();
      }
      break;
  }
}


void menu_analog_inputs() {

  if (digitalRead(plus) == 0) {
    maxChan++ ;
    if (maxChan > 4) {
      maxChan = 1;
    }
    VUSB_Keyboard.print (F( "Analoge Inputs> " ));
    VUSB_Keyboard.println (maxChan);
  }
  VUSB_Keyboard.delay (200);
}


void menu_multiplicator() {

  if (digitalRead(plus) == 0) {
    mult_menue++;
    if (mult_menue > 4) {
      mult_menue = 1;
    }
    switch (mult_menue) {

      case 1:
        multiplicator = 1;
        VUSB_Keyboard.println (F( "Multiplikator> 100 msec" ));
        break;
      case 2:
        multiplicator = 10;
        VUSB_Keyboard.println (F( "Multiplikator> Sekunden" ));
        break;
      case 3:
        multiplicator = 600;
        VUSB_Keyboard.println (F( "Multiplikator> Minuten" ));
        break;
      case 4:
        multiplicator = 36000;
        VUSB_Keyboard.println (F( "Multiplikator> Stunden" ));
        break;
      default:
        multiplicator = 1;
        VUSB_Keyboard.println (F( "Multiplikator> 100 msec" ));
        break;
    }
  }
  VUSB_Keyboard.delay (200);
}


void menu_basiszeit() {

  if ((digitalRead(plus) == 0)  || (digitalRead(minus) == 0)) {
    if (digitalRead(plus) == 0) {
      plusminus++;
    }
    if (digitalRead(minus) == 0) {
      plusminus--;
    }
    if (plusminus > 60) {
      plusminus = 0;
    }
    if (plusminus < 16) {
      base = plusminus;
    }
    if (plusminus > 15) {
      base = (5 * (plusminus - 15) + 15);
    }
    timerInterval = base * multiplicator;
    if (timerInterval > 43200) {
      VUSB_Keyboard.println (F("Maximal 12 Stunden moeglich! Bitte neu waehlen! " ));
      plusminus = 1;
      timerInterval = 3600;
    }
    else {
      VUSB_Keyboard.print (F( "Basis )  " ));
      VUSB_Keyboard.print (base, DEC);
      VUSB_Keyboard.print (F( "     Multiplikator )  " ));
      VUSB_Keyboard.print (multiplicator, DEC);
      VUSB_Keyboard.print (F( "     Intervall )  " ));
      if (multiplicator < 10) {
        VUSB_Keyboard.print (timerInterval, DEC);
        VUSB_Keyboard.println (F( "00 msec" ));
      }
      else {
        VUSB_Keyboard.print (timerInterval / 10, DEC);
        VUSB_Keyboard.println (F( " sec" ));
      }
    }
  }
  VUSB_Keyboard.delay (200);
}


void measure() {

  if (digitalRead(start) == 0) {
    Timer.reset();
    pinMode(led, OUTPUT);
    digitalWrite(led, 0);                       // LED leuchtet bei LOW
    if (timerInterval == 0) {                   // falls ohne gesetztes timerInterval gestartet wurde
      timerInterval = 1;
    }
    timerTicks = timerInterval;                 // Ausgabe der ersten Werte sofort nach Start
    while (true) {                              // Kernschleife
      if (Timer.check() == 1) {                 // Sekunde um
        timerTicks++;
        if (timerTicks >= timerInterval) {      // gewaehltes Zeitintervall ist um
          timerTicks = 0;
          for (i = 0; i < (maxChan); i++) {     // Werte ausgeben
            aVal[i] = analogRead(i + 2 );
            aVal[i] = analogRead(i + 2 );
            VUSB_Keyboard.print(aVal[i], DEC);
            VUSB_Keyboard.print("\t");
          }
          VUSB_Keyboard.print("\r\n");
        }
      }
      if (digitalRead(cancel) == 0) {
        VUSB_Keyboard.println (F( "Ende" ));
        pinMode(led, INPUT);                    // LED aus, Pin wird wieder Input
        digitalWrite(led, 1);
        goto ende;
      }
    }
  }
ende:
  ;
}


void loop() {

  configure();                                         // Konfigurationstasten abfragen
  measure();

}