We-Mod-It | Das Forum von Moddern für Modder

Quellcode

/*
StativoStativo Firmware 0.9.5
Stand: 10.01.2014 2:21

Legende der Status LED:
GRUEN: Betriebsbereit. Motorsteuerung aktiv. Auf Aktion durch Nutzer wartend.
GELB: Aktiv. Anfahren der Startposition/Standbyeposition.
ORANGE: Aktiv. Startposition angefahren. Start der Nachfuehrung nach CAMIntervall.
ROT: Aktiv. Nachfuehrung und Kamerasteuerung aktiv.
BLAU: Pausiert. Motorueberhitzung. Luefterdrehzahl auf 100%. Wiederherstellung der Betriebstemperatur. Anfahren der Startposition nach Abkuehlung.

by Simon Krause und Alexander Schulz
*/

//------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------


#include "OneButton.h" //OneButton Bibliothek implementiert
#include "multiCameraIrControl.h" //multiCameraIrControl Bibliothek implementiert
#include "AccelStepper.h" //AccelStepper Bibliothek implementiert
#include "math.h" // Math Bilibothek implementiert

typedef enum {
  ACTION_NONE, //Steuerung aus - LEDs aus
  ACTION_ON,   //Steuerung betriebsbereit - gruene LED ein
  ACTION_1, //Steuerung aktiv - Nachfuehrung betreibsbereit/aktiv - gelbe/orange/rote LED ein
  ACTION_2, //Motor auf Standbyestellung - gelbe LED ein
} 
MyActions;

MyActions nextAction = ACTION_NONE; //Steuerung bei Start aus

#define EVER (;;)

//------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------

//---------------------------KALIBRIERUNG----------------------------

long startposition = 41500; //Startposition in Mikroschritten
long runposition = -56000; //Anschlag der Nachuehrung in Mikroschritten
int VR = 9; //Geschwindigkeit der Nachfuehrung
int VB= 2500; //Geschwindigkeit der Positionsanfahrung
unsigned long IRIntervall = 60000; //Intervall der IR-LED
unsigned long IRIntervallPause = 1000; //Zeit bis zur erneuten Ausloesung
unsigned int CAMIntervall = 15000; //Zeit bis zur Aktivierung der Nachfuehrung
int maxtemp = 50; //Maximale Temperatur des Spannungsreglers
float fanmintemp = 27; //minimale Temperatur der stufenlosen Lueftersteuerung
float fanmaxtemp = 35; //maximale Temperatur der stufenlosen Lueftersteuerung

//------------------------------MOTOR---------------------------------

AccelStepper stepper(1,3,2); //Motor Pins an 2 und 3
long steps; //Speicherung der aktuellen Position
boolean counted = false; //Hilfvariable fuer die Rotatefunktion
float rotatevelo; //Geschwindigkeit des Motors
int rotatecounter = 0; //Hilfvariable fuer die Rotatefunktion

//-------------------------HILFSVARIABLEN-----------------------------

int i; //Variable zur Aktivierung einzelner Sub-Aktionen
int status; //Variable zur Aktivierung/Deaktivierung einzelner Aktionen
unsigned long previousmillis = 0; //Hilfsvariable fuer Steuerung der IR-LED
unsigned long pausemillis = 0; //Hilfsvariable fuer Steuerung der IR-LED
int photo = 0; //Anzahl der aufgenommenen Fotos
int lastphoto = 1; //Hilfsvariable fuer Steuerung der erneuten Ausloesung
unsigned long PIntervall; //Hilfsvariable fuer verzoegerte Nachfuehrung

//------------------------LUEFTERSTEUERUNG-----------------------------

boolean fanstatus = true; //Lueftersteuerung ein- oder ausschalten
float printtemp; //Aktuelle Temperatur
int fandiftemp = fanmaxtemp - fanmintemp; //Differenz zwischen fanmaxtemp und fanmintemp fuer stufenlose Lueftersteuerung
boolean overheat = false; //Hilfvariable fuer Steuerung bei Ueberhitzung

//--------------------------STATUSAUSGABE------------------------------

unsigned long starttime;
unsigned long currentmillis;
int printsec; //Gesamtzeit der Nachfuehrdauer in Sekunden

//--------------------------KAMERASTEUERUNG----------------------------

Nikon SNikon(4); //IR LED fuer Nikon an PIN 4
Canon SCanon(4); //IR LED fuer Canon an PIN 4
Pentax SPentax(4); //IR LED fuer Pentax an PIN 4
Olympus SOlympus(4); //IR LED fuer Olympus an PIN 4
Sony SSony(4); //IR LED fuer Sony an PIN 4

//--------------------------EIN/AUSGAENGE------------------------------

OneButton button(A0, true); //Taster an PIN A1
#define DIR_PIN 2 //Richtung Easydriver an PIN 2
#define STEP_PIN 3 //Schritt Easydriver an PIN 3
int blue = 5; //blaue LED an PIN 5
int green = 6; //gruene LED an PIN 6
int mstop = 7; //Motorstop
int red = 9; //rote LED an PIN 9

//-----------------------------RGB-LED---------------------------------

int redvalue;
int greenvalue;
int bluevalue;
float brightness;
float fade;
float photobrightness = 0.25;

//------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------

void setup() {
  Serial.begin(9600); //Serialoutput auf Port 9600 aktiviert

  pinMode(DIR_PIN, OUTPUT); //PIN 2 als Output
  pinMode(STEP_PIN, OUTPUT); //PIN 3 als Output
  pinMode(5, OUTPUT); //PIN 5 als Output
  pinMode(6, OUTPUT); //PIN 6 als Output
  pinMode(7, OUTPUT); //PIN 7 als Output 
  pinMode(8, OUTPUT); //PIN 8 als Output
  pinMode(9, OUTPUT); //PIN 9 als Output
  pinMode(10, OUTPUT); //PIN 10 als Output
  pinMode(11, OUTPUT); //PIN 11 als Output
  
  stepper.setMaxSpeed(abs(4500)); //maximale Geschwindigkeit des Motors
  button.attachClick(myClickFunction); //Klick-Funktion implementiert
  button.attachDoubleClick(myDoubleClickFunction); //Doppelklick-Funktion implementiert  
  Serial.println("==== StativoStativo v1.0 =========================");
  Serial.println("Bedienungshilfe kann mit 'm' eingeblendet werden.");
} //Ende setup

//------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------

