Anzeige 
Seite 3 von 5 ErsteErste 12345 LetzteLetzte
Ergebnis 31 bis 45 von 72

Thema: Software und Hardware für Solarflieger

  1. #31
    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 Micha
    Genauso haben es mir unsere Informatik Kollegen im Verein auch erklärt, irgendwas mit im Fernsehen flimmernden karierten Sakos und Aliasing u.s.w.

    Ich taste jetzt synchronisiert ab, einmal Messen, einmal ausgeben, taktgleich, dann sollte es eigentlich passen.

    Hallo maccl
    Hott-Texmodus ist sooo gemein, und sooo träge... Ich red mich mal damit raus, das funzt nur mit Hott



    Hallo Julian

    Randbedingungen:
    Reglerauflösung 800Schritte
    Übertragungsfrequenzen zum Regler typisch 500Hz oder 4000Hz
    Moderne Regler können natürlich beides noch mehr, aber es soll ja universell sein,

    Praktischer Erfahrungswert für "lineares" Regeln (Plus Minus schrittgleich) Leerlauf - Vollgas ca. 0,5Sekunden ist eine gute Ausgangsbasis.

    Mal überschlagen:
    Ergibt eine Regelschleife von 800steps Auflösung / 0,5Sekunden = 1,6KHz
    bei 500Hz und 800er Auflösung sind wir schon bei ca 1,5Sekunden, das ist natürlich viel zu träge.
    Erhöht man die Schrittgröße, würde man die Auflösung verringern.

    Also entweder hochfrequent regeln, oder zumindest ein quasi-P mit rein, beides hat sich in der Praxis mittlerweile bewährt. Mit dem P-light in der synchronisierten Schleife bin ich ja die 2018er Saison geflogen.
    Mit zusätzlichem I habe ich noch nicht im Modell experimentiert, das folgt genau ab jetzt

    Die 4KHz nutze ich nicht um 4000x pro Sekunde zu übertragen, sondern weil ein neuer Wert nur 0,25mS zur Übertragung benötigt, statt wie herkömmlich 2ms. Der Regler hat dadurch satte 1,75mS mehr Zeit (7mal so viel) den neuen Wert umzusetzen, sobald ein neuer Wert feststeht.




    Einen Einfluss der Telemetrie auf die Regelung kann ich zu 99,999% ausschließen, die ISRs können maximal einmal pro Regelschleife auftauchen, nehmen mir maximal 15uS weg. Die Regelschleife wird vom PWM-Timer per Overflow-Flag alle 2mS gestartete, läuft so synchron zur Ausgabe. Der Code darin benötigt derzeit knapp unter 1mS (unten mit dem Serial.print messbar) , da tun die 15uS nicht weh. (pure Absicht, deswegen habe ich die Telemetrie ja kmpl. neu geschrieben).

    Ich habe vorhin mal ein kurzes Video mit der Änderung vom vorigem Beitrag gemacht, P=5 (entspricht P=0,2 typischer PID). Dafür das sämtliches Feintuning noch aussteht (zu kalt mit Notebook da draußen ), und alles so über den Daumen gepeilt aus dem Ärmel geschüttelt ist, rennt es jetzt schon recht ordentlich.

    Die einzige Änderung zwischen den beiden Videos:
    Vorher:
    Code:
      if (MPP > U_SOL)  {if (OCR3A > 1100 ) {OCR3A--;}} // MPPC Voltage to Low
      else              {if (OCR3A < 1900 ) {OCR3A++;}}   // MPPC Voltage to High
    Nachher ( P= jeh grösser die Abweichung je grösser die Regelschritte. Je kleiner der Wert, desto größer die Schritte)
    Code:
     uint8_t P = 5; 
     if (U_SOL > MPP) {if (OCR3A < 1900) {OCR3A += +1 + ((U_SOL - MPP) / P); }} //Solarspannung zu hoch, erhöhe PWM
     else             {if (OCR3A > 1100) {OCR3A += -1 - ((MPP - U_SOL) / P); }} //Solarspannung zu gering, veringere PWM

    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

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

    Standard

    Zitat Zitat von lastdownxxl Beitrag anzeigen
    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
    Leuchtet mir nicht ein...
    Weil ja, ich verstehe was du meinst, aber was fuer einen Sinn macht es den Regelkreis zweimal zu durchlaufen in der Zeit in der ich noch nicht einmal dem Stellglied etwas sagen konnte?
    Das ich den ADC Wert integrieren muss ueber die selbe Zeit ist klar.

    Da kann ich aber einfach einen IIR Filter anwenden.

    Gruesse Julian
    Like it!

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

    Standard

    Holger, viel besser.

    Hast du ein Speicheroszilloskop? Damit auf 0.1-0.5s/div Eingestellt kann man sich die Sprungantwort ansehen und dann kucken ob man noch was nachstellen muss.

    Gruesse Julian
    Like it!

  4. #34
    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 Julian
    Dann müsste ich mir das Tektronix ausleihen. Erstmal aber fertigmachen, Spannung und PPM-OUT habe ich ja auch im 500Hz Log, das allermeiste sieht man da schon bereits, die ganz kurzen Schlenker sieht man da natürlich nicht.
    Ich trigger sonst immer das alte Hameg auf die 500Hz PWM, dann habe ich ein (flüchtiges) 2mS Fenster in der Glotze.


    @all

    Wie wäre es mit einem klassischem SerialTerminal Menü ? SerialTerminal ist einfach und Plattformaunabhängig, funzt auch mit dem Smartphon und OTG-USB Adapter.

    Hab mal was hingetippt (Arduinio----*duck*) sollte auf jedem USB-Arduino funzen, vielleicht mag mal wer mit spielen, und Resonanz geben.

    Code:
    uint8_t A=12,B=23,C=34,D=45,E=56,F=67,G=78;
    
    void setup() {
    Serial.begin(19200);
    helpscreen();
    listscreen();
    }
    
    void loop() {}
    
    void serialEvent() {  
    if (Serial.available()){
    uint8_t inByte=Serial.read(); 
    if(inByte=='A') {A = Serial.parseInt();  Serial.print("A change in: "); Serial.println(A);}  
    if(inByte=='B') {B = Serial.parseInt();  Serial.print("B change in: "); Serial.println(B);} 
    if(inByte=='C') {C = Serial.parseInt();  Serial.print("C change in: "); Serial.println(C);} 
    if(inByte=='D') {D = Serial.parseInt();  Serial.print("D change in: "); Serial.println(D);} 
    if(inByte=='E') {E = Serial.parseInt();  Serial.print("E change in: "); Serial.println(E);} 
    if(inByte=='F') {F = Serial.parseInt();  Serial.print("F change in: "); Serial.println(F);} 
    if(inByte=='G') {G = Serial.parseInt();  Serial.print("G change in: "); Serial.println(G);} 
    if(inByte=='H') {helpscreen();} 
    if(inByte=='L') {listscreen();}
    }}
    
    void helpscreen(){ 
    Serial.println();
    Serial.println("MPPC for Solarmodels");
    Serial.println("type H for help");
    Serial.println("type L for list Parameter");
    Serial.println("to change a parameter, type A123 for change A with value 123");
    Serial.println("Bitte unten Zeilenumbruch im Serialmonitor wählen");
    Serial.println();
    
    }  
    void listscreen(){
    Serial.println( );           
    Serial.print("Parameter A: ");Serial.println(A);
    Serial.print("Parameter B: ");Serial.println(B);
    Serial.print("Parameter C: ");Serial.println(C);
    Serial.print("Parameter D: ");Serial.println(D);
    Serial.print("Parameter E: ");Serial.println(E);
    Serial.print("Parameter F: ");Serial.println(F);
    Serial.print("Parameter G: ");Serial.println(G);
    Serial.println();
    }
    So sieht das dann aus (irgendwie 80er ) -Wichtig ist unten den Zeilenumbruch zu wählen -(schreib ich gleich mit in den helpscreen)
    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	Term.jpg 
Hits:	12 
Größe:	68,9 KB 
ID:	2047287
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

  5. #35
    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

    Yeahh, C64 lässt grüssen
    Code:
      _ __ ___  _ __  _ __   ___  
     | `_ ` _ )| '_ )| '_ ) / __) 
     | | | | | | |_) | |_) | (__  
     |_| |_| |/| .__/| .__/ (___) 
               |_|   |_|     for Solarmodelling
    
     >>> type H for help, D for Doku
     Telemetrie 0=OFF 1=HOTT 2=JETI   (0) T = 0
     Tempsensor 0=OFF,1=INT 2=LM35?   (1) C = 2
     Tempsensor calibration         (127) S = 66
     Voltage calibration:           (127) V = 123
     MPP-comp 0=OFF 10=STRONG         (5) M = 3
     P-GAIN PID 0=OFF 10=FAST         (5) P = 6
     I-GAIN PID 0=OFF 10=FAST         (5) I = 5
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

  6. #36
    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

    Ich würde das mal so abliefern, mag mal Jemand nach Denkfehler drüberschauen, Bevor ich das mit dem MPPC Code verheirate ?
    Sollte auf jedem USB-Arduino laufen.
    Code:
    #include <EEPROM.h>
     uint32_t U_SOL=635, PWM=1567, MPP=630 , Looptime=1200; //dummywerte
    
    void setup() {
      Serial.begin(19200);
      logo();
      helpscreen();
    }
    void loop() {}
    
    // ++++++++++++++++++++++++++++++++ SERIAL MENUE BEGIN ++++++++++++++++++++++++++++++++++++++++++++++ //
    uint8_t T,C,S,V,M,P,I;
    
    void serialEvent() {
      if (Serial.available()) { uint8_t inByte = Serial.read();
      if(inByte== '#') {Serial.println(); Serial.println(U_SOL); Serial.println(MPP); Serial.println(PWM);}else{
      if(inByte== 'x') {Serial.println(Looptime);}else{  //secret function, show Timestamp LOOP, max 1500uS (2000)
      if(inByte== 'H') {helpscreen();} 
      if(inByte== 'D') {DOKU();}  
      if(inByte== 'T') {T = Serial.parseInt(); EEPROM.update(0x01, T);helpscreen();}
      if(inByte== 'C') {C = Serial.parseInt(); EEPROM.update(0x02, C);helpscreen();}
      if(inByte== 'S') {S = Serial.parseInt(); EEPROM.update(0x03, S);helpscreen();}
      if(inByte== 'V') {V = Serial.parseInt(); EEPROM.update(0x04, V);helpscreen();}
      if(inByte== 'M') {M = Serial.parseInt(); EEPROM.update(0x05, M);helpscreen();}
      if(inByte== 'P') {P = Serial.parseInt(); EEPROM.update(0x06, P);helpscreen();}
      if(inByte== 'I') {I = Serial.parseInt(); EEPROM.update(0x07, I);helpscreen();}
    }}}}
    void helpscreen() {
      Serial.print("\n >>> type H for help, D for Doku\n");
      T = EEPROM.read(0x01);  Serial.print(" Telemetrie 0=OFF 1=HOTT 2=JETI   (0) T = "); Serial.println(T);
      C = EEPROM.read(0x02);  Serial.print(" Tempsensor 0=OFF,1=INT 2=LM35?   (1) C = "); Serial.println(C);
      S = EEPROM.read(0x03);  Serial.print(" Tempsensor calibration         (127) S = "); Serial.println(S);
      V = EEPROM.read(0x04);  Serial.print(" Voltage calibration:           (127) V = "); Serial.println(V);
      M = EEPROM.read(0x05);  Serial.print(" MPP-comp 0=OFF 10=STRONG         (5) M = "); Serial.println(M);
      P = EEPROM.read(0x06);  Serial.print(" P-GAIN PID 0=OFF 10=FAST         (5) P = "); Serial.println(P);
      I = EEPROM.read(0x07);  Serial.print(" I-GAIN PID 0=OFF 10=FAST         (5) I = "); Serial.println(I);
    }
    void logo(){  
      Serial.println("  _ __ ___  _ __  _ __   ___  ");
      Serial.println(" | `_ ` _ )| '_ )| '_ ) / __) ");
      Serial.println(" | | | | | | |_) | |_) | (__  ");
      Serial.println(" |_| |_| |/| .__/| .__/ (___) ");
      Serial.println("           |_|   |_|     for Solarmodelling");
    }
    void DOKU(){ logo();
      Serial.println("\n >>> type H for help, D for Doku\n");  
      Serial.println(" type # for show live Data (Voltage MPP PPM)");
      Serial.println(" type X123 to change parameter X to value 123");
      Serial.println(" Blah-Blah-Doku-Blah-Blah");
    }
    // ++++++++++++++++++++++++++++++++ SERIAL MENUE END ++++++++++++++++++++++++++++++++++++++++++++++ //
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

  7. #37
    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
    Hott-Texmodus ist sooo gemein, und sooo träge... Ich red mich mal damit raus, das funzt nur mit Hott
    Hi Holger,
    warum träge? Die Einstellungen macht man eh am Boden

    kann da auch gerne beim Textmode helfen, wär aber halt gut wenn du ein Github-Projekt machst.




    zu deinem SerialTerminal:
    ich finde es nicht schlecht (auch das Logo)
    aber schau dir doch mal an wie das die betaflight-Jungs machen.
    das könnte man bestimmt übernehmen (oder Teile davon)

    https://github.com/betaflight/betafl...c-CLI-commands
    https://github.com/betaflight/betafl...nterface/cli.c


    oder was auch noch eine gute Möglichkeit wäre, wenn man auf bestehendes Protokoll zurückgreift
    zb MWP oder JSON
    Dafür gabe es dann opensource GUIs die man dann so anpassen kann wie man es braucht
    http://www.multiwii.com/wiki/index.p...e=MultiWii_GUI

    würde aber eher Json nehmen zb hier
    https://github.com/bblanchon/ArduinoJson




    kannst du mir sagen wo ich deine 85er-Software mit Knüppel-Modus finde?



    Danke

    Gruß Maccl
    Like it!

  8. #38
    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 Maccl

    http://www.rc-network.de/forum/showt...=1#post4666023 Testversion von vor kurzem
    https://www.rcgroups.com/forums/show...&postcount=120 Testversion von vor einem Jahr -pingleich mit Ukranduid
    Ich bin selber nie mit dem 85er geflogen

    Gihub und json habe ich probiert, ist mir alle viel zu englisch, komm ich schlicht nicht mit klar, und würde dafür vermutlich Stunden versenken.

    Der 32u4 ist ein kleiner gemeiner Giftzwerg, da lief das Serialmenü gemütlich auf dem Nano, aber die 32u4 Zicke weigerte sich. Nach kurzem googlen, der kann kein Interrupt auf dem USB Es ist auch völlig egal was ich in Serial.begin(123) schreibe, haupsache irgend ne Zahl, und auch welche Baudrate man im Serialmonitor wählt AVR+USB ist wie ein Fahrradlenker im Auto

    Sei es drumm. Mein Gedanke ist, das zumindest die Harwarebezogenen Parameter auf dem Eeprom landen, damit sie nach einem Update noch da sind. Hab das jetzt ganz minimalistisch gelöst, nur wenn der Motor auf Aus ist, fragt der nach dem Serialport.

    Soll ich mal eine Zwischenversion einstellen ?


    btw; der neue MPPC mal um Formel-iert. Muss den aber nochmal durch den Wolf drehen, scheint aber soweit zu passen.
    Die oberen drei Parameter sind zum testen
    Code:
    void setup() {
    Serial.begin(19200);
    uint8_t  Temp_20 = 30;  // 0=-20°C / 20=0°C / 60=40°C 
    uint16_t RC =  1800;    // RC IN 1100-1900uS
    uint16_t PWM = 1000;    // ausgehende PWM 1100-1900uS
    
    uint32_t MPP  = 2400-RC;                       Serial.println(MPP);  //
             MPP -= MPP*Temp_20*3/1000;            Serial.println(MPP);  // Temperaturkompensation  
             MPP  = MPP*(1000-(2000-PWM)/20)/1000; Serial.println(MPP);  // Leistungskompensation
    }
    void loop() {}
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

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

    Standard

    Hi Holger

    danke für die FW.


    also JSON ist im Grunde nix dramatisches.
    arduinoJSON ist eine Library für Arduino die es einem leichter macht die DatenPakete zu erstellen und zu parsen.
    hier gibts ne deutsche WIKI https://de.wikipedia.org/wiki/JavaSc...bject_Notation

    hier gibts einen Assi der zeigt wie das parsen geht
    https://arduinojson.org/v5/assistant/

    in dem man halt zb das ins Terminal schreibt könnte man einen Wert setzen ....
    { "parameter": "wert123" }

    ein GUI dann später dafür zu machen wäre mit processing oder anderen Tools möglich

    JSON ist halt sehr verbreitet, u.a HausSensorik usw....und eigentlich eine gute sache um datenpakete auzutauschen


    ein einfaches tutorial
    https://www.youtube.com/watch?v=z_rP...&frags=pl%2Cwn



    hier gäbe es ein git-Übersetzung
    https://github.com/danielauener/git-auf-deutsch
    https://de.wikipedia.org/wiki/GitHub

    aber Git bzw Github war für mich auch lange extrem verwirrend.
    will es aber nicht mehr missen und empfehle dir dich damit mal auseinander zusetzen.


    du kannst gern mal was einstellen, habe halt die Befürchtung das es hier untergeht.
    Like it!

  10. #40
    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

    vorläufiger Anschlussplan für die Beta1 Version.

    Zum Einsatz kommt ein Arduino-Micro, wichtig ist das er einen 32u4 Prozessor mit 8MHz und 3,3Volt hat.
    Bitte beim Kauf darauf achten, die hier vorgestellte Software funktioniert ausschließlich auf diesem Arduinoboard



    Anschlussplan Oberseite

    GND zu A1 Widerstand für den Spannungsteiler Solarspannung 10K (auf den Bild oben)
    RX zu TX 1K2 für Hott (auf dem Bild unten links SMD, es darf auch ein bedrahteter Widerstand sein)
    D2-D3-D4 mit einem Draht brücken.

    Name:  MPPCTH2.jpg
Hits: 290
Größe:  97,3 KB



    Anschlussplan Unterseite
    A1 zu Solarspannung mit 27K Widerstand für den Spannungsteiler in der Leitung. (auf dem Bild unten mitte rot)
    RAW 5V BEC (auf dem Bild unten links 2x Rot)
    RX zu T-Pin Hott (auf dem Bild oben links orange)
    GND zu Minus Empfänger (auf dem Bild 2x oben links braun)
    D4 zu Empfänger Gaskanal (auf dem Bild oben Mitte orange)
    D5 zu Regler (auf dem Bild oben Mitte orange)

    Name:  MPPCTH3.jpg
Hits: 289
Größe:  107,8 KB
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

  11. #41
    User Avatar von eifeljeti
    Registriert seit
    19.05.2011
    Ort
    Eifel
    Beiträge
    1.362
    Daumen erhalten
    61
    Daumen vergeben
    30
    0 Nicht erlaubt!

    Standard

    Halbwegs bekanntes Terrain,

    bleiben halt immer ein paar Fragen .. ihr macht ja immer nur "Braindumps" .. , wer da nicht ständig mitliest, weiss ja nu gar nicht mehr watt sache ist.
    1. Spannungsteiler ist für für wieviele Solarzellen ,27k / 10k also der resultierende Spannungsmessbereich ?
    2. Wozu D2-D3-D4 brücken ?
    3. RX zu TX 1K2 für Hott , watt mache ich an der Stelle ohne HOTT, ?? Hmhm wohl eher gar nichts.
    4. RAW 5V BEC (auf dem Bild unten links 2x Rot), ich denk du wolltest ganzen RC-Kreis mit 3.3V fahren, also doch einen Stepup oder Buck/Boost Pololu davor ?
    braucht der 32u4 8 MHZ denn da 5v , sollte der nicht VCC sowie intern Signalpegel 3.3v haben ?
    5. Lasst den Code bei der Schaltung, jetzt geht eine Sucherei los, die kein gutes Ende findet.
    6. sind sie paar MHz nicht zu langsam ?

    ... sonst steuer ich den MPP wieder nach Gehör ..

    edit: Frage 4. hat sich fast erledigt, ok ;da kann rein von - bis, was ist mit den Empfehlungen Vinput sollte 1V größer sein als die 3.3V ?
    gruss rudi ...
    Geändert von eifeljeti (22.11.2018 um 19:20 Uhr) Grund: edit ...
    Gruss Rudi ! -Eifeljeti- aus den Highlands der Eifel.
    Du fliegst hoch,mit viel Strom, oder gar sehr schnell ? VERDACHT ;-) !
    Like it!

  12. #42
    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 Rudi
    Am WE komme ich hoffentlich dazu eine Anleitung zu schreiben.
    Morgen soll ja die Sonne strahlen, dann kann ich nochmal schön testen. BETA1 ist soweit fertig

    1) bis 9,5V (Aref 2,56V) - mit anderen Widerständen natürlich auch höher.

    2) D2 (INT0) liest steigende Flanke, D3 (INT1) fallende Flanke, D4 (ICP) macht präzise Zeitstempel, man könnt auch alles auf D4 machen, und den ICP-Interrupt aufrufen, aber dann müsst man den Pin abfragen das kostet (ein ganz klein wenig) Zeit, und wäre zu einfach (soll ich das ändern ???)

    3) jepp, warten und hoffen das wer Jeti nachfügt. Ich kann kein Jeti (bin da guter Hoffnung das sich jemand für Jeti und FrSky findet)

    4) 5V oder mehr Volt an RAW, damit der interne Stabi 3,3V macht, würdest man es an VCC klemmen, rennt der Prozessor mit 5V, dann funzt Telemetrie nicht.
    EDIT -- der Empfänger bleibt weiterhin an den 5V.

    5) Bin grad dabei eine Miniseite zu machen, wo nachher alles draufsoll, später dann ein Blogbeitrag hier im Forum.

    6) Für mit ohne Telemetrie habe ich schon mit 1MHz rum-getestet, aber unter 8MHz spart ,man kaum mehr Strom. Die 16MHz dagegen merkt man schon (1Servo im Stand), 16MHz funzt nicht mit den 3,3V die wir für die Telemetrie brauchen.

    7) Ruhe- ich fliege nach Gehör.....


    Die ungetestete Beta1 - muss noch in die Sonne, danach mach ichs noch hübsch, und dann am WE online, auf das getestet werden mag

    Code:
    //    _ __ ___  _ __  _ __   ___ 
    //   | `_ ` _ \| '_ \| '_ \ / __)     (c)2018 by IsVölligWurschd 
    //   | | | | | | |_) | |_) | (__
    //   |_| |_| |/| .__/| .__/ \___)
    //             |_|   |_|   Telemetrie MPPC-MAXIMIZER for Solarmodelling 
    //
    //
    //++++++++++++++++ USER MENUE START +++++++++++++++++++++++++++++++++++
    
    uint8_t TEMPCAL = 83;    // default is 100 cal in 1° steps
    
    float   VOLTCAL = 5.44;  // defalt is 5.45 Voltage Calibration  higher is lower volt
    
    uint8_t MPPGAIN = 5;     // default=5 1=FAST 10=SLOW that make MPP faster,
    
    uint16_t Pdown = 1500;   // 1000=STRONG 1500=MIDLE 2000=LOW
    
    //  #define Telemetrie_SERIAL  // Do never fly with Serialdabug !!!! 
        #define Telemetrie_HOTT   
    //  #define Telemetrie_JETI
    //  #define Telemetrie_OFF
    
    //+++++++++++++++ USER MENUE ENDE ++++++++++++++++++++++++++++++++++++++
    
    volatile uint16_t RC=0, Solarvolt, Temp_20;
    uint32_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
        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}    
        OCR3A  = 1100;          // 1100uS zum Init an den Regler ausgeben
    
        TELEMETRIE_init();      // Telemetrie init, siehe Unterprogramme
        Serial.begin(500000);
        delay(2500);            // warten bis Regler initialisiert ist 
    }
    
    void loop() {
    //-----------Schleife mit PWM Timer 500Hz sycronisieren-------------
      while (TIFR3  & (1<<TOV3)){               // OVF -Flag abfragen, wenn gesetzt dann
             TIFR3 |= (1<<TOV3);                // OVF1 Flag löschen, und Schleife starten
             
    //------------MPP berrechnen-------------- 
    //static uint8_t loopcount; loopcount++; if (loopcount == 0 ){ 
        MPP  = 2400-RC;               
        MPP -= MPP*Temp_20*3/1000;                // Temperaturkompensation            
      //MPP  = MPP*(Pdown-(2000-OCR3A)/20)/Pdown; // Leistungskompensation          
    // }
     
    //----------Sachen machen ----------
        TELEMETRIE_send();                     // Telemetriedaten übergeben, siehe Unterprogramm 
        analog_Read();                         // Solarspannung und Temp-Sensor lesen, siehe Unterprogramm 
    //--------uuund regeln ------------------------------
    if (Solarvolt > MPP) {if (OCR3A < 1900) {OCR3A += +1 + ((Solarvolt - MPP) / MPPGAIN); }} //Voltage to high -inc PWM
    else                 {if (OCR3A > 1100) {OCR3A += -1 - ((MPP - Solarvolt) / MPPGAIN); }} //Voltage to high -dec PWM
    
    //Serial.println(TCNT3);
    //Serial.println(OCR3A);
    }}  // # # # # # # # # # # LOOP ENDE # # # # # # # # # # //
    
    
    // # # # # # # # # # # analog_Read START # # # # # # # # # # //
    void  analog_Read(){
          ADMUX  = 0b11000111; //ADC Tempsensor
          ADCSRB = 0b00100000;
          ADCSRA = 0b11000110;     
          while (ADCSRA & (1<<ADSC)) ;
          Temp_20 = ADCW + TEMPCAL - 340;         //KALIBRATION
          
          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; 
    }     Solarvolt = Utemp / VOLTCAL;       // auf centiVolt realwert kalbrieren
    
    }// # # # # # # # # # # analog_Read ENDE # # # # # # # # # # //
    
    
    // # # # # # # # # # # Read-RC-ISR-Routinen START # # # # # # # # # # //
    ISR(INT0_vect){               // Read RC- rising edge
        OCR1A  = ICR1;            // ICP-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    
    }// # # # # # # # # # Read-RC-ISR-Routinen ENDE # # # # # # # # # # //
    
    
    // # # # # # # # # # # TELEMETRIE BEGIN # # # # # # # # # # //
    #ifdef Telemetrie_HOTT                    // HOTT-Telemetrie Start
    volatile uint8_t  HOTT[46];
       
    void TELEMETRIE_send(){    
        HOTT[0]   = 0x7C;                     // Start Byte
        HOTT[1]   = 0x8C;                     // 8C = ESC
        HOTT[2]   = 0x00;                     //
        HOTT[3]   = 0xC0;                     // <<4
        HOTT[4]   = 0x00;                     // ALARM 
        HOTT[5]   = 0x00;                     // ALARM
        HOTT[6]   = (uint8_t)(Solarvolt&255); // L-Byte Spannung in cV
        HOTT[7]   = (uint8_t)(Solarvolt>>8);  // H-Byte Spannung in cV
        HOTT[8]   = (uint8_t)(MPP&255);       // L-Byte Spannung_min in cV     
        HOTT[9]   = (uint8_t)(MPP >>8);       // H-Byte Spannung_min in cV   
      //HOTT[10]  = (uint8_t)(looptime&255);  // L-Byte Kapazität in cAh
      //HOTT[11]  = (uint8_t)(looptime >>8);  // H-Byte Kapazität in cAh                                          
        HOTT[12]  = Temp_20;                  // Temp 1a Offset-20
      //HOTT[13]  = Temp1B;                   // Temp 1b Offset-20
        HOTT[14]  = (uint8_t)(MPP&255);       // L-Byte Strom in dA
        HOTT[15]  = (uint8_t)(MPP >>8);       // H-Byte Strom in dA
      //HOTT[16]  = (uint8_t)(AmpMax);        // L-Byte Strom_max in dA
      //HOTT[17]  = (uint8_t)(Amp_Max);       // H-Byte Strom_max in dA
        HOTT[18]  = (uint8_t)(OCR3AL);        // L-Byte RPM/10
        HOTT[19]  = (uint8_t)(OCR3AH);        // H-Byte RPM/10
        HOTT[20]  = (uint8_t)(0x6c);          // L-Byte RPM_max/10    
        HOTT[21]  = (uint8_t)(0x07);          // H-Byte RPM_max/10   
        HOTT[22]  = OCR3A/8-117;              // Temp2a Offset-20
      //HOTT[23]  = Temp2A;                   // Temp2b Offset-20
        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_SERIAL      // Serialdebug, 
    void TELEMETRIE_send(){       // Wird einmal pro loop ausgeführt, sync mit 500Hz
    static uint8_t loopcount; 
    loopcount++;                  // 2x pro Sekunde
    if (loopcount == 0 ){
    Serial.print("mV  ");   Serial.println(Solarvolt);
    Serial.print("MPP ");   Serial.print(MPP);   
    Serial.print(" / ");    Serial.println(2400-RC);
    Serial.print("PWM ");   Serial.println(OCR3A);
    Serial.print("°C: ");   Serial.println(Temp_20-20);
    Serial.println();
    }}
    void TELEMETRIE_init(){}
    #endif
    
    #ifdef Telemetrie_JETI //Platzhalter für JETI Telemetrie
    void TELEMETRIE_send(){}
    void TELEMETRIE_init(){TCCR4B=0b00000000;}
    #endif
    
    #ifdef Telemetrie_OFF  //Platzhalter für mit-ohne Telemetrie
    void TELEMETRIE_send(){}
    void TELEMETRIE_init(){TCCR4B=0b00000000;}
    #endif
    
    // # # # # # # # # # # TELEMETRIE ENDE # # # # # # # # # # //
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

  13. #43
    User Avatar von eifeljeti
    Registriert seit
    19.05.2011
    Ort
    Eifel
    Beiträge
    1.362
    Daumen erhalten
    61
    Daumen vergeben
    30
    0 Nicht erlaubt!

    Standard

    Und wenn man auf den VCC -Pin mit 3.3V als externe Betriebsspannung draufgeht ( .. aus dem Pololu ) ?
    geht das nicht auch, wenn ich das Pinout richtig verstanden habe ?


    Soweit ich das sehe, haben meine Regler alle kein BEC, somit kein 5V vorhanden.
    Habe nur Solarspannung und dann eben runter auf 3.3V mit dem Low-drop 3.3V Polulu,
    das schien bisher ein guter Ansatz zu sein.


    Soviele unterschiedliche Potentiale finde ich nicht gerade toll, aber wenns für den Zweck sein muss.
    Muss ich halt grübeln:
    a) Stepup von 3.3 => 5 oder 6V,
    b) Solarspannung direkt auf RX + Raw des ProMicro
    c) Solarspannung Stepdowned auf 5v für RX und Raw
    Gruss Rudi ! -Eifeljeti- aus den Highlands der Eifel.
    Du fliegst hoch,mit viel Strom, oder gar sehr schnell ? VERDACHT ;-) !
    Like it!

  14. #44
    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!

    Beitrag

    Moin Rudi

    Wenn du 3,3V BEC hast, kannst Du entweder mit den 3,3V direkt auf VCC, oder mit der Solarspannung auf RAW, so wie es mit Deiner Verkabelung besser zusammenpasst.

    Praktischer ist vermutlich den Widerstand 27K direkt von RAW nach A1 auf der Unterseite zu löten, und Solarspannung dann auf RAW. (Vielleicht generell auch per Anleitung so machen?)

    An RX kommt keine Spannung, da kommt Telemetrie dran.


    EDIT - Version 2 -auch vorläufig und andere Schreibweise (ist die Besser?)

    D234 Brücke habe ich rausgeworfen nur noch D4

    Widerstand 10K von GND zu A1
    Widerstand 27K von RAW zu A1
    Widerstand 1k2 von RX zu TX (Nur bei Telemetrie)

    RAW = Solarspannung
    GND = Minus
    D4 = Impuls Gaskanal
    D5 = Impuls Regler
    RX = Telemetrie (nur bei Telemetrie)
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

  15. #45
    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!
    Gruß Holger
    dessen Signatur vom Signatur-Moderationator aufgrund Überlänge gelöscht wurde.
    Like it!

Seite 3 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
  •