Software und Hardware für Solarflieger

Ich fange hier mal an.

Im Moment bastel ich an einen "VolksMPP", es soll irgendetwas möglichst einfaches, aber auch leichtgewichtiges werden, das vor dem Regler die Spannung des Solarpanels fix hällt.

Möglich wäre ein Attiny85, in Gesprächen ergibt sich immer eine geringere Berührungsangst, (ja so ein IC anlöten schaff ich schon...).

Ich will den Code mal kmpl. neu aufbauen, gerade grübel ich über Soft-PWM nach, zwei Varianten habe ich zusammengebastelt, funzen beide auch, weiß aber nicht welche (oder andere) die bessere sein sollte. Der At85 hat ja nur einen 8Bit Timer für die PWM, so das man nur per Soft-PWM aufstocken kann. Hier fehlt es noch an einer guten Lösung.

Die beiden Varianten sind in der ISP, bei der einen sind die drei Zeilen auskommentiert, die andere gerade aktiv, und ist angelehnt an: http://www.technoblogy.com/show?1NGL

Code:
#define  F_CPU 8000000UL
#include <util/delay.h>
#include <avr/io.h>
#include <avr/interrupt.h> 
volatile uint8_t  count  = 0;
volatile uint8_t  PWM_L  = 0;
volatile uint8_t  PWM_H  = 0;
volatile uint16_t PWMi   = 0;
volatile uint16_t PWM    = 0;

int main(void){
  DDRB   |= 0b00000010;
  TCCR1   = 0b01010100;
  TIMSK   = 0b00000100;
  sei();

  
  PWM   = 1500;
  
  PWM_L = (uint8_t)(PWM&255);
  PWM_H = (uint8_t)(PWM >>8)*32;  
  
while(1){}} 
  
ISR (TIM1_OVF_vect){
 
[B]//Variante 1[/B]
//  if (count >  PWM_H) {OCR1A = 0;     }  else {
//  if (count == PWM_H) {OCR1A = PWM_L; }  else {
//  if (count <  PWM_H) {OCR1A = 255;   }  }}
    
[B]//Variante 2[/B]
  if (count == 0)                 PWMi = PWM;
  if (PWMi >= 256) {OCR1A = 255;  PWMi = PWMi - 256; }
  else             {OCR1A = PWMi; PWMi = 0; }
  
[B]//Variantenende[/B]

  count = count + 32;
}
 
Der andere Kandidat wäre der USB-Tiny-ISB, eigentlich ein ISP, aber die Anschlüsse reichen.
Er hat einen Attiny44, 12MHz was uns besonders beim ADC entgegenkommt, und die Timer passen perfekt 8(12) + 16Bit
Man bekommt die Platinchen für ca. 1,50€ in der Bucht, taugen auch als ISP, um einen zu bespielen kann man einfach zwei "stapeln".



attachment.php


Ich habe einen PPM Passthrough schon mal fertig gemacht. 50Hz RC-PPM geht rein, und 500Hz PPM geht raus, stellt man den PWM Timer eins höher (x8) dann ist es OneShot.
Sicherungen im ISR u.s.w. fehlen noch....

.include "tn44adef.inc"

.def ZERO = r0

.org 0x0000
rjmp main
.org 0x0002
rjmp PCINT0_ISR

main:
ldi r16, low(RAMEND)
out SPL, r16
ldi r16, high(RAMEND)
out SPH, r16
ldi r16, 0b00000000
mov ZERO, r16
;--------------- Port Setup ----------------
ldi r16, 0b00100000
out DDRA, r16
ldi r16, 0b00010000
out PORTA, r16
;--------------- Read RC -------------------
ldi r16, 0b00010000
out GIMSK, r16
ldi r16, 0b00010000
out PCMSK0, r16
ldi r16, 0b00000000
out TCCR0A, r16
ldi r16, 0b00000010
out TCCR0B, r16
ldi r16, 0b00000100
out USICR, r16
;------------- Write PWM -------------
ldi r16, 0b00100010
out TCCR1A, r16
ldi r16, 0b00011010
out TCCR1B, r16
ldi r16, 0b00001011 ; ICR1 = 3000; 1011 10111000
out ICR1H, r16
ldi r16, 0b10111000
out ICR1L, r16
sei

loop:
rjmp loop


PCINT0_ISR:
sbis PINA, PINA4
rjmp falling_edge
ldi r16, 0b00000010
out TCCR0B, r16
out TCNT0, ZERO
out USISR, ZERO
reti

falling_edge:
out TCCR0B, ZERO
in r17, TCNT0
in r16, USISR
cbr r16, 0b11110000
out OCR1BL, r17
out OCR1BH, r16
reti


edit
C Version, gefrickel in der ISR, im USISR sitzen in den unteren 4Bit die H-Byte Daten des 12Bit Zählers, in den oberen 4Bit wehen da Fähnchen. im ASM habe ich die einfach per cbr r16, 0b11110000 gelöscht, in der C-Version durch subtrahieren, in der Hoffnung, das sie niemals anders aufpoppen :D (vorsichtshalber den Timer vorher gestoppt :rolleyes:)
Code:
#define  F_CPU 12000000UL
#include <util/delay.h>
#include <avr/io.h>
#include <avr/interrupt.h>   

int main(void){  
//-------------  Read ADC -------------
  //ADMUX   = 0b10000110;   //  Read ADC6 
  //ADCSRA  = 0b11000111;   //  Prescale 1/128 188KHz 139uS SlowMode // 
  //ADCSRA  = 0b11000110;   //  Prescale 1/64   94KHz  69uS FastMode
//--------------- Read RC ------------------- 
  PORTA  |= 0b00010000;     //  PA4 is RC Input 
  GIMSK   = 0b00010000;     //  PCINT activ
  PCMSK0  = 0b00010000;     //  PCINT is
  TCCR0A  = 0b00000000;     //  Timer ON
  TCCR0B  = 0b00000010;     //  010 Prescale 1/8 2MS  
  USICR   = 0b00000100;     //  count is 192-207 (4Bit 16count    
//-------------  Write PWM -------------
  DDRA   |= 0b00100000;     //  Write ESC is PA                 
  TCCR1A  = 0b00100010;     //  PWM  Mode 15      
  TCCR1B  = 0b00011010;     //  Prescale 1/8 Channel-B // 001 1/1 ONESHOT
  ICR1    = 3000;

  sei(); 

while(1){}}
  
ISR(PCINT0_vect) { 
if    (PINA   & (1<<PA4))
{       TCCR0B  = 0b00000010;
        TCNT0   = 0b00000000; 
        USISR   = 0b00000000;     
}else{  TCCR0B  = 0b00000000;    
        OCR1BH  = 
        USISR   - 0b11000000;
        OCR1BL  = TCNT0;
}     }
 
Grad mal nen halbes Stündchen Zeit gehabt, das Chaos im letztem Codemal aufgeräumt.
-USI Fähnchen ordentlich gelöscht (da war der C-Knoten im Hirn, hoffe das passt auch so:rolleyes:)
-Timer1 auf prescale 1/1 statt 1/8 dadurch höhere schreibare Auflösung (aber kein Oneshot)
-Die Routine in der Loop mit Timer1 syncronisiert (stumpf per abfragen der OVF Flag, wobei ich nicht verstehe, wieso nach 1 fragen, sowie per 1 löschen ??? (Datenblatt))
-ISR nach oben verlegt, damit es nachher auch noch SEXY aussieht ;)
-Code auch auf Arduino-IDE tauglichkeit getestet (Spence-Code At44 12MHz funzt)

Anregungen und Kritik sind gerne willkommen (Denkfehler?)


Code:
#define  F_CPU 12000000UL
#include <util/delay.h>
#include <avr/io.h>
#include <avr/interrupt.h>   

ISR(PCINT0_vect) { 
if      (PINA   &   (1<<PA4))       //  Read RC rising edge
{       TCCR0B  =   0b00000010;     //  Read RC start Timer
        TCNT0   =   0b00000000;     //  Read RC zero Timer
        USISR   =   0b00000000;     //  Read RC zero Timer
}else{  TCCR0B  =   0b00000000;     //  Read RC falling edge, stop Timer       
        OCR1AH  =                   //  Read RC store High-Byte
        USISR   &  ~0b11110000;     //  Read RC Delete Flags
        OCR1AL  =   TCNT0;          //  Read RC store Low-Byte
}}  
int main(void){ 
//      ADMUX   =   0b10000110;     //  Read ADC Read ADC6 
//      ADCSRA  =   0b11000111;     //  Read ADC Prescale 1/128 188KHz 139uS SlowMode 
//      ADCSRA  =   0b11000110;     //  Read ADC Prescale 1/64   94KHz  69uS FastMode   
        PORTA  |=   0b00010000;     //  Read RC PA4 is RC Input 
        GIMSK   =   0b00010000;     //  Read RC PCINT activ
        PCMSK0  =   0b00010000;     //  Read RC PCINT is
        TCCR0A  =   0b00000000;     //  Read RC Timer ON
        TCCR0B  =   0b00000010;     //  Read RC Prescale 1/8  
        USICR   =   0b00000100;     //  Read RC count 192-207 (4Bit)       
        DDRA   |=   0b00100000;     //  Write PWM Write ESC is PA                 
        TCCR1A  =   0b00100010;     //  Write PWM PWM  Mode 15      
        TCCR1B  =   0b00011001;     //  Write PWM Prescale 1/8 Channel-B // 001 1/1 ONESHOT           
        ICR1H   =   0b01011101;     //  Write PWM ICR-Top 24000 (2000mS)
        ICR1L   =   0b11000000;     //  Write PWM ICR-Top 24000 (2000mS)  
        OCR1BH  =   0b00110011;     //  Start ESC 13200 (1100mS)
        OCR1BL  =   0b10010000;     //  Start ESC 13200 (1100mS)
        sei(); 

while(1){
    if  (TIFR1  & (1<<TOV1)){       // sync with PWM-Timer1 
        TIFR1  |= (1<<TOV1) ;       // OVF1 Flag löschen
        OCR1B   = OCR1A << 3;       // Read RC(2000) zu Write PWM (24000)
  }   
}}


//  ppm mS  Read Write  
//  1000mS  1500 8800
//  1100mS  1650 13200
//  1500mS  2250 18000 
//  1900mS  2850 22800
//  2000mS  3000 24000
 

derjuwi

User
Holger, das ist nutzlos und unverstaendlich so. Bitte Kommentiere und beschreibe was du machst als kurzen Text + Warum in den Zeilenkommentaren.
Dein derzeitiger Programmcode ist fuer den Muelleimer, das kann keiner verwenden. Waere doch schade um deine Muehe?

Gruesse Julian
 
Moin Julian
Meinst Du das so? (ist ja fast mehr Arbeit als der Code an sich:D)

edit, Kommentare zwischen den Zeilen machte es für mich eher unübersichtlicher, da mein Schleppi-Schirm nicht riesig ist, und auch eher breit ist statt hoch, besser rechts daneben, weil dann sieht man mehr Code am Stück ;)

Code:
#define  F_CPU 12000000UL
#include <util/delay.h>
#include <avr/io.h>
#include <avr/interrupt.h>   

ISR(PCINT0_vect){                 //  Interuptroutine zum Auslesen des Empfängers
if      (PINA   &   (1<<PA4))     //  Wenn die eingehende Flanke vom RC-Signal steigend...
{       TCNT0   =   0b00000000;   //    dann wird Timer0 (L_Byte) genullt,
        USISR   =   0b00000000;   //    der Timer-USI (H_Byte) wird genullt,
        TCCR0B  =   0b00000010;   //    und der Timer0/USI wird gestartet.
}else{  TCCR0B  =   0b00000000;   //  Ansonsten haben wir eine fallende Flanke, und Timer 0 wird getoppt.       
        OCR1AH  =                 //    In OCR1AH werden die unteren 4Bit des USI-Timers als H_Byte zwischengespeichert
        USISR   &  ~0b11110000;   //    hierzu müssen die oberen 4Bit (Flags) gelöscht werden.
        OCR1AL  =   TCNT0;        //    In OCR1AL wird Timer0-Wert als L_Byte zwischengespeichert.
}}  

int main(void){    

//      ADMUX   =   0b10000110;   //  Read ADC  |  
//      ADCSRA  =   0b11000110;   //  Read ADC  | Prescale 1/64   188KHz  69uS

        PORTA  |=   0b00010000;   //  Read RC   | Pullup aktiviert für PA4 als Eingang für den Empfänger
        GIMSK   =   0b00010000;   //  Read RC   | Pinchance-Interupt wird aktiviert
        PCMSK0  =   0b00010000;   //  Read RC   | Pinchance-Interupt Pin ist PA4 (PCINT4)
        TCCR0A  =   0b00000000;   //  Read RC   | Normaler Timer-Mode (keine PWM)
        TCCR0B  =   0b00000010;   //  Read RC   | Prescale 1/8 ergibt saublöde 1,5 Steps pro mS
        USICR   =   0b00000100;   //  Read RC   | Timer0 wird per USI-Timers auf 12Bit erweitert (Datenblatt 14.4.3)
           
        DDRA   |=   0b00100000;   //  Write PPM | Regler wird an PA5 angeschlossen                  
        TCCR1A  =   0b00100010;   //  Write PPM | Fast PWM Mode 14, PWM-Channel B (OFFEN !!!)     
        TCCR1B  =   0b00011001;   //  Write PPM | Prescale 1/1, der Timer läuft mit 12MHz         
        ICR1H   =   0b01011101;   //  Write PPM | ICR-Top 24000 entspricht 2000mS
        ICR1L   =   0b11000000;   //  Write PPM | ICR-Top 24000 entspricht 2000mS 

        OCR1BH  =   0b00110011;   //  init ESC  | Regler-Leerlauf mit 13200 entspricht 1100mS
        OCR1BL  =   0b10010000;   //  init ESC  | Regler-Leerlauf mit 13200 entspricht 1100mS
        _delay_ms(2500);          //  init ESC  | Kurz warten bis der Regler initialisiert ist.    
        sei(); 

while(1){
  if (TIFR1  &  (1<<TOV1)){       // Loop syncronisieren per OVF-Flag vom Regler Timer1, Frequenz: 500Hz(2mS)
      TIFR1  |= (1<<TOV1) ;       // Flag wird manuel gelöscht, da ohne ISR keine aut. Löschung.
          
// RC-Wert wird testweise an den Ausgang umgeleitet, RC 0-3000 entspricht PPM 0-24000, darum / 8 (<<3) geteilt:
// Das ungenutzte 16Bit Register OCR1A wird für die RC-Signale zweckentfremdet, 
// da es auch in in L+H 8Bit ansprechbar ist (OCR1AL OCR1AH). 

    OCR1B = OCR1A << 3;       
  }
}}
 

derjuwi

User
Viel Besser. Zu gut fehlt nocht die Beachtung der "Warum" Regel. Warum machst du etwas, nicht was du machst soll kommentiert sein (wenngleich bei dem Registergeschiebe auch das WAS interessant und sinnvoll ist.

Und man schreibt am Beginn eines Programmes einen Header mit Autor, Datum und Zweck der Software.

GITHUB!

Und ja, man rechnet 20% der Zeit fuers programmieren, 50% fuer die Fehlersuche und 30% fuer die Dokumentation.

Gruesse Julian
 
Ich finde dieses Grau auf Grau sehr unleserlich, hatte vorhin mal einen Screenshot gemacht. Ich nutze ja nur einen Texteditor (Geany:)), makefile und die übliche toolchain (avr-gcc, avrdude, avra u.s.w.)

In bunt sieht das dann doch wesentlich übersichtlicher aus:
Bildschirmfoto zu 2018-11-07 09-46-50.png

Aber erstmal das PPM Passthrough komplettieren,.... Watchdog u.s,w, kommen noch,

Gerade ringe ich noch innerlich mit mir, als Alternative den internen On-Chip Tempschätzer für die ext-Tempsensorverweigerer zu nutzen. Den müsste man vor dem einlernen erstmal "warmlaufen" lassen, und viel mehr als die Jahreszeit wird der nicht einschätzen, aber besser als nichts. Auf der anderen Seite, eine Verlockung den externen einzusparen ?
LM35DZ ausreichend ? (Habe den derzeit auf der Rumpfnase direkt in der Sonne statt an den Zellen, ist nicht gut, aber ausreichend, meine ich).
 

maccl

User
Hallo Holger,

wenn ich das auf einen atmega328 spielen möchte, dann muss ich nur F_CPU anpassen oder?

ich hab das nicht testen können, aber gibts denn auch Failsave?
Was passiert wenn PWM-IN abgezogen wird oder einem Wackler hat?

Was spräche Hardwäre-mäßig gegen einen Ardunio Pro Mini?
kostet auch nicht viel und hätte mehrer Pins und mehr Möglichkeiten.

Ps: würde mich auch über ein Github-Projekt freuen.

gruß Maccl
 
Hi Maccl

Dafür soll der Watchdog noch mit rein. Das ist eigentlich auch nur ein einfacher Timer. Der wird dann bei jedem RC-Puls zurückgesetzt, falls nicht, läuft der in einer voreingestellten Zeit über, und kann was ausführen (z.B. den Prozessor zurücksetzen, oder eine ISR ausführen, in der man den Motor abstellt).

Der Code rennt so leider nicht auf einem Arduino, dafür ist der zu Hardware-Nah.
Für das kleine Attiny-Board sprach, das
Mir ist es an sich egal, welches Board man nimmt, mir geht es darum, etwas zu basteln, was nachher einfach nachzubasteln ist (für mich selber fräse ich mir meine Platinen). Für das kleine Attiny-Board sprach, das es relativ klein, und dazu unglaublich billig ist (1,5€ inkl Porto).
https://www.ebay.de/itm/Mico-USB-Ti...=item3f79bef82c:g:OUsAAOSw4CFY6zD0:rk:13:pf:0
Optional kann man noch das vordere Drittel mit der USB-Buchse wegsägen, dann wiegt es unter 1g.
Leider muss man da aber auch an den Bootloader drann, was aber supereinfach ist, indem man einfach zwei per Stiftleiste übereinandersteckt, und das Eine mit dem anderem bespielt. danach gehen alle Updates über das Servokabel.

photo_2018-11-08_14-10-28.jpg





Bei den Arduinoboards ist der Vorteil, das sie ja quasi gebrauchsfertig sind, für die Nachbastler sollte es dann aber was mit USB sein ? (ansonsten wäre wieder das Thema Bootloader;)) 8MHz (3,3V) wäre Telemetriefreundlicher.

USB + 3,3V gibt es glaube nur die kleinen Boards mit dem 32u4 ? (Leonardo, Pololu A-Star...)

Die 32u4 sind ja mit reichlich Timern ausgestattet, mit der USB-Stabilität hatte ich bisher wenig Glück.


Mir ist es an sich egal, welches Board, nur müsst man sich auf eines einigen, und dann aber dabei bleiben. :)

Im Bild,
Arduino-Nano 5V 16MHz, Atmega328p (2x8 + 1x16Bit Timer / 1xUart)
Mini 3,3V/ 8 Mhz, Atmega328p (2x8 + 1x16Bit Timer / 1xUart)
Leonardo 8MHz 3,3V, Atmega32u4 (2x8 + 1x10 + 2x16Bit Timer / 2xUart)
USBTiny 12MHz 3,3-5V (1x12 Bit Counter + 1x16 Bit Timer)
attiny85 auf DIp-Adapterplatine. (1x12 Bit Counter + 1x8 Bit Timer)


photo_2018-11-08_13-50-15.jpg

GITHUB, sind da nicht Dieselben Nasen wie bei diesem Microcontroller-Forum unterwegs ? (Umgangsformen....)
 
Andere Alternative wäre ein FlightController, da gibt es viele, nahezu alle haben einen STM32 Prozessor drauf (Alles wieder von vorn;)) , aber dafür auch gleich die Sensorik, Spannung sowieso, meist ein kleines SBEC, BEschleunigungs und Lage-Sensoren, und einige auch Stromsensoren.
Denke aber das es für viele komplizierter wird als mit dem AVR Boards

Aktuell:
PicoBLX, nicht das kleinste mit 2,7g, dafür bekommt man ihn unter 10€
https://www.ebay.de/itm/Newest-PIKO...Controller-for-DIY-Indoor-Drone-/152601931356


oder Racewhoop, 1,7g, dafür um die 30€
https://www.amainhobbies.com/furious-fpv-racewhoop-smallest-brushless-fc-fpv-0178-s/p618039
 
Hab mal ein bissl mit dem 32u4 gespielt, zickt etwas rumm, musste nur ca 20x mal den Bootloader draufladen, jedesmal wenns ein nicht-Arduino-Code war, war der weg :eek: (Da muss erstmal Jugend-forscht bei:D)

fix mal nen PPM-Passthrougt gebaut, Kommentarlos, das funzt sonst recht gut, purer Luxus
Code:
void setup() {
EICRA   = 0b00001011; //1=falling 0=rising
EIMSK   = 0b00000011;
TCCR3A  = 0b00000000;
TCCR3B  = 0b00000010;
DDRB   |= 0b11111111;
TCCR1A  = 0b10000010;
TCCR1B  = 0b00011010;
ICR1=2000;
}
void loop() {}
ISR(INT0_vect){TCNT3=0;}      //rising
ISR(INT1_vect){OCR1A=TCNT3;} //falling
 

maccl

User
Hi Holger

Der Code rennt so leider nicht auf einem Arduino, dafür ist der zu Hardware-Nah.
sorry verstehe ich nicht.
warum?

Für das kleine Attiny-Board sprach, das Mir ist es an sich egal, welches Board man nimmt, mir geht es darum, etwas zu basteln, was nachher einfach nachzubasteln ist (für mich selber fräse ich mir meine Platinen). Für das kleine Attiny-Board sprach, das es relativ klein, und dazu unglaublich billig ist (1,5€ inkl Porto).
https://www.ebay.de/itm/Mico-USB-Ti...=item3f79bef82c:g:OUsAAOSw4CFY6zD0:rk:13:pf:0

ich verstehe schon was du meist, aber ich glaub halt das man es anderen Leuten leichter machen kann in dem man auf eine fertige Platine zurückgreift.
(Bei vielen Leuten muss man froh sein wenn sie Löten können.)

USBTinyISP finde ich prinzipell ja nicht schlecht, aber wenn man halt noch ein paar andre Pins nutzen möchte zb für telemetrie oder Einzelzellen-Messung wirds halt knapp.
gerade auch was den Speicher angeht.

so einen ProMini (Clone) bekommt auch schon ab 2 euro
https://www.ebay.de/itm/Pro-Mini-3-...Tmega128-Arduino-Compatible-Nano/173317324167


Bei den Arduinoboards ist der Vorteil, das sie ja quasi gebrauchsfertig sind, für die Nachbastler sollte es dann aber was mit USB sein ? (ansonsten wäre wieder das Thema Bootloader;)) 8MHz (3,3V) wäre Telemetriefreundlicher.

das schöne ist wenn jemand keinen FTDi-Adapter hat kann er nen arduino nano mit USB nehmen.
die paar gramm mehr tun auch nicht weh. (man kann ja dann leichter bauen)

Bootloader: reicht der arduino bootloader nicht?

Warum ist 8MHz (3,3V) Telemetriefreundlicher?
man braucht nur nen kleine Diode und könnte dann direkt auf die Serielle Schnittstelle


GITHUB, sind da nicht Dieselben Nasen wie bei diesem Microcontroller-Forum unterwegs ? (Umgangsformen....)

GITHUB ist kein Forum sondern ein Onlinedienst in dem Software öffentllich in Projekten weiterentwickelt wird.
genau das wollen wir doch oder?

https://de.wikipedia.org/wiki/GitHub

ich selbst nutze GIT auch Lokal um software für die Arbeit zu entwickeln.
ohne das könnte ich heute gar nicht mehr arbeiten

zum Commiten, Pushen, Pullen und Mergen nehme ich
https://www.sourcetreeapp.com

es ginge auch mit Kommandozeile... wenn dir das lieber ist

schau dir zum Beispiel man an wie sich die Community von Betaflight entwickelt hat
https://github.com/betaflight/betaflight/wiki

alle Änderungen sind nachvollziehbar.
Fehler/Fragen sind sauber gelistet.
und die Wiki (egal ob für Hard oder Software ist dort auch sauber untegracht)

und (führt jetzt evtl zu weit) mit travis-ci wird dann automatisch getesten und deployed

gruß Maccl
 

maccl

User
... um jetzt noch ein ganz anderes Fass aufzumachen.

der ideal-Fall wäre wenn das alles der Empfänger machen könnte (wie z.B. die Kreisel / Gyro Empfänger).
ähnlich wie bei den Graupner-Empfängern bei denen es möglich ist die Spannung des Akkus am Sensor-Eingang zu messen.
... bräuchte man vermutlich nur ein paar Zeilen code um den MPP direkt in den Empfänger zu integrieren.

die Frage ist nur Graupner die Firmware zur Verfügung stellen würde.
Was ich bezweifle. aber fragen kostet sicher nix.

aber dann schauen die Fassts, JEtis, etc in die Röhre.
 
GEILE IDEE

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. :D

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-frsky-nano-receiver

uSKY_proto2.0_fp-300x221.jpg


usky_pcb_layout-300x226.png


uSKY_proto2_assembled-300x203.jpg


Dazu haben wir im Verein einen Informatischen Kollegen der stm32 liebt, und FrSky spricht, und auch schon länger mit dem uSky spielen will :):cool: 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 :cool:

Du bist so gemein :cry: (;)) 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/showthread.php?1667453-DIY-FrSky-RX
 
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.
 

maccl

User
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. :D

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
 

maccl

User
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-Digisp...SB-Development-Board-for-Arduino/253689020433

dein Code rennt hier drauf nehme ich an.
 

maccl

User
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/sho...larBear-pure-solar-powered-32-wing-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;
}}
}
 
Ansicht hell / dunkel umschalten
Oben Unten