void loop() {
  steps = stepper.currentPosition(); //Aktuelle Position des Motors in Variable speichern
  unsigned long now = millis(); //Aktuelle Zeit in Variable speichern
  button.tick(); //Taster ueberpruefen
  printtemp = Thermister(analogRead(2)); //Temperatur kontinuierlich aktualisieren
  
if (Serial.available() > 0) //Steuerung ueber Serial
    {
    int comand = Serial.read(); //Daten in comand speichern
    if (comand == 49) // comand auswerten und Aktion durchfuehren; 49 = 1
      {
      myClickFunction();
      }
    if (comand == 50) // comand auswerten und Aktion durchfuehren; 50 = 2
      {
      myDoubleClickFunction();
      } 
    if (comand == 51) // comand auswerten und Aktion durchfuehren; 51 = 3
      {
        IRIntervall = 60000;
        printtime("Belichtungszeit",float(IRIntervall/1000));
      } 
     if (comand == 52) // comand auswerten und Aktion durchfuehren; 52 = 4
      {
        if (IRIntervall > 20000) {
        IRIntervall += -20000;
        printtime("Belichtungszeit",float(IRIntervall/1000));
        }
        else {
         Serial.println("Minimale Belichtungszeit von 20 Sekunden erreicht."); 
        }
      } 
     if (comand == 53) // comand auswerten und Aktion durchfuehren; 53 = 5
      {
        IRIntervall += 20000;
        printtime("Belichtungszeit",float(IRIntervall/1000));
      } 
      if (comand == 54) // comand auswerten und Aktion durchfuehren; 54 = 6
      {
        IRIntervall += 60000;
        printtime("Belichtungszeit",float(IRIntervall/1000));
      } 
      if (comand == 105) // comand auswerten und Aktion durchfuehren; 105 = i
      {
        info();
      } 
      if (comand == 109) // comand auswerten und Aktion durchfuehren; 109 = m
      {
        manual();
      } 
  }
  
  //---------------------------LUEFTERSTEUERUNG---------------------------
  
  if (fanstatus == true) {
    if (printtemp >= fanmintemp && printtemp <= fanmaxtemp) { //Stufenlose Lueftersteuerung
      analogWrite(10,((floor(185/fandiftemp)*(printtemp-fanmintemp) )+70));
    }
    else if (printtemp > fanmaxtemp) { //100% Drehzahl bei erhoeter Temperatur
      analogWrite(10,255);
    }
    else {
      analogWrite(10,0);
    }
  }
  
  //-------------------------TEMPERATURAKTIONEN---------------------------
  
  if (printtemp > maxtemp) { //Motorstopp bei Ueberhitzung - blaue LED ein
    digitalWrite(mstop, LOW); //Motorsteuerung aus
    RGB(0,0,255,1.0); //Status-LED auf blau
    digitalWrite(11, HIGH); //Buzzer ein
    if (overheat == false) { //einmalige Ausgabe der Ueberhitzung
      Serial.print("Achtung Ueberhitzung! ");
      Serial.print("Temperatur: ");
      Serial.print(printtemp);
      Serial.print(char(176));
      Serial.println("C");
      if (lastphoto == photo) { //ggf. Abbruch der Belichtung
         SNikon.shutterNow();
        /*SCanon.shutterNow();
        SPentax.shutterNow();
        SOlympus.shutterNow();
        SSony.shutterNow();*/
        photo = 0; //Zuruecksetzen der Variablen
        lastphoto = 1;
        }
      overheat = true;
      status = 0;
      rotatecounter = 0;
      i = 4;
      nextAction = ACTION_NONE;
    }
  }
   
  if (overheat == true && printtemp > (maxtemp-5) && (millis() % 1000 == 0)) { //regelmaessige Ausgabe der Temperatur bei Ueberhitzung
    Serial.print("Temperatur: ");
    Serial.print(printtemp);
    Serial.print(char(176));
    Serial.println("C");
  }
    
  if (overheat == true && printtemp < (maxtemp-5)) { //Aktion nach Wiederherstellung der Betriebstemperatur
    Serial.println("Betriebstemperatur wiederhergestellt!");
    digitalWrite(11, LOW); //Buzzer ausschalten
    nextAction = ACTION_2; //Steuerung betriebsbereit machen
    status = 5;
    i = 3;
    overheat = false;
  }
  
  //-------------------------ACTION_NONE--------------------------
 
  if (nextAction == ACTION_NONE) { //Steuerung aus - LEDs aus
    if (i == 3) {
      RGB(0,0,0,1.0); //Status LED aus
      digitalWrite(mstop, LOW); //Motorsteuerung aus
      Serial.println("Steuerung aus.");
    i=4;
    }
  }
  
  //--------------------------ACTION_ON---------------------------

  else if (nextAction == ACTION_ON) { //Steuerung betriebsbereit - gruene LED ein
    if (i == 3) {
      Serial.println("Steuerung betriebsbereit. Bitte gewuenschte Belichtungszeit einstellen. (Standart: 1 Minute)");
      RGB(0,255,0,1.0); //Status LED auf gruen
      digitalWrite(mstop, HIGH); //Motorsteuerung an
      status=0;
      photo=0;
      i=4;
    }
  }
  
  //--------------------------ACTION_1----------------------------

  else if (nextAction == ACTION_1) { //Steuerung aktiv - gelbe/orange/rote LED ein
    if (i < 5){ //Anfahren der Startposition - Warten auf Nachfuehrung
      if (status == 0) {
        Serial.println("Startstellung anfahren.");
        RGB(255,100,0,1.0); //Status-LED auf gelb
        status = 1;
      }
      if (status == 1) {
        rotate(VB,startposition); //Anfahren der Startposition von der Standbyestellung  
      }
      if (status == 2) { //Warten auf Nachfuehrung
        Serial.print("Nachfuehrung betriebsbereit. Kamera bereit machen. ");
        printtime("Belichtungszeit",float(IRIntervall/1000));
        PIntervall = millis();
        RGB(255,25,0,1.0); //Status-LED auf orange   
        photo = 0;
        lastphoto = 1;
        status = 3;
      }
      if (status == 3) { //Wartezeit bis Nachfuehrung
        if(millis() - PIntervall > CAMIntervall) {   
          previousmillis = millis();
          Serial.println("Nachfuehrung aktiv.");
          starttime = millis();
          i=5;
          status=4; 
        }
      }    
    }
    else if (i == 5) { //Nachfuehrung aktiv - Kamerasteuerung aktiv
      currentmillis = millis();
      printsec = round((millis() - starttime)/1000);
      if(currentmillis - previousmillis > IRIntervall){ //Kamerasteuerung und Statusausgabe
        previousmillis = currentmillis;   
        SNikon.shutterNow(); //Ausloesen der Kamera
        /*SCanon.shutterNow();
        SPentax.shutterNow();
        SOlympus.shutterNow();
        SSony.shutterNow();*/
        photo == photo++; //Anzahl der Fotos um 1 erhoeen
      } 
      if ((currentmillis - previousmillis > IRIntervallPause) && (photo != lastphoto)) {
         previousmillis = currentmillis;
         lastphoto = photo;
         SNikon.shutterNow(); //erneutes Ausloesen der Kamera
        /*SCanon.shutterNow();
        SPentax.shutterNow();
        SOlympus.shutterNow();
        SSony.shutterNow();*/
        info();
      }
      if (status == 4){
      rotate(VR,runposition); //Nachfuehrung ab Startposition zum Anschlag
      }
    if( (currentmillis - previousmillis > (IRIntervall-5000)) && (currentmillis - previousmillis < (IRIntervall-250))) {
      fade = float(IRIntervall-250-currentmillis+previousmillis)/4750;
      RGB((fade*255),0,((1.0-fade)*255),photobrightness);
    } else if( (currentmillis - previousmillis > (IRIntervall-250)) && (currentmillis - previousmillis < IRIntervall)) {
      fade = float(IRIntervall-currentmillis+previousmillis)/250;
      RGB(((1.0-fade)*255),0,(fade*255),photobrightness);
    } else {
      RGB(255,0,0,photobrightness);
    }
  }
}
  
  //--------------------------ACTION_2----------------------------

  else if (nextAction == ACTION_2) { //Anfahren der Standbyestellung - gelbe LED ein
    if (i == 3) {
      RGB(255,100,0,1.0);
      if (status == 5) {
        Serial.println("Standbyestellung anfahren.");
        status = 6;
        if (lastphoto == photo) { //ggf. Abbruch der Belichtung
         SNikon.shutterNow();
        /*SCanon.shutterNow();
        SPentax.shutterNow();
        SOlympus.shutterNow();
        SSony.shutterNow();*/
        photo = 0; //Zuruecksetzen der Variablen
        lastphoto = 1;
        }
      }
      if (status == 6) {
        rotate(VB,0); //Anfahren der Standbyestellung
      }
    }
    else if (i==4){ //Steuerung nach Anfahren der Standbyestellung betriebsbereit
      myDoubleClickFunction();
    }
  } 

}

//------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------

void myClickFunction() { //Aktionswechsel bei Klick
  i=3;  
  if (nextAction == ACTION_NONE){
    nextAction = ACTION_ON;
  }
  else {
    nextAction = ACTION_NONE;
  }
}

//------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------

void myDoubleClickFunction() { //Aktionswechsel bei Doppelklick
  i=3;
  rotatecounter = 0;
  if (nextAction == ACTION_ON) {
    status = 0;
    nextAction = ACTION_1;
  } 
  else if (nextAction == ACTION_1) {
    status = 5;
    Serial.println("Nachfuehrung beendet.");
    nextAction = ACTION_2;
  } 
  else if (nextAction == ACTION_2) {
    nextAction = ACTION_ON;
  }
}

//------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------

double Thermister(float RawADC) { //Funktion zur Temperaturbestimmung
 double Temp;
 Temp = log(((10240000/RawADC) - 10000));
 Temp = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp ))* Temp );
 Temp = Temp - 273.15; //Wert in Celsius konvertieren
 return Temp;
}

//------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------

void rotate(float velo, long GoToStep) { //Funktion zur Steuerung des Motors
  if (rotatecounter == 0) { //einmaliger Ablauf vor Aktion
    digitalWrite(mstop, HIGH); //Motorsteuerung ein
    counted = false;
    rotatecounter = 1;
    if (GoToStep <= steps) {
      rotatevelo = -1 * velo;
    }
    else {
      rotatevelo = velo;  
    }
  } 
  if (rotatevelo < 0.0) { //Bedingung fuer negative Geschwindigkeit
    if (GoToStep <= steps) {
      stepper.setSpeed(rotatevelo);
      stepper.runSpeed();
    }
    else {
      counted = true; 
    }
  }
  else if (rotatevelo > 0.0) { //Bedingung fuer positive Geschwindigkeit
    if (GoToStep >= steps) {
      stepper.setSpeed(rotatevelo);
      stepper.runSpeed();
    }
    else {
      counted = true; 
    }
  }
  if (counted == true) { //Aktionen nach Steuerung
    digitalWrite(mstop, LOW); //Motorsteuerung aus
    rotatecounter = 0; 
    if(status == 1) {
      status = 2;
      Serial.println("Startstellung angefahren.");
    } 
    else if (status == 6) {
      status = 0;
      i = 4;
      Serial.println("Standbyestellung angefahren.");
    } 
    else if(status == 4) {
      myDoubleClickFunction();
    }
  }
}

//------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------

void info() {
         Serial.println("==== Info ========================================");

        Serial.print("Anzahl Fotos: ");
        Serial.println(photo);
        printtime("Belichtungszeit",float(IRIntervall/1000));
        printtime("Verbleibende Belichtungszeit",float( (IRIntervall-currentmillis+previousmillis)/1000));
        Serial.print("Temperatur: ");
        Serial.print(printtemp);
        Serial.print(char(176));
        Serial.println("C"); 
}

//------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------

void RGB(int redvalue, int greenvalue, int bluevalue, float brightness) {
  analogWrite(green, int(round(greenvalue*brightness)));             
  analogWrite(blue, int(round(bluevalue*brightness)));
  analogWrite(red, int(round(redvalue*brightness)));
}
void manual(){
   Serial.println("==== Bedienungshilfe =============================");
   Serial.println("-- Moegliche Serialeingaben ----------------------");
   Serial.println("                           Simulierter Klick | 1 |");
   Serial.println("                     Simulierter Doppelklick | 2 |");
   Serial.println("        Belichtungsdauer auf 1 Minute setzen | 3 |");
   Serial.println("  Belichtungsdauer um 20 Sekunden verkuerzen | 4 |");
   Serial.println(" Belichtungsdauer um 20 Sekunden verlaengern | 5 |");
   Serial.println("    Belichtungsdauer um 1 Minute verlaengern | 6 |");
   Serial.println("                                        Info | i |");
   Serial.println("                      Bedienungshilfe/Manual | m |");
  /* Serial.println("-- Moegliche Aktionen ----------------------------");
   Serial.println("|        |     Steuerung aus");
   Serial.println("| aus    |  K: Anschalten der Steurung");
   Serial.println("|        | DK: -");
   Serial.println("\n|        |     Steuerung an");
   Serial.println("| gruen  |  K: Ausschalten der Steurung");
   Serial.println("|        | DK: Starten der Nachfuehrung");
   Serial.println("\n|        |     Startstellung anfahren");
   Serial.println("| gelb   |  K: Ausschalten der Steurung");
   Serial.println("|        | DK: Abbruch der Nachfuehrung");
   Serial.println("\n|        |     Warten auf Kamerakonfiguration");
   Serial.println("| orange |  K: Ausschalten der Steurung");
   Serial.println("|        | DK: Abbruch der Nachfuehrung");
   Serial.println("\n|        |     Nachfuehrung aktiv");
   Serial.println("| rot    |  K: Ausschalten der Steurung");
   Serial.println("|        | DK: Abbruch der Nachfuehrung");
   Serial.println("\n|        |     Motorueberhitzung");
   Serial.println("| blau   |  K: Ausschalten der Steurung");
   Serial.println("|        | DK: -");*/
}   
void printtime(String text,int seconds) {
  Serial.print(text);
  Serial.print(": ");
  if (float( (seconds % 86400) /3600) != 0){
    Serial.print(float( (seconds % 86400) /3600));
    if (float( (seconds % 86400) /3600) == 1) {
      Serial.println(" Stunde ");
    } else {
      Serial.println(" Stunden ");
    }
  }
  if (float( (seconds % 3600) /60) != 0){
    Serial.print(float( (seconds % 3600) /60),0);
    if (float( (seconds % 3600) /60) == 1){ 
      Serial.print(" Minute ");
    } else {
      Serial.print(" Minuten ");
    }
  }
  if (float(seconds % 60 != 0)) {
    Serial.print(float(seconds % 60),0);
    if (float(seconds % 60) == 1) {
      Serial.print(" Sekunde");
    } else {
      Serial.print(" Sekunden");
    }
  }
  Serial.print("\n");
}