Anzeige 
RC-Network Hangflugführer
Seite 2 von 5 ErsteErste 12345 LetzteLetzte
Ergebnis 16 bis 30 von 72

Thema: Software und Hardware für Solarflieger

  1. #16
    User Avatar von Holger Lambertus
    Registriert seit
    11.04.2002
    Ort
    31547 Rehburg
    Beiträge
    1.616
    Blog-Einträge
    3
    Daumen erhalten
    116
    Daumen vergeben
    79
    0 Nicht erlaubt!

    Standard GEILE IDEE

    Also maccl, für Deine Ideen sollte man Dich ######zensiert##########, ständig wirfst Du damit meine Projekte um, weil Du mit ner besseren Idee daherkommst, und mich auch neue dumme Gedanken bringst.

    Das mit dem Empfänger ist eigentlich genial, mir fällt da zuerst der 0,4g OpenSky - Usky Empfänger für FrSky ein, wegen dem ich schön öfter gedacht habe "FrSky müsste man haben"
    OpenSky: https://github.com/fishpepper/opensky

    Bilder: https://fishpepper.de/projects/usky/

    Man kann den Empfänger selber bauen, oder auch einfach für 7€ fertig kaufen, und dann umflashen;
    https://www.readytoflyquads.com/usky...-nano-receiver







    Dazu haben wir im Verein einen Informatischen Kollegen der stm32 liebt, und FrSky spricht, und auch schon länger mit dem uSky spielen will Dateien im KiCad passen auch, damit macht er auch am liebsten seine Platinen.
    Ein bissl werden wir wohl anpassen müssen, oder S-Bus Servos nehmen

    Ich werde die Tage mal mit ihm reden, Platinen kosten ja heute nix mehr, das wir da mal nen Stapel von machen lassen, SMD-Bestückung im Verein, und dann ran an die Software

    Du bist so gemein () Aber wenn wir das hinbekommen, wäre das GENIAL



    edit, will nur nen Link setzen, noch nicht kmpl. gelesen, könnte dazu passen.
    https://www.rcgroups.com/forums/show...3-DIY-FrSky-RX
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

  2. #17
    User Avatar von Holger Lambertus
    Registriert seit
    11.04.2002
    Ort
    31547 Rehburg
    Beiträge
    1.616
    Blog-Einträge
    3
    Daumen erhalten
    116
    Daumen vergeben
    79
    0 Nicht erlaubt!

    Standard

    Kurz mal zu den Artduinos

    Idee war beim USB-Tiny "Volk-MPP" ohne Telemetrie, für einen einfachen MPPC hat er alles was man braucht.
    Der Code rennt nicht auf dem Arduino, da die Register von dem Attiny44, die ich direkt beschreibe, anders aufgebaut sind als von dem 328p, der hat z.B. kein USI. u,s,w. da ich PPM direkt über die Timer einlese und schreibe, würde das bei einer anderen CPU Frequenz nicht mehr passen, die PPM für den Regler wären bei 16MHz statt 500Hz dann 625Hz. Aber es wäre trotzdem fix gemacht, das auf dem 328p umzusetzen.

    Spannungsteiler muss an jedem Board gelötet werden, das ist kein Unterschied. Mit einer ordentlichen Anleitung sollte jeder das Board bespielt bekommen, es gibt sicher in jedem Verein immer jemanden der evtl helfen kann, und wenn nicht, habe ich (und evtl noch ein paar andere) immer welche von den Dingern rumliegen, die fix verschickt sind (ohne Gewinn versteht sich, wenn es jemand mit Gewinn machen will, nur zu....).


    Telemetrie, -Dilemma.
    Hott habe ich mit 5V Hardware Uart nie vernünftig zum laufen bekommen, (einige haben damit schon den T-Port vom Empf. getötet).
    HArdware Uart mit 3,3V, Widerstand zwischen RX und TX, Empf an RX rennt bestens.
    Softuart bei der man den Pin in der Soft zwischen RX und TX ständig umschaltet, rennt auch mit 5V und der üblichen Z-Diode mit Widerstand.
    Softuart ohne blockieren ist aber frickelei ohne Ende, Interrupt über Pinchance, Uart über einen Timer die Bits einzelnd zusammenbasteln, u.s.w. und das darf sich dann nicht mit dem MPPC ins GEhege kommen.
    Hardware Uart macht die Arbeit im Hintergrund, denke das ist die wesentlich bessere Variante.

    Das nächste Dilemma, wenn man nun beim Arduino mit 328p den Widerstand für die Telemetrie zwischen rx und tx gelötet hat, dann funzt der Arduino-bootloader nicht mehr, beim Nano auch nicht über USB, da der Bootloader ja den einzigen Hardware-Uart mitbenutzt. Deshalb nehme ich da gerne den AVRootloader als Bootloader, und kann weiterhin bequem über das Servokabel flashen.

    Darum habe ich mit dem 32u4 3,3V Board gespielt, der hat nebem dem USB einen zweiten Uart den man für Hott nehmen kann. Zwei 16Bit Timer die man Holzhammermässig mit lesen und schreiben der PPM nutzen kann (purer Luxus), Zwei Timer bleiben die man für Hott als Timer nutzen kann (2mS Idle und die 5mS am Anfang).
    Es ist an sich das einzige günstige ArduinoBoard das alle Anforderungen erfüllt.
    Mit der Arduino-IDE rennt auch der Bootloader stabil. (als Lilipad USB für den 8MHz Leonardo)

    Das Bootloaderproblem tauchte auf wenn ich statt void setup(){} + void loop(){} das int main(void) { while(1){}} benutze, keine Ahnung warum, findet sich sicher noch, vorerst kann man aber damit leben, denk ich ?
    Fehler gefunden, es muss das drinnstehen:
    int main(void) {
    init();
    #if defined (USBCON)
    USBDevice.attach();
    #endif
    ...................

    Alternativ wäre noch der attiny841 gegen den der 328p sehr blass aussieht, 2(3) Uarts, 1x8Bit + 2 16Bit Timer, könnte MPPC + Hott-Telemetrie + SumD. Gibt es aber nicht fertig als Board, bzw nur mit-ohne Spannungs-Stabi bei Watterot als Nanite 841 mit V-USB.
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

  3. #18
    User
    Registriert seit
    15.04.2011
    Ort
    München
    Beiträge
    31
    Daumen erhalten
    2
    Daumen vergeben
    0
    0 Nicht erlaubt!

    Standard

    Zitat Zitat von Holger Lambertus Beitrag anzeigen
    Also maccl, für Deine Ideen sollte man Dich ######zensiert##########, ständig wirfst Du damit meine Projekte um, weil Du mit ner besseren Idee daherkommst, und mich auch neue dumme Gedanken bringst.
    sorry

    aber das ist dann halt leider kein VolksMPP mehr, sondern nur was FrSky-Nutzer

    ich werde mir das nicht an tun.

    aber ich freu mich wenn dur Spaß daran findest
    Like it!

  4. #19
    User
    Registriert seit
    15.04.2011
    Ort
    München
    Beiträge
    31
    Daumen erhalten
    2
    Daumen vergeben
    0
    0 Nicht erlaubt!

    Standard

    Zitat Zitat von Holger Lambertus Beitrag anzeigen
    Der Code rennt nicht auf dem Arduino, da die Register von dem Attiny44, die ich direkt beschreibe, anders aufgebaut sind als von dem 328p, der hat z.B. kein USI. u,s,w. da ich PPM direkt über die Timer einlese und schreibe, würde das bei einer anderen CPU Frequenz nicht mehr passen, die PPM für den Regler wären bei 16MHz statt 500Hz dann 625Hz. Aber es wäre trotzdem fix gemacht, das auf dem 328p umzusetzen.
    ok ich verstehe.
    dann macht es wohl sinn beim tiny zu bleiben

    was hälst du davon?
    hier kann man schön alle pins abgreifen und usb einfacher wegschneiden
    https://www.ebay.de/itm/Mini-Digispa...o/253689020433

    dein Code rennt hier drauf nehme ich an.
    Like it!

  5. #20
    User
    Registriert seit
    15.04.2011
    Ort
    München
    Beiträge
    31
    Daumen erhalten
    2
    Daumen vergeben
    0
    0 Nicht erlaubt!

    Standard

    Zitat Zitat von maccl Beitrag anzeigen
    bin hier über einen kleinen Nuri gestolpert der einen etwas anderen MPP verwendet.
    ich hab irgendwo gelesen das er auf deiner software basiert.
    weist du worin der unterschied liegt ?

    https://www.rcgroups.com/forums/show...ing-Free-plans
    hier ist der Code den ich meine

    Code:
    /*MPPT v6.3 for F5E RC Solar Airplane
    pin2 solar voltage coming off a divider. 1.1v max. 300k and pin2 across 47k to ground
    pin3 rc input comeing from rx
    pin4 rc output going to esc
    December 2017
    Sergey Vekli and Ted Luginbuhl
    __ __
    Reset -|o \/ |- VCC
    3 Rx -| |- 2 Solarvoltage
    4 ESC -| |- 1
    GND -|______|- 0
    */
    //#include <avr/wdt.h> // Watch Dog Timer
    #define Vmpp 0.55 // good setting: 0.84 for 12 cell and .55 for 8 cell. If too low motor will be faster at
    less than full throttle.
    #define VmppLOW 0.63 // low throttle mpp voltage. 0.97 seems to be good for 12 cell and .63 for 8
    cell.Set so that motor cuts off when parallel with suns rays.
    #define STEPdown 2 //default 2 If too high throttle will oscilate, if too low esc will reset
    #define STEPup 1
    #define iterations 15 //default 15. This is how many times the algo averages the array voltage.
    #define transition 150 // point at wich transition takes place from Vmpp to VmppLOW between 110
    and 230. Default 150.If too high it will kick in too soon and mimick Vmpp set too low.
    #define LOW false
    #define HIGH true
    int x = 0;
    int Vcell = 0;
    int VMPP = 0.00;
    int VMPPlow = 0.00;
    boolean cur_level = LOW;
    void setup()
    {
    // wdt_enable(WDTO_500MS); //Enable Watch Dog Timer.
    // set pins mode
    pinMode(4, OUTPUT); //going to esc
    pinMode(3, INPUT); //coming from rx
    //convert Vmpp to adc levels
    VMPP = Vmpp * 925;
    VMPPlow = VmppLOW * 925;
    //set freq and interrupts registers
    GIMSK = B00100000;
    PCMSK = B00001000;
    TCCR0A = B00000010;
    TCCR0B = B00000010;
    TIMSK = B00010000;
    OCR0A = 110;
    analogReference(INTERNAL1V1);
    }
    //main control timer
    ISR(TIMER0_COMPA_vect)
    {
    if (cur_level == HIGH)
    {
    digitalWrite(4, LOW);
    cur_level = LOW;
    }
    TCNT0 = 0;
    }
    //interrupt for rx repeater mode
    ISR(PCINT0_vect)
    {
    if (digitalRead(3) > cur_level)
    {
    digitalWrite(4, HIGH);
    cur_level = HIGH;
    TCNT0 = 0;
    }
    else
    {
    if (cur_level == HIGH)
    {
    digitalWrite(4, LOW);
    cur_level = LOW;
    }
    }
    }
    //main measurement-set cycle
    void loop()
    {
    //wdt_reset(); //Pat the dog
    if (OCR0A <= transition) // throttle level at wich higher Vmpp kicks in else statement.
    {
    x = VMPPlow;
    }
    else
    {
    x = VMPP;
    }
    Vcell=0;
    for (int XX = 0; XX < iterations; XX++) //iterations for average array voltage.
    {
    delay(1);
    Vcell = Vcell + analogRead(A1);
    }
    Vcell = Vcell / iterations;
    //Vcell=analogRead(A1);
    if (Vcell > x)
    {
    if (OCR0A <= 230 ) //230
    {
    OCR0A += STEPup;
    }}
    if (Vcell < x)
    {
    if (OCR0A >= 110) { //110
    OCR0A -= STEPdown;
    }}
    }
    Like it!

  6. #21
    User Avatar von Holger Lambertus
    Registriert seit
    11.04.2002
    Ort
    31547 Rehburg
    Beiträge
    1.616
    Blog-Einträge
    3
    Daumen erhalten
    116
    Daumen vergeben
    79
    0 Nicht erlaubt!

    Standard

    Hallo Maccl
    Das ist der Ukranduit-MPP, auch auf dem Attiny85. Ich finde es toll was er da macht, vor allem da er vielen Flugkollegen dort mit einer einfachen Lösung hilft. Der Attiny85 hat leider nur die 2x8Bit Timer. Die PWM ist dort 8Bit, 256Steps, da PPM 1-2mS davon die Hälfte, und die Randbereiche weg, ergeben sich etwa 100Regelschritte Auflösung, und der Arbeitspunkt wird manuel in der Software eingestellt. In dem ausgehendem Thread hatte ich eine 85er Soft gebastelt, 9Bit PWM, hat dann ca. 200Schritte Auflösung, und der MPP Arbeitspunkt ist vom Sender her per Gasknüppel wählbar.

    Bei dem ÚSBtiny werkelt da ein Attiny44 mit 16Bit PWM, der die volle Auflösung des Reglers nutzt, die meisten Regler können 800Steps.


    32u4 8MHz

    Ich hatte gestern ein bissl Zeit, und mal mit dem 32u4 Hott inkl dem PPM.Passthrough gespielt, Hott funzt soweit, Uart ist nicht so mein Ding, das geht bestimmt auch besser (weniger Blähcode in der ISR), ich stelle das mal unausgegoren und nur teil kommentiert hier rein, die Tage teste ich das mal ausgiebig.
    Diese Boards kosten auch um die 3-4€ in der Bucht, man kann den USB im "Vollbetrieb" weiternutzen, z.B. zum debug, oder evtl später Parameter per SerialTerm einzugeben, u.s.w. der 32u4 ist ungeahnter Luxus für mich, wenn nur diese blöde Arduino-IDE damit nicht wäre (nur damit rennt der stabil, irgendwas scheine ich im C zu missachten).
    Für die 3,3V Version sprechen auch 5mA statt 15mA Stromverbrauch.

    Funktioniert auch ohne Hott, also quasi universell. Jeti u.s.w. habe ich keine Aktien dran, das müsste dann wer anders einbauen.
    Wenn die Tage noch ein bissl Zeit finde, setze ich mich da noch bei den Feinheiten mal bei. Danach können ans sich schon die MPP-Routinen drauf.

    Für den "Anwender" wäre es zumindest sehr einfach, Arduino-IDE installieren, UBS-Kabel einstöpseln, Code (Datei) öffnen, auf den Pfeil drücken, fettich
    Ich würde es als "Universalboard" so in Raum werfen ?!? (Wir, also das Board und Ich, hatten anfangs so unsere gewissen Differenzen, sind mittlerweile aber dann doch noch Freunde geworden )

    Code:
    // Testroutine für das 8MHz 3,3V Arduinoboard mit dem 32u4 MCU. Nächster Schritt: Eingelesene PPM vom Empf. wird mit 500Hz an den
    // Regler weitergeleitet, als Drehzahl im Hottsender angezeigt, und auf dem Arduino Serialmonitor ausgegeben.
    // In der IDE bitte "Lilipad Arduino USB" benutzen. Der Code funktioniert ausschließlich auf einem 8MHz 32u4-Board ! 
    // Regler -- D9   
    // RC-Kanal -- D2 + D3 (beide!!)
    // Hott-T -- D0(Rx) + über einen 1,2K Widerstand nach D1(Tx)
    
    volatile uint8_t count;
    volatile uint8_t HOTT[45] = {0x7C,0x8D,0x00,0xD0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,
                                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7D,0x00};
    void setup() { 
        UBRR1L = 0b00011001;  // HOTT-UART wird auf 19200baud konfiguriert          
        UCSR1B = 0b10011000;  // Hott-RX+TX Interruptsteuerung wird aktiviert
        TIMSK4 = 0b01000000;  // Hott-Delay-Timer Comperator A als ISR aktiviert  
        TCCR4B = 0b00000000;  // Hott-Delay-Timer stoppen, falls kein Hott verwendet wird
                      
        DDRB  |= 0b00100000;  // Read RC 
        EICRA  = 0b00001011;  // Read RC // INT1=falling INT0=rising
        EIMSK  = 0b00000011;  // Read RC
        TCCR3A = 0b00000000;  // Read RC
        TCCR3B = 0b00000010;  // Read RC
            
        TCCR1A = 0b10000010;  // PPM_OUT
        TCCR1B = 0b00011010;  // PPM_OUT
        ICR1   = 2000;        // PPM_OUT         
        sei();      
    }
    void loop() {   
      // Serial.begin(19200); Serial.println( HOTT[28]); Serial.end();   
      HOTT[28]++;  
    }
    
    ISR(INT0_vect){ TCNT3 = 0b00000000;}    // Read RC rising edge, der Timer wird genullt
    ISR(INT1_vect){ OCR1A = TCNT3;     }    // Read RC falling edge, der Timer wird ausgewertet
    
    // -----------HOTT-ISR-Routinen--------------------------//
    ISR(USART1_RX_vect){
    if  (UDR1   == 0b10001101)           // Hott-GAM hat nach Daten gerufen, Senderoutine wird gestartet:
    {   UCSR1B   = 0b00001000;           // Hott-RX-Interrupt wird während der Senderoutine gesperrt,
        HOTT[44] = 0b00000000;           // Hott-Checksum auf Null stellen,
        count    = 0b00000000;           // Hott-Byte-Counter auf Null stellen,
        TCNT4    = 0b00000000;           // Hott-Delay-Timer auf Null stellen,
        OCR4A    = 0b10011110;           // Hott-Delay-Timer auf 5 mS stellen,
        TCCR4B   = 0b00001001;           // Hott-Delay-Timer starten.
    }}
    ISR(TIMER4_COMPA_vect){
    if  (count   > 0b00101101)           // Wenn alle Bytes gesendet sind
    {   TCCR4B   = 0b00000000;           // Hott-Delay-Timer stoppen
        UCSR1B   = 0b10011000;           // Hott-RX-Interrupt wieder aktivieren
    }else{ 
        HOTT[44] = HOTT[44] + HOTT[count]; // Hott-Checksum bauen                 //while (!(UCSR1A & (1<<UDRE1))){}    
        UDR1     = HOTT[count];          // Hott-Byte aktuell schreiben
        TCNT4    = 0b00000000;           // Hott-Delay-Timer auf Null stellen
        OCR4A    = 0b00111111;           // Hott-Delay-Timer auf 2 mS stellen 
        count++;                
    }}
    Irgendwie werde ich das Bild unten im Beitrag nicht los ??
    Miniaturansichten angehängter Grafiken Miniaturansichten angehängter Grafiken Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	photo_2018-11-08_13-50-15.jpg 
Hits:	10 
Größe:	79,9 KB 
ID:	2044112  
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

  7. #22
    User Avatar von Holger Lambertus
    Registriert seit
    11.04.2002
    Ort
    31547 Rehburg
    Beiträge
    1.616
    Blog-Einträge
    3
    Daumen erhalten
    116
    Daumen vergeben
    79
    0 Nicht erlaubt!

    Standard

    Kurzer Zwischenstand
    Ein paar Sachen verändert, Rc auslesen über ICP, da es etwas fluktuierte, der 32u4 hat keine ISR Prios. Ein paar andere Feinheiten, erstmal in Forum wegspeichern, ich hoffe das ich am WE Zeit finde, um alles noch zu kommentieren und den MPP als solche reinzubasteln.
    RC Anschluss nun D2+3+4 (ich löse INT0+1 aus, bei einer ICP-ISR müsste ich den Pin abfragen, da die drei Pins aber so hübsch nebeneinander liegen, kann man es auch nutzen). Regler nun abweichend D5, da ich Timer1 und 3 tauschen musste, um den ICP1 für RC zu nutzen.

    RC wird nun eingelesen, als 500Hz PPM an den Regler weitergeben, auf dem Sender als RPM angezeigt, und auf dem Serialmonitor angezeigt (das Serial.print dazu aktivieren).


    Code:
    volatile uint16_t RC=0;
    volatile uint8_t  HOTT[46] = {0x7C,0x8D,0x00,0xD0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                                  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7D,0x00};
    
    
    void setup() {
        UBRR1L = 0b00011001;  // HOTT-UART 19200 Baud         
        UCSR1B = 0b10011000;  // Hott-RX Interrupt aktiviert
        TCCR4A = 0b00000000;  // Hott-Delay-Timer läuft alle 2048uS über
        TCCR4B = 0b00000110;  // Hott-Delay-Timer Prescale 1/32
        TIMSK4 = 0b00000100;  // Hott-Delay-Timer Overflow ISR aktiviert 
        
        PORTD |= 0b00010000;  // Read RC Pullup aktiviert
        TCCR1A = 0b00000000;  // Read RC Normal PWM-Mode 
        TCCR1B = 0b01000010;  // Read RC ICP aktivieren, Prescale 1/8
        EIMSK  = 0b00000011;  // Read RC Interupts INT0 + INT1 aktiviert
        EICRA  = 0b00001011;  // Read RC Interrupt INT1=falling-edge INT0=rising-edge
    
        DDRC  |= 0b01000000;
        TCCR3A = 0b10000010;  // PPM_OUT
        TCCR3B = 0b00011010;  // PPM_OUT
        ICR3   = 2000;        // PPM_OUT
    
        sei();
        Serial.begin(19200);  
    }
    
    
    
    void loop() {
        OCR3A = RC;                       //Test RC(Senderknüppel)als 500Hz PPM ausgeben
        uint16_t  RPM = RC;               //Test RC(Senderknüppel)für RPM übernehmen
        HOTT[21] = (uint8_t)(RPM&255);    //Test RC als RPM auf dem Sender ausgeben 
        HOTT[22] = (uint8_t)(RPM >>8);    //Test RC als RPM auf dem Sender ausgeben
      //Serial.println(RC);  delay(50);   //Test RC auf Serialmonitor ausgeben. 
    }
    
    
    
    // ------------- Read-RC-ISR-Routinen ----------------- //
    ISR(INT0_vect){           // Read RC- rising edge
        OCR1A  = ICR1;        // Timestamp in OCR1A zwischenspeichern
        TCCR1B = 0b00000010;  // ICP auf falling edge stellen
    } 
    ISR(INT1_vect){           // Read RC- falling edge,
        RC     = ICR1-OCR1A;  // RC berrechnen
        TCCR1B = 0b01000010;  // ICP auf rising edge stellen
        TCNT1  = 0b00000000;  // Zähler zurücksetzen um Überläufe zu meiden    
    } 
    
    
    
    // ------------ HOTT-ISR-Routinen------------------------//
    ISR(USART1_RX_vect){
    if  (UDR1     == 0b10001101)      // Hott-GAM hat nach Daten gerufen, Senderoutine wird gestartet:
    {   UCSR1B     = 0b00001000;      // Hott-RX-Interrupt wird während der Senderoutine gesperrt,
        HOTT[44]   = 0b00000000;      // Hott-Checksum auf Null stellen,
        HOTT[45]   = 0b11111110;      // Hott-Counter-Byte zurücksetzen 3 OVFs Vorlauf für 6mS
        TCNT4      = 0b10000000;      // Hott-Delay-Timer zurücksetzen 1/2 Cycle abkürzen für 5mS
        TCCR4B     = 0b00000110;      // Hott-Delay-Timer starten, 2048uS pro Überlauf
    }}
    
    ISR(TIMER4_OVF_vect){             // Hott-Delay-Timer läuft im Sendebetrieb alle 2048uS über
    if  (HOTT[45]  < 0b00101101)      //  Solange noch nicht 45 alle Bytes gesendet sind, Sendung mit der Maus:
    {                                         //while (!(UCSR1A & (1<<UDRE1))){} <---WIRKLICH NÖTIG ??? 
        UDR1       = HOTT[HOTT[45]];  //  aktuelles Hott-Byte schreiben
        HOTT[44]   = HOTT[44]         //  Hott-Checksum HOTT[44] bauen, es wird nur das L-Byte gesammelt,
                   + HOTT[HOTT[45]];  //  und mit dem aktuellem Hott-Byte addiert.      
    }else{  
    if  (HOTT[45] == 0b00101101)      // Wenn alle 45 Bytes gesendet wurden, ist Sendeschluss: 
    {   TCCR4B     = 0b00000000;      //  Hott-Delay-Timer stoppen, keine OVFs mehr.
        UCSR1B     = 0b10011000;}     //  Hott-RX-Interrupt wieder aktivieren (Empfangsbereit -ohne GEZ).            
    }   HOTT[45] ++ ;                 //  Nach jedem Durchlauf wird das Hott-Counter-Byte um 1 erhöht. 
    }
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

  8. #23
    User Avatar von Holger Lambertus
    Registriert seit
    11.04.2002
    Ort
    31547 Rehburg
    Beiträge
    1.616
    Blog-Einträge
    3
    Daumen erhalten
    116
    Daumen vergeben
    79
    0 Nicht erlaubt!

    Standard

    Ist mir grad noch beim Frühstück eingefallen, das übliche synchronisieren über den PPM-Timer Überlauf wie gehabt, einfach das Serial-print als Timestamp für die Loop nutzen. Wir haben 2mS Zeit für den MPP Code in der Loop, besser deutlich weniger, bei 1500uS spätestens Schluss machen. Im Serialmonitor sieht man auch schön die etwas höhere Zeit, sobald man den Sender dazuschaltet, und die Hott-ISRs dazwischenfunken. Es sind kaum 10uS. Der "Blockierfreie" Hott Code funzt also

    die neue Loop:

    Code:
    void loop() {
    if (TIFR3  & (1<<TOV3)){       // sync with PWM-Timer 3, alle 2mS, Loop aber sollte nennenswert kürzer sein
        TIFR3 |= (1<<TOV3) ;       // OVF1 Flag löschen
    
        OCR3A = RC;                       //Test RC(Senderknüppel)als 500Hz PPM ausgeben
        uint16_t  RPM = RC;               //Test RC(Senderknüppel)für RPM übernehmen
        HOTT[21] = (uint8_t)(RPM&255);    //Test RC als RPM auf dem Sender ausgeben 
        HOTT[22] = (uint8_t)(RPM >>8);    //Test RC als RPM auf dem Sender ausgeben
    
        delay(1); //testweise 1000uS verplempern... 
    Serial.println(TCNT3);   //Zwischenzeit der Loop in uS ausgeben 
    }}
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

  9. #24
    User Avatar von Holger Lambertus
    Registriert seit
    11.04.2002
    Ort
    31547 Rehburg
    Beiträge
    1.616
    Blog-Einträge
    3
    Daumen erhalten
    116
    Daumen vergeben
    79
    0 Nicht erlaubt!

    Cool Update Alpha0-Version

    Heute scheint die Sonne, also habe ich mal fix einen 0815 MPPC mit drauf gespielt.
    im Display :
    erste Reihe; 63,0V entspricht 6,3V real
    zweite Reihe: 63,0A entspricht 6,3V MPP ,
    dritte Reihe: 17000rpm entspricht 1700uS Regler PPM
    unten links: ausgehende PPM in %
    unten rechts; MCU Temperatur vom Arduino.
    Das kann man noch irgendwann mal schicker anzeigen, so war es erst mal alles auf einen Blick.

    Die Regelung rennt noch etwas stockelig, aber es funzt soweit, man könnte damit sogar problemlos fliegen.




    Als nächstes aber erstmal den Code aufräumen, (und blöde Kommentare drannbibben).
    Ich stell die "Alpha-minus3 Version trotzdem mal ein Datensicherung (falls das hier überhaupt jemand interessiert)

    Code:
    // MPPC testversion für Solarmodelle !! Beschreibung und Fragen im RC-N Forum.
    // In der IDE bitte "Lilipad Arduino USB" benutzen. 
    // Der Code funktioniert ausschließlich auf einem 8MHz 32u4-Board ! 
    // Regler -- D5  --------> gibt das Reglersignal in 500Hz aus. 
    // RC-Kanal -- D2 + D3 + D4 ---> liest den Gaskanal des Senders ein
    // Hott-Telemetriebuchs -- D0(Rx) + über einen 1,2K Widerstand nach D1(Tx)
    // Solarspannung A1 über Spannungsteiler Aref = 2,56V
    
    #define Telemetrie_HOTT        // Telemetrie_HOTT Telemetrie_OFF Telemetrie_JETI   ......   
    
    volatile uint16_t RC=0, U_SOL, MPP, Temp;
    
    void setup() {               Serial.begin(500000);
        PORTD |= 0b00010000;  // Read RC Pullup aktiviert
        TCCR1A = 0b00000000;  // Read RC Normal PWM-Mode 
        TCCR1B = 0b01000010;  // Read RC ICP aktivieren, Prescale 1/8
        EIMSK  = 0b00000011;  // Read RC Interupts INT0 + INT1 aktiviert
        EICRA  = 0b00001011;  // Read RC Interrupt INT1=falling-edge INT0=rising-edge
    
        DDRC  |= 0b01000000;  // PPM_OUT
        TCCR3A = 0b10000010;  // PPM_OUT
        TCCR3B = 0b00011010;  // PPM_OUT
        ICR3   = 2000;        // PPM_OUT}    
    
        TELEMETRIE_init();
        OCR3A = 1100; //Regler initialisieren 
        delay(2500);  //warten bis Regler initialisiert ist 
    }
    
    void loop() {
    while (TIFR3  & (1<<TOV3)){       // sync with PWM-Timer 3, alle 2mS, Loop aber sollte nennenswert kürzer sein
           TIFR3 |= (1<<TOV3) ;       // OVF1 Flag löschen      
    
           MPP =  RC/2.1;        // Professor-ium für 12Zellen 2,1
           TELEMETRIE_send();                   
           analog_Read();       //liest Solarspannung und Temp-Sensor
    
      if (MPP > U_SOL)  {if (OCR3A > 1100 ) {OCR3A--;}} // MPPC Voltage to Low
      else              {if (OCR3A < 1900 ) {OCR3A++;}}   // MPPC Voltage to High 
    
    Serial.println(TCNT3);   //debug (TCNT3 gibt die verbrauchte Zeit in mS der Loop aus)
    }}
    
    
    
    // ----------------------- analog_Read setup START ----------------- //
    void  analog_Read(){
          ADMUX  = 0b11000111; //ADC Tempsensor
          ADCSRB = 0b00100000;
          ADCSRA = 0b11000110;     
          while (ADCSRA & (1<<ADSC)) ;
          Temp = ADCW-277;         //KALIBRIEREN !!!!
          
          ADMUX  = 0b11000110; //ADC6
          ADCSRB = 0b00000000;
          uint16_t Utemp = 0; 
    for  (int i=1; i <= 5; i++){    
          ADCSRA |= (1<<ADSC);  
          while (ADCSRA & (1<<ADSC)) ;
          Utemp = Utemp + ADC; 
    }     U_SOL = Utemp / 7.13;       // auf centiVolt realwert kalbrieren mit 7,13
    }// ----------------------- analog_Read  setup ENDE ----------------- //
    
    
    // ----------------------- Read-RC-ISR-Routinen ----------------- //
    ISR(INT0_vect){           // Read RC- rising edge
        OCR1A  = ICR1;        // Timestamp in OCR1A zwischenspeichern
        TCCR1B = 0b00000010;  // ICP auf falling edge stellen
    } 
    ISR(INT1_vect){           // Read RC- falling edge,
        RC     = ICR1-OCR1A;  // RC berrechnen
        TCCR1B = 0b01000010;  // ICP auf rising edge stellen
        TCNT1  = 0b00000000;  // Zähler zurücksetzen um Überläufe zu meiden    
    }// ----------------------- RPM_IN_OUT setup ENDE ----------------- //
    
    
    // ------------------------HOTT TELEMETRIE BEGIN ------------------//
    #ifdef Telemetrie_HOTT 
     
    volatile uint8_t  HOTT[46];
       
    void TELEMETRIE_send(){     //https://github.com/Ziege-One/Strom2Hott/blob/master/Message.h
        HOTT[0]   = 0x7C;
        HOTT[1]   = 0x8C; 
        HOTT[3]   = 0xC0;
        HOTT[6]   = (uint8_t)(U_SOL&255);     //#06 voltage 0.1V steps. 55 = 5.5V
        HOTT[7]   = (uint8_t)(U_SOL>>8);      //#07 MSB
        HOTT[8]   = (uint8_t)(MPP&255);       //#08 voltage min 0.1V steps. 55 = 5.5V     
        HOTT[9]   = (uint8_t)(MPP >>8);       //#09 MSB    
      //HOTT[10]  = (uint8_t)(mAh);           //#10 used battery capacity in 10mAh steps
      //HOTT[11]  = (uint8_t)(mAh);           //#11 MSB                                          
        HOTT[12]  = Temp+20;                  //#12 Temperature 1. Offset of 20. a value of 20 = 0°C)  
      //HOTT[13]  = Temp1B;                   //#13 Temperature 1. max Offset of 20. a value of 20 = 0°C
        HOTT[14]  = (uint8_t)(MPP&255);       //#14 current in 0.1A steps 100 == 10,0A 
        HOTT[15]  = (uint8_t)(MPP >>8);       //#15 MSB
      //HOTT[16]  = (uint8_t)(AmpMax);        //#14 current in 0.1A steps 100 == 10,0A
      //HOTT[17]  = (uint8_t)(Amp_Max);       //#15 MSB
        HOTT[18]  = (uint8_t)(OCR3AL);        //#18 RPM in 10 RPM steps. 300 = 3000rpm   
        HOTT[19]  = (uint8_t)(OCR3AH);        //#19 MSB
        HOTT[20]  = (uint8_t)(0x6c);          //#18 RPM max in 10 RPM steps. 300 = 3000rpm   
        HOTT[21]  = (uint8_t)(0x07);          //#19 MSB    
        HOTT[22]  = OCR3A/8-117;              //#22 Temperature 2. Offset of 20. a value of 20 = 0°C
      //HOTT[23]  = Temp2A;                   //#23 Temperature 2. max Offset of 20. a value of 20 = 0°C  
        HOTT[43]  = 0x7D;
    }
    
    void TELEMETRIE_init(){
        UBRR1L    = 0b00011001;     // Hott-UART 19200 Baud         
        UCSR1B    = 0b10011000;     // Hott-RX Interrupt aktiviert
        TCCR4A    = 0b00000000;     // Hott-Delay-Timer läuft alle 2048uS über, wird erst in der Hott-ISR gestartet
        TCCR4B    = 0b00000000;     // Hott-Delay-Timer STOP, damit ohne Hott steht, aktiviert sich in der Hott-ISR
        TIMSK4    = 0b00000100;     // Hott-Delay-Timer Overflow ISR aktiviert 
    }
    
    ISR(USART1_RX_vect){
    if  (UDR1    == HOTT[1])         // Hott hat nach Daten gerufen, Senderoutine wird gestartet:
    {   UCSR1B    = 0b00001000;      // Hott-RX-Interrupt wird während der Senderoutine gesperrt,
        HOTT[44]  = 0b00000000;      // Hott-Checksum auf Null stellen,
        HOTT[45]  = 0b11111110;      // Hott-Counter-Byte zurücksetzen 3 OVFs Vorlauf für 6mS
        TCNT4     = 0b10000000;      // Hott-Delay-Timer zurücksetzen 1/2 Cycle abkürzen für 5mS
        TCCR4B    = 0b00000110;      // Hott-Delay-Timer starten, 2048uS pro Überlauf, Prescale 1/8
    }}
    
    ISR(TIMER4_OVF_vect){             // Hott-Delay-Timer läuft im Sendebetrieb alle 2048uS über
    if  (HOTT[45] < 0b00101101)       //  Solange noch nicht 45 alle Bytes gesendet sind, Sendung mit der Maus:
    {                                         //while (!(UCSR1A & (1<<UDRE1))){} <---WIRKLICH NÖTIG ??? 
        UDR1      = HOTT[HOTT[45]];   //  aktuelles Hott-Byte schreiben
        HOTT[44]  = HOTT[44]          //  Hott-Checksum HOTT[44] bauen, es wird nur das L-Byte gesammelt,
                  + HOTT[HOTT[45]];   //  und mit dem aktuellem Hott-Byte addiert.      
    }else{  
    if  (HOTT[45]== 0b00101101)       // Wenn alle 45 Bytes gesendet wurden, ist Sendeschluss: 
    {   TCCR4B    = 0b00000000;       //  Hott-Delay-Timer stoppen, keine OVFs mehr.
        UCSR1B    = 0b10011000;}      //  Hott-RX-Interrupt wieder aktivieren (Empfangsbereit -ohne GEZ).            
    }   HOTT[45] ++ ;                 //  Nach jedem Durchlauf wird das Hott-Counter-Byte um 1 erhöht. 
    }
    #endif // ------------------------HOTT TELEMETRIE ENDE ----------------------------------------//
    
    
    #ifdef Telemetrie_JETI //Platzhalter für JETI Telemetrie
    void TELEMETRIE_send(){}
    void TELEMETRIE_init(){}
    #endif
    
    #ifdef Telemetrie_OFF  //Platzhalter für mit-ohne Telemetrie
    void TELEMETRIE_send(){}
    void TELEMETRIE_init(){}
    #endif
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

  10. #25
    User Avatar von derjuwi
    Registriert seit
    15.08.2005
    Ort
    Hamburg
    Beiträge
    457
    Daumen erhalten
    8
    Daumen vergeben
    1
    0 Nicht erlaubt!

    Standard

    Hi!

    ehrlichgesagt ist das keine sehr gute regelperformance. Vermutlich zum Teil dem Hott Telemetriekram geschuldet. Deine Spannung ist instabil selbst auf deinem langsamen Hott Feedback ablesbar schwankend, du hast einbrueche bis auf 5V und Ueberschwinger ohne Ende...

    Ich biete dir hiermit nochmal an deine Regelungsstechnik zu analysieren und dir zu helfen. Das ist so wie es ist nicht gut.

    Du willst ohne RC Akku fliegen... So wird das nix.

    Gruesse Julian
    Like it!

  11. #26
    User Avatar von Holger Lambertus
    Registriert seit
    11.04.2002
    Ort
    31547 Rehburg
    Beiträge
    1.616
    Blog-Einträge
    3
    Daumen erhalten
    116
    Daumen vergeben
    79
    0 Nicht erlaubt!

    Standard

    Moin Julian

    Danke
    guggsd du hier "quote': Heute scheint die Sonne, also habe ich mal fix einen 0815 MPPC mit drauf gespielt. "Die Regelung rennt noch etwas stockelig," >>>> ich würde es sogar grotttig nennen, ging ja nur um fix die Grundfunktion mal auszutesten. Mit der Reglung geht es ja jetzt erst los. In Kooperation mit Telemetrie ist für mich Neuland, aber interessant

    Dadurch das die Regelschleife nur noch mit 500Hz rennt, ist das so mit nur PWM ++ und -- natürlich viel zu langsam, das schwingt über, weil es schlicht zu träge ist.

    Bei meiner aktuellen Steuerung bin ich in der loop ja mit den 4KHz OneShot synchronisiert, da ist das kein Problem, Sind die Abweichungen groß, regelt er in jedem Durchlauf, werden sie kleiner, dann nur jedes zweite Mal, noch kleiner, dann jedes vierte Mal, u.s.w. bis 16. Das funzt super, die Spannung steht wie angenagelt, und in der Ausgangs-PPM pumpt und schwingt es nicht
    Zeit für Telemetrie ist so da aber nicht mehr, darum wieder 500Hz.


    Hatte vorhin auch mal fix nen professorisches P dazugebastelt, (wenig Zeit....) selbst das ist schon ein Unterschied wie Tag und Nacht, bleibt so vermutlich aber auch nicht - .

    Code:
    //P= je grösser die Abweichung je grösser die Regelschritte. Je kleiner der Wert, desto größer die Schritte
     uint8_t P = 10; 
     if (U_SOL > MPP)   {if (OCR3A < 1900 ) {OCR3A += +1 + ((U_SOL - MPP) / P); }}  
     else               {if (OCR3A > 1100 ) {OCR3A += -1 - ((MPP - U_SOL) / P); }}

    So ungefähr wollte ich das mal ausprobieren (PI-mitohneD) , Spielecode, Ausgabe in 100er Slow-Motion -I schwingt noch hinterher....
    Code:
    int P = 2;        //P-Anteil -Userwert
    int I = 2;        //I-Anteil -Userwert
    
    uint16_t VOLT=  610;  //U-IST dummywert für Spannung
    
    uint16_t  MPP=  630;  //U-SOLL
    
    uint16_t PWM=1500;
    int PID_i[10];        //ARRAY für I-Anteil
    int z;                //Zähler
    
    void setup() {Serial.begin(19200);}
    void loop() {   
    
    PID_i[z] = VOLT-MPP;     // IST minus SOLL Regelung verdreht als PID-üblich, da durch abfallende PWM die Spannung steigt.
    
    int temp = 0;   for(int i = 0; i <10 ; i++)    {temp += PID_i[i];}    temp = temp / 10;
    
    int PID_I = temp / I;
    int PID_P = PID_i[z] / P;
    
    z++; if(z>10){z=0;}
    
    PWM += +PID_I +PID_P;
    
    if(PWM>1900){PWM=1900;}
    if(PWM<1100){PWM=1100;}
    
    Serial.print("  P:");Serial.print(PID_P);
    Serial.print("  I:");Serial.print(PID_I);
    Serial.print("  PWM:");Serial.println(PWM);delay(200);
    }
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

  12. #27
    User
    Registriert seit
    15.04.2011
    Ort
    München
    Beiträge
    31
    Daumen erhalten
    2
    Daumen vergeben
    0
    0 Nicht erlaubt!

    Standard

    Hi Holger

    sieht doch gar nicht so schlecht aus.

    aber nochmal zur Hardware.

    Du hast das jetzt für den 32u4 bzw 328p geschrieben richtig?

    Hab mir in der Zwischenzeit mal einen USB-Tiny-ISB mit Attiny44 und Attiny85 besorgt, um auch mal deine Vorgängerversionen und den Ukranduit zu testen. Aber es macht vermutlich keinen Sinn oder?

    Ist nur etwas schwierig in dem "Solarflieger"-Fred die Code-Schnipsel zu finden.

    Wäre dir wirklich sehr sehr sehr dankbar wenn du das mal bei Github reinstellen könntest.
    und evtl alle Versionen mit allen Board-Optionen

    DANKE

    Gruß Maccl
    Like it!

  13. #28
    User
    Registriert seit
    15.04.2011
    Ort
    München
    Beiträge
    31
    Daumen erhalten
    2
    Daumen vergeben
    0
    0 Nicht erlaubt!

    Standard

    nettes Feature:
    die PID - Werte könnte man in Zukunft via Textmode ändern, dann könnt man am Platz einfach Anpassungen vornehmen.
    Like it!

  14. #29
    User Avatar von derjuwi
    Registriert seit
    15.08.2005
    Ort
    Hamburg
    Beiträge
    457
    Daumen erhalten
    8
    Daumen vergeben
    1
    0 Nicht erlaubt!

    Standard

    Eine Solarzelle ist kein System das man per PI oder PID regeln kann, resp. muss. Eine Solarzelle hat keine Masse die beschleunigt werden muss und keine Traegheit in ihrer Reaktion.
    Auserdem ist sie nichtstetig in ihrem Verhalten, eine erhoehung der PWM kann einen Anstieg und einen Abfall der Leistung bewirken.

    Am besten hat bei mir immer ein schwingender Regler mit geringer Hysterese funktioniert. Bei nur 500Hz Stellfrequenz muss man aber hier dolle aufpassen um nicht wie oben Holle in seinem Beispiel instabil zu werden.

    Die Regelfrequenz mit der ein Regler laeuft darf nicht hoeher sein als die Haelfte der Zeit die der Regler braucht um die Aenderung zu sehen die er gestellt hat.


    Ist ja auch logisch, sonst sieht man ja noch garnicht den Erfolg der Massnahme.

    Ein neuer Durchlauf der Regelschleife darf erst erfolgen wenn der Ausgangswert ueber den Motorsteller zur PWM erhoehung und damit zur Veraenderung der Solarspannung gefuehrt hat. Die dafuer erforderliche Zeit ist mindestens zu verdoppeln um sauber abtasten zu koennen.

    Bei 500Hz und einer schnellen uebernahme des RC Wertes in echte MotorPWM wuerde ich mal aus dem Bauch schaetzen das nach 10ms ca. ein neuer Spannungswert messbar sein sollte. Die Regelschleife sollte also max. mit 50Hz(2*10ms) laufen... Das ist keine pessimistische Schaetzung, eher optimistisch.

    Gruesse Julian
    Like it!

  15. #30
    User Avatar von lastdownxxl
    Registriert seit
    06.11.2010
    Ort
    Überlingen
    Beiträge
    907
    Blog-Einträge
    2
    Daumen erhalten
    100
    Daumen vergeben
    5
    0 Nicht erlaubt!

    Standard

    Zitat Zitat von derjuwi Beitrag anzeigen
    Die Regelfrequenz mit der ein Regler laeuft darf nicht hoeher sein als die Haelfte der Zeit die der Regler braucht um die Aenderung zu sehen die er gestellt hat.
    Hallo Julian,

    die Abtastzeit TA bei einem digitalen Regler muss kleiner als die bestimmende Systemzeitkonstante Ts der Regelstrecke. Ansonsten bekommt der Regler änderungen im Istwert nicht schnell genug mit. Die Abtastfrequenz (Reglerfrequenz) muss also höher sein als...

    Gruß
    Micha
    Like it!

Seite 2 von 5 ErsteErste 12345 LetzteLetzte

Ähnliche Themen

  1. Antworten: 5
    Letzter Beitrag: 02.04.2017, 11:19
  2. Antriebsvarianten für Solarflieger
    Von GC im Forum Elektroflug
    Antworten: 49
    Letzter Beitrag: 12.06.2016, 11:12
  3. Jeti DC/DS-16 TX 3.0 Software und 3.22 RX Software online
    Von PW im Forum Fernsteuerungstechnik
    Antworten: 8
    Letzter Beitrag: 20.02.2015, 11:53
  4. Unterschied der Hardware Naza V1 und V2
    Von reimundko im Forum Multicopter
    Antworten: 1
    Letzter Beitrag: 21.05.2013, 19:47

Lesezeichen

Lesezeichen

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •