Solarflieger

// Arduino IDe 1.8.8
// Boardlayout  Lilypad Arduino USB
// Programmer: USBtinyISP (AtTinyCore)
// Hardware: Arduino ProMicro 3.3V, z.B. Sparkfun.com
// Pinout: 
// RAW: +Vsolar
// GND: -Vsolar, -Rx, -ESC
// D4: <= RX Signal Motor
// D5: => ESC Signal
//
// v64 23-02-2019
// can touch this
uint8_t   SERIALMONITOR = 1;             // default: 0 0=schaltet die serielle Debugausgabe ab,  1=schaltet sie ein. Durch Debug wird der Schleifendurchlauf stark verlangsamt. Niemals im Debug Mode Fliegen gehen ! 
float     VOLTCAL = 5.44;                // default: 5.45 ein Anpassungsfaktor für Messergebniskalibrierung der Solarspannung Mit Multimeter und Debugausgabe einleveln
uint8_t   Sprungwertpwmhoch = 1;         // default: 1  Sprungwert zur Anpassung des Regelverhaltens bei steigender Spannung 
uint8_t   Sprungwertpwmrunter = 10;      // default: 10  Sprungwert zur Anpassung des Regelverhaltens bei fallender Spannung 
uint16_t  Abbruchspannung = 510;         // default: 530 bei Erreichen von 5.30V oder weniger wird der Antriebsmotor ohne weiteren Regelzyklus ausgemacht um rc-blackout zu verhindern
uint16_t  UntereKnueppelgrenze = 1100 ;  // default: 1100 feste untere Grenze im uS des Gaswertes festlegen um Fehlmessungen im Bereich darunter zu egalisieren
uint16_t  ObereKnueppelgrenze  = 1900 ;  // default: 1900 feste obere Grenze im uS des Gaswertes festlegen um Fehlmessungen im Bereich darueber zu egalisieren
// touch no further



volatile uint16_t RC=0, DIFF=0, Solarvolt, VorherigeSolarspannung;
uint16_t MPP;

void setup() {    
           
    PORTD |= 0b00010000;                  // Read RC Pullup aktiviert
    TCCR1A = 0b00000000;                  // Read RC Normal PWM-Mode 
    TCCR1B = 0b01000010;                  // Read RC ICP aktivieren, Prescale 1/8
    TIMSK1 = 0b00100000;
    DDRC  |= 0b01000000;                  // PPM_OUT
    TCCR3A = 0b10000010;                  // PPM_OUT
    TCCR3B = 0b00011010;                  // PPM_OUT
    ICR3   = 2000;                        // PPM_OUT    
    OCR3A  = 1100;                        // 1100uS zum Init an den Regler ausgeben   ohhhhcr

    
    Serial.begin(500000);
    delay(2500);                         // warten bis Regler initialisiert ist 
}

void loop() {
  
while(TIFR3  & (1<<TOV3)){              // OVF -Flag abfragen, wenn gesetzt dann OVF1 Flag löschen,
      TIFR3 |= (1<<TOV3);               // Schleife rennt nun mit 500HZ sync zu PPM-OUT 
 

      
  if (SERIALMONITOR == 1)               // Serial Debug siehe Unterprogramm
      //serialdebug();   
      MPP  = 2400-RC;                   // MPP aus RC uebertragen
      ADMUX  = 0b11000110;              // ADC1 fuer Solarspannung waehlen
      ADCSRB = 0b00000000;
      uint16_t Utemp = 0;  

for  (int i=1; i <= 5; i++)             // zum Runden mehrfach lesen und addieren
     {            
      ADCSRA |= (1<<ADSC);  
      while (ADCSRA & (1<<ADSC)) ;
      Utemp = Utemp + ADC; 
      }    
Solarvolt = Utemp / VOLTCAL;      // bei 5 Durchläufen passt der Teiler von Variable VOLTCAL sehr genau


// #################### beginn regelkreis ##########
// Motornotausbedingungen auswerten : Solarspannung dramatisch gering oder Gasknueppel auf null ? daher pwm fuer null leistung zum esc senden



// ########## Solar komplett im Eimer - Knueppelstellung egal
if (Solarvolt <= Abbruchspannung) {
    OCR3A = UntereKnueppelgrenze;
    // Serial.println("STOPP: Kein Solar mehr da");
  }

// nix tun, da Leerlauf
else if (RC <= (UntereKnueppelgrenze + 10)) { // 10 ist ein Puffer, dass alles was < 1110 ist = 1100 gesetzt wird und Motor-STOPP erzwingt
    OCR3A = UntereKnueppelgrenze; 
    // Serial.println("STOPP: Leerlauf");
  }

// ########## Normalbetrieb - Regelkreis
// bei Solarspannungsabfall Motor herunterregeln, unabhaengig davon, was der Knueppelausschlag sagt
else if (VorherigeSolarspannung > Solarvolt) {
    // Abfrage verhindert, dass Knueppelstellung in den negativen Bereich wandert
    if (OCR3A > UntereKnueppelgrenze) {
        OCR3A = OCR3A - Sprungwertpwmrunter;
        // Serial.print("RUNTERREGELN weil Spannungseinbruch - Motorleistung: "); Serial.println(OCR3A);
      }
  }

// bei Solarspannungsanstieg / Solarspannung bleibt konstatnt
else if (VorherigeSolarspannung <= Solarvolt) {
    // ...und bereits erreichtem Knueppelausschlag
    if (OCR3A == RC) {
        // Serial.print("NIX TUN da nix vom Knueppel gefordert und Spannung groesser resp. konstant - Motorleistung: "); Serial.println(OCR3A);
      }
      
    // ...und noch nicht erreichtem Knueppelausschlag Motor heraufregeln
    else if (OCR3A < RC) {
        // Abfrage verhindert, dass Knueppelsteuerung in oberen Bereich ueberlauft
         if (OCR3A < ObereKnueppelgrenze) {
            OCR3A = OCR3A + Sprungwertpwmhoch;
            // Serial.print("HOCHREGELN weil Spannungszuwachs - Motorleistung: "); Serial.println(OCR3A);
          }
      }

    // ...und gefordertem Herunterregeln des Motors
    else if (OCR3A > RC) {
        // Abfrage verhindert, dass Knueppelstellung in den negativen Bereich wandert
        if (OCR3A > UntereKnueppelgrenze) {
          OCR3A = OCR3A - Sprungwertpwmrunter;
          // Serial.print("RUNTERREGELN da Knueppel zurueckgenommen - Motorleistung: "); Serial.println(OCR3A);
        }
      }
  }



else {
    // Serial.println("NIX von alledem");
  }

// +++++++++++++++++++ hier rausgenommen


//DIFF = Solarvolt - VorherigeSolarspannung;
//Serial.print(DIFF); Serial.print (Solarvolt); Serial.println (VorherigeSolarspannung);
VorherigeSolarspannung = Solarvolt;

// ########## kommende vier Zeilen einkommentieren fuer eine Ausgabe aller Randparameter
//Serial.print("Knueppelausschlag: "); Serial.print(RC);
//Serial.print(" Motorleistung: "); Serial.print(OCR3A);
//Serial.print(" Vorherige Solarspannung: "); Serial.print(VorherigeSolarspannung);
//Serial.print(" Jetzige Spannung: "); Serial.println(Solarvolt);

//serialdebug();


}}  


// # # # # # # # # # # Read-RC-ISR-Routine START # # # # # # # # # # //
ISR (TIMER1_CAPT_vect){
if  (PIND &(1<<PD4)){         // rising edge
    OCR1A  = ICR1;            // ICP-Timestamp in OCR1A zwischenspeichern
    TCCR1B = 0b00000010;      // ICP auf falling edge stellen
}else{                        // falling edge
    RC     = ICR1-OCR1A;      // RC berrechnen
    if (RC < UntereKnueppelgrenze) {RC = UntereKnueppelgrenze;};  //bei gemessenen Ausreissern nach unten feste Grenze setzen vom VariablenGrenzwert
    if (RC > ObereKnueppelgrenze) {RC = ObereKnueppelgrenze;};  //bei gemessenen Ausreissern nach oben feste Grenze setzen vom VariablenGrenzwert      
    TCCR1B = 0b01000010;      // ICP auf rising edge stellen
    TCNT1  = 0b00000000;      // Zähler zurücksetzen um Überläufe zu meiden   
}}


// # # # # # # # # # # SERIALDEBUG # # # # # # # # # # //
void serialdebug()                            // Wird mit ca. 2Hz ausgefuehrt
 {       
  static uint8_t loopcount; loopcount++;      // 2x pro Sekunde         
  if (loopcount == 0 )
   {         
    Serial.print("aktVolt ");   Serial.print(Solarvolt); 
    Serial.print("vorherigeVolt ");   Serial.print(VorherigeSolarspannung); 
    Serial.print(" Gasknüppelwert uS ");    Serial.print(RC);
    Serial.print(" PWM  zu ESC uS ");   Serial.print(OCR3A);
    Serial.println();
   }
  }

uint16_t RC, MPP, SVolt,  ICR1a;

void setup() { 
      DDRB   |= 0b01010100;     // ESC-PPM-OUT OC1B 32u4 = PB6(D10)
      PORTD  |= 0b00010000;     // READ-RC-IN  ICP1 32u4 = PD4(D4) 
      TCCR1A  = 0b00100011;     // Fast PWM,   OC1A as Top, OC1B is PWM
      TCCR1B  = 0b01011010;     // ICP-rising, Prescale 1/8
      TIMSK1  = 0b00100000;     // ICP-ISR activ
      OCR1A   = 2000;           // PPM-OUT Timer Top for 2mS 500Hz
      OCR1B   = 1050;           // Start PPM ESC      
      sei();    
      analogReference(INTERNAL);
      delay(2500);              //wait init ESC
}
 
void loop(){
while ( TIFR1   & (1<<TOV1))          // OVF -Flag abfragen, taucht alle 2mS auf.
{       TIFR1  |= (1<<TOV1);          // wenn gesetzt dann OVF1 Flag löschen. 
  
       //serialdebug();();            //Darf maximal 0,5mS dauer
        
      MPP     = 2200- RC;             // RC wird in die ADC range gewandelt                       
      SVolt   = 0;                    // SVolt zurücksetzen
      for(int i=1; i<=8; i++)         // Schleife zum ADC runden
{     SVolt  += analogRead(A0);       // alle ADC Werte addieren  
}     SVolt  /= 5.44;      // teilen und zugleich Kalibrieren

  if (SVolt > MPP) {if (OCR1B < 1900) {OCR1B += +1 + ((SVolt - MPP) / 5); }} //Voltage to high -inc PWM
  else             {if (OCR1B > 1050) {OCR1B += -1 - ((MPP - SVolt) / 5); }} //Voltage to high -dec PWM
}}}


ISR (TIMER1_CAPT_vect) {          // RC READ ISR  
if(TCCR1B   &  (1<<ICES1))        // we have rising edge -
{   TCCR1B &= ~(1<<ICES1);        // switch ICP to falling edge                                             
    ICR1a   =  ICR1;              // store ICP1 IN ICP1a
} else                            // we have falling edge
{   TCCR1B |=  (1<<ICES1);        // switch ICP @ rising edge                                               
 if (ICR1   <  ICR1a)             // if Overflow ? 
       {RC  =  ICR1+2000-ICR1a;}  // Yes > Calc RC with OVF
 else  {RC  =  ICR1     -ICR1a;}  // No  > Calc RC without OVF
}}

void serialdebug(){     //Immer maximal 3-4 Zeichen senden ! 
  static uint8_t loopcount; loopcount++;
  switch(loopcount){
  case  0:    Serial.print("MPP");    break;
  case  10:   Serial.print(MPP);      break; 
  case  20:   Serial.println("mV");   break;
  case  30:   Serial.print("SOL");    break;
  case  40:   Serial.print(SVolt);    break;
  case  50:   Serial.println("mV");   break;
  case  60:   Serial.print("PWM");    break;
  case  70:   Serial.print(OCR1B);    break;
  case  80:   Serial.println("mV");   break;
  }

 // serialdebug();
Serial.write(OCR1B / 8);
Serial.write(SVolt / 4);