Ant unter "hochdruck"

  • Das Ventil ist nicht für Daueranwendungen gedacht. Es wird bei 8V schon nach einigen Sekunden gut warm. Für eine Daueranwendung müsstest du dann mit der Wicklung experimentieren. Je höher der Druckunterschied zwischen Eingang und Ausgang, deso höher muss die Spannung sein.
    Ich denke mal das das Ventil im Tipp- oder Kurzzeitbetrieb schon noch an 3S überleben wird. Vorrausgesetzt es wird nicht zu warm. Also nach 10s bei 2S lasse ich mein Ventil schon so 2 Minuten abkühlen. Aber mein Ventil ist ja eh maximal nur eine Sekunde angesteuert.
    Mit mehr Windungen und dünnerem Draht kannst du dir das auf die passende Spannung wickeln. Da mein Ventil mit 7V zuverlässig arbeitet kommen die 8V Akkuspannung drauf, um sicherzugehen. Wenn ich den Abstand zwischen Anker und Gegenstück noch weiter verringer dürfte die Spannung noch weiter runtergehen. Ich bin aber schon nur noch bei einem Millimeter. Ich weis nicht ob noch weniger sinn macht. Was meinen die Profis?


    Ich hab mal eine mehr oder weniger Schritt für Schritt anleitung erstellt. Das ist noch keine Nachbauanleitung. Es soll nur die Baureihenfolge erläutern und den Aufbau erklären.

    Erfahrungen sind was sehr nützliches, leider macht man sie erst kurz nachdem man sie gebraucht hätte...

  • Mike, wieviel wiegt das Ding denn jetzt insgesamt? Ich hatte mal überlegt, wenn ich einen Pneu-Ant bauen würde, denke ich sollte ich ein Lego-Ventil benutzen und mit einem Servo verkleistern. Wie ist die Gewichtung? Wirst Du einen kleinen COnflict bauen?


    An alle Kiddies da draußen: Trotz Blutalkohol schaffe ich es, einen grammatisch und rechtschreibtechnisch nahezu einwandfreien Post OHNE die Korrekturfunktion meines Browsers zu posten. Schneidet Euch mal ne Scheibe davon ab...


  • (sind aber 7V und 470mA)


    Ein Legoventil geht auch, aber mir ging es um die schnelle Schaltzeit. Das mit dem Legoventil ist zwar leichter und einfacher zu bauen, schaltet aber auch viel langsamer und der Querschitt ist glaub ich auch kleiner.


    Mein Ventiel kostet etwa 8€ Materialkosten ohne die Ansteuerelektronik. Leider ist der erforderliche Maschienenpark auch erheblich größer ;( .
    Mein Ventil ist etwas kleiner als eine AA Baterie.

    Erfahrungen sind was sehr nützliches, leider macht man sie erst kurz nachdem man sie gebraucht hätte...

  • Also irgendwie komme ich auf keinen grünen Zweig. Ich bekomme nicht den Durchfluss hin den ich gerne hätte. Kann es sein das das Gas nicht schnell genug expandiert (flüssig->gas)? Kann es sein das ein Ventil einen Mindestdruck brauch um ganz dicht zu sein? Weil wenn der Tank fast leer ist entweicht minimal Gas aus dem Ventil.
    Fragen über Fragen. Aber Montag kümmere ich mich erstmal um den RC-Schalter. Hab keine ahnung vom Programmieren aber ich muss dieses Programm doch umgeschrieben bekommen, dass es eine maximale Einschaltdauer von 1Sekunde hat oder?

    Es ist nicht mein Programm und verweise auf: http://home.arcor.de/raik.apelt/rc-schalter.html


    /************************************************************************************/
    // Schalterfunktionalität an einem Empfänger- RC- Ausgang
    //
    // -> erprobt mit ATtiny13
    //
    // Version: 0.2
    //
    // Datum: 01.02.2010
    //
    // Hardware bei ATtiny13 (Taktfrequenz (4,8Mhz, CKDIV8 Vorteiler Fuse gesetzt -> 600kHz):
    // R/C-Kanal an PB1 (INT0)
    // Error-LED an PB2
    // Schalt-LED1 an PB3
    // Schalt-LED2 an PB4


    // Hardware bei ATmega8 (Taktfrequenz (1,0Mhz interner RC- Takt):
    // R/C-Kanal an PD2 (INT0)
    // Error-LED an PB2
    // Schalt-LED1 an PB3
    // Schalt-LED2 an PB4
    /************************************************************************************/
    // Compiler- Warnungen


    #ifndef F_CPU
    #warning "F_CPU not defined"
    #define F_CPU 600000UL
    #endif


    /************************************************************************************/
    // Libraries


    #include <avr/io.h>
    #include <avr/interrupt.h>
    #include <avr/wdt.h> // für Watchdog- Funktionen
    #include <stdint.h>


    /************************************************************************************/
    // Pin- Belegung


    #define RC_KanalEingang PINB // Eingangssignal R/C- Empfänger
    #define RC_KanalPin PINB1 // Pin für Eingangssignal R/C- Empfänger
    #define RC_KanalPort PORTB // Port für Eingangssignal R/C- Empfänger


    #define LED_Port PORTB // Port für Ausgänge
    #define LED_PortDDR DDRB // Datenrichtungsregister für Ausgänge
    #define SchaltErrorLED PB2 // Ausgang für Error LED
    #define SchaltLED1 PB3 // Ausgang für Schalt LED 1
    #define SchaltLED2 PB4 // Ausgang für Schalt LED 2


    /************************************************************************************/
    // Variablen


    static volatile uint8_t Reading; // Bit- Merker zur Sperrung der Hauptroutine während der erneuten Wertermittlung
    // Merker Flanke


    static volatile uint8_t Error; // Bit- Merker für Fehler
    static volatile uint8_t RCvalue; // empfangener Wert von R/C- Empfänger -> wird von Timer runtergezählt


    /************************************************************************************/
    //Header


    void RC_Read();
    void RC_Error();


    /************************************************************************************/
    // Interruptroutinen


    /* ISR für INT0 - R/C-Signal mit Timer lesen */
    ISR(INT0_vect)
    {
    RC_Read();
    }


    /* Fehlerbehandlung bei Timerüberlauf -> Fehler generieren */
    ISR(TIM0_OVF_vect)
    {
    RC_Error();
    }


    /************************************************************************************/
    // Hauptprogramm


    int main(void)
    {
    // Vorbereitung des RC- Eingangs
    // RC- Eingang ist schon nach Initialisierung des AVR ein Eingang
    RC_KanalPort |= (1<<RC_KanalPin); // interne Pull-Up-Widerstände aktivieren


    // Initialisierung LED- Ausgänge
    LED_PortDDR |= (1<<SchaltErrorLED)|(1<<SchaltLED1)|(1<<SchaltLED2); // Datenrichtung
    LED_Port |= (1<<SchaltErrorLED)|(1<<SchaltLED1)|(1<<SchaltLED2); // alle Portausgänge sind jetzt high
    // -> LED sind nun aus


    // Initialisierung Interrupteingang INT0
    MCUCR |= (1<<ISC00); // Interrupt wird bei jedem Pegelwechsel an INT0 ausgelöst
    GIMSK |= (1<<INT0); // Interrupt INT0 aktivieren


    // Initialisierung Timer0
    TIMSK0 |= (1<<TOIE0); // Timer0 Interrupt aktivieren

    // Initialisierung Watchdog auf 500ms, bedingt #include <avr/wdt.h>
    wdt_enable(WDTO_500MS);


    // Vorbereitung Status- Flags - kein Fehler liegt an, momentan kein Datenenpfang
    Reading = 0;
    Error = 0;

    // globale Interrupptfreigabe
    sei();


    /***********************************************************************************/
    while(1)
    {
    // Watchdog zurücksetzen
    wdt_reset();


    // Error- LED an, wenn Timer- Überlauf war
    if(Error == 1)
    {
    LED_Port &= ~(1<<SchaltErrorLED); // Portausgang Error- LED low -> LED an
    }
    else
    {
    LED_Port |= (1<<SchaltErrorLED); // Portausgang Error- LED high -> LED aus
    }

    // LED- Ausgabe während der langen Lesepause...
    if(Reading == 0)
    {
    // LED- Ausgänge schalten, je Timer- Wert -> erprobt mit ATmega8
    if(RCvalue > 100)
    {
    LED_Port &= ~(1<<SchaltLED1); // Portausgang Schalt- LED2 low -> LED an


    }
    else
    {
    LED_Port |= (1<<SchaltLED1); // Portausgang Schalt- LED1 high -> LED aus


    }

    if(RCvalue > 130)
    {
    LED_Port &= ~(1<<SchaltLED2); // Portausgang Schalt- LED2 low -> LED an
    }
    else
    {
    LED_Port |= (1<<SchaltLED2); // Portausgang Schalt- LED2 high -> LED aus
    }
    }
    }
    }


    /***********************************************************************************/


    // ISR für INT0 - R/C-Signal mit Timer lesen
    void RC_Read()
    {
    // Timer starten mit steigender Flanke
    if(Reading == 0)
    {
    TCCR0B |= (1<<CS01); // Start Timer0 mit Vorteiler 8
    Reading = 1; // Merker Flanke setzten
    }

    // Timer stoppen mit fallender Flanke
    else
    {
    TCCR0B = 0x00; // Stop Timer0
    RCvalue = TCNT0; // Wert von Timer lesen
    TCNT0 = 0x00; // neuen Startwert für Timer laden
    Reading = 0; // Merker Flanke setzten
    }


    Error = 0; // Error- Merker zurücksetzen
    }



    // ISR für Timer0 - Fehlerhandling Timeroverflow
    void RC_Error()
    {
    TCCR0B = 0x00; // Stop Timer0
    RCvalue = 0; // Wert für Ausgänge annehmen
    TCNT0 = 0x00; // neuen Startwert für Timer zurücksetzen
    Reading = 0; // Merker Flanke setzten
    Error = 1; // Error- Merker setzen
    }

    Erfahrungen sind was sehr nützliches, leider macht man sie erst kurz nachdem man sie gebraucht hätte...

  • Oder das von: http://www.ram-projects.de/mod…rc-schalter-mit-attiny13/


    $regfile = "attiny13.dat"
    $crystal = 9600000
    $hwstack = 16
    $swstack=8
    $framesize=24


    Config Portb.2 = Input
    Config Portb.1 = Output
    Config Portb.0 = Output
    Dim W As Word
    Do
    Pulsein W , Pinb , 2 , 1
    If W <= 150 Then
    Portb.0 = 0
    Portb.1 = 0
    End If
    If W > 150 And W <= 200 Then
    Portb.0 = 1
    Portb.1 = 1
    End If
    If W > 200 Then W = 200
    End If
    Loop
    End





    Es müsste doch jeweils nur ein Timer eingefügt werden oder nicht?

    Erfahrungen sind was sehr nützliches, leider macht man sie erst kurz nachdem man sie gebraucht hätte...

  • Wenn ich das Prog. von ram projects richtig verstehe wird eine eingangs pwm abgefragt, wenn diese unter 150 ist dann aus wenn größer als 150 dann ein.
    Durch End if
    loop
    geht das program wieder zum ersten if befehl, und sobalt die Bedingung von diesem erfüllt wird, fängt das Prog wieder von vorne mit dem abfragen an-


    Damit hat man eine einfache ein-aus schalter funktion.


    Ich kann nur minimal assembler und sonnst nichts an Prog. sprachen.


    Aber ich kann erklären was du wie programmieren musst.


    Der Teil bleibt:
    (wobei du nur einen output brauchst)
    Config Portb.2 = Input
    Config Portb.1 = Output
    Config Portb.0 = Output
    Dim W As Word
    Do
    Pulsein W , Pinb , 2 , 1
    If W <= 150 Then
    Portb.0 = 0
    Portb.1 = 0
    End If
    If W > 150 And W <= 200 Then


    Jetzt der befehl:
    Portb.0=1
    Portb.1=1
    und nach einem Wartebefehlt mit 1sec dauer der befehl
    Portb.0=0
    Portb.0=0
    Danach noch nen warte befehl für so 500ms und dann einfach ein Ende mit loop, damit das Programm von vorne anfängt.
    Die 500ms wartezeit sollen dazu dienen, das es nichts macht wenn man den Knopf/hebel nicht sofort wieder los lässt.


    Jetzt musst du nur nach den passenden "Befehlskürzeln" suchen ;D


    Quote

    Original von Krümmel
    Hab keine ahnung vom Programmieren


    Hast du dir nicht selber den Kreuzmischer in Böse gebaut?


    Gruß Kai

  • Gebaut ja aber nicht das Programm geschrieben. Ich weis wie ich das Programm auf das IC bekomme mehr aber auch nicht.


    Das mit den 1S und 0,5S gefällt mir nicht so ganz. Eine Einschaltsperre wäre nicht schlecht.
    Etwa so:


    if W > 150
    then PB1 = 1
    whait timer1 1s
    then PB1 = 0
    whait W <150
    loop


    So in der art. Geht das so? Wie schreibe ich das so in AVR Studio 5? Da kann ich nur sowas eintragen:
    // Interruptroutinen


    /* ISR für INT0 - R/C-Signal mit Timer lesen */
    ISR(INT0_vect)
    {
    RC_Read();
    }


    /* Fehlerbehandlung bei Timerüberlauf -> Fehler generieren */
    ISR(TIM0_OVF_vect)
    {
    RC_Error();
    }

    Erfahrungen sind was sehr nützliches, leider macht man sie erst kurz nachdem man sie gebraucht hätte...

  • wait ohne h ;D


    achso, dachte du hättest das Prog selber geschrieben.


    So wie du das meinst würde auch gehen, nur ist das nicht so einfach.
    Wie gesagt, ich kann nur ganz wenig assembler.


    IBF etc. könnt ihr das Progamm nicht kurz in schreiben? Sowas müsste für euch doch schnell machbar sein?

  • Quote

    Original von panzerbot
    Wie gesagt, ich kann nur ganz wenig assembler.


    IBF etc. könnt ihr das Progamm nicht kurz in schreiben? Sowas müsste für euch doch schnell machbar sein?


    Hm... irgendwie sehe ich da keinen Assembler... *grübel*


    Die ersten Listings sind C und die letzten erinnern mich eher an Basic (keine geschweiften Klammer,.. ein 'Do' ohne 'end'...). Die ganzen Spezialbefehle von dem Basic-Interpreter kenne ich nicht. Sorry Jungs, da kann ich euch nicht helfen.

  • Das ich nur ein wenig Assembler kann war in dem Sinne gemeint, das ich keine Ahnung von anderen Programmiersprachen habe und somit nicht wüsste was zu tun ist.


    Krümmel: Dann musste wohl lernen wie man Programmiert :D Kannst ja direkt mit Basic Anfangen, wir oft empfohlen. Viele sagen C, C++ und Java sind zu schwer für den Anfang, und solange du keinen Fahrtregler bauen willst mit Stufenloser Kennlinie sollte das Nötige Wissen recht schnell vorhanden sein.


    Gruß Kai

  • Reiner hast recht das sieht mir eher nach Basic aus.
    Mal sehen ob das das AVR Studio auch kann.

    Erfahrungen sind was sehr nützliches, leider macht man sie erst kurz nachdem man sie gebraucht hätte...

  • ;RcSchalter


    list p=16f870
    #include <p16f870.inc>


    __CONFIG _HS_OSC & _WDT_OFF & _PWRTE_ON & _CP_OFF & _BODEN_ON & _LVP_OFF & _CPD_OFF & _WRT_ENABLE_OFF & _DEBUG_OFF


    ; '__CONFIG' directive is used to embed configuration data within .asm file.
    ; The lables following the directive are located in the respective .inc file.
    ; See respective data sheet for additional information on configuration word.


    ; Konstanten festlegen
    freq Equ D'10' ; Frequenzangabe
    zschl1 Equ 0x20 ; Zähler für Zeit-Schleife
    zschl2 Equ 0x21 ; Zähler für Zeit-Schleife
    zschl3 Equ 0x22 ; Zähler für Zeit-Schleife


    ;***** VARIABLE DEFINITIONS
    w_temp EQU 0x71 ; variable used for context saving
    status_temp EQU 0x72 ; variable used for context saving


    ; Macros festlegen
    b0 MACRO ; auf Bank 0 schalten
    bcf STATUS, RP0
    bcf STATUS, RP1
    ENDM


    b1 MACRO ; auf Bank 1 schalten
    bsf STATUS, RP0
    bcf STATUS, RP1
    ENDM


    b2 MACRO ; auf Bank 2 schalten
    bcf STATUS, RP0
    bsf STATUS, RP1
    ENDM


    b3 MACRO ; auf Bank 3 schalten
    bsf STATUS, RP0
    bsf STATUS, RP1
    ENDM


    b02 MACRO ; auf Bank 0 oder 2 schalten
    bcf STATUS, RP0
    ENDM


    b13 MACRO ; auf Bank 1 oder 3 schalten
    bsf STATUS, RP0
    ENDM


    ;**********************************************************************
    ORG 0x000 ; processor reset vector


    clrf PCLATH ; ensure page bits are cleared
    goto Init ; go to beginning of program


    ORG 0x004 ; interrupt vector location


    movwf w_temp ; save off current W register contents
    movf STATUS,w ; move status register into W register
    movwf status_temp ; save off contents of STATUS register


    Init
    ;Outputs einstellen PinB0
    b1
    bcf TRISB, 0
    b0
    bcf PORTB, 0


    ;PortA = Digital
    b1
    movlw B'00000110'
    movwf ADCON1
    b0


    ;******************************************


    Main
    btfss PORTA, 0
    goto Main
    movlw .3
    call Zeit
    btfss PORTA, 0
    goto Main
    bsf PORTB, 0
    movlw .250
    call Zeit
    movlw .250
    call Zeit
    movlw .250
    call Zeit
    movlw .250
    call Zeit
    movlw .250
    call Zeit
    movlw .250
    call Zeit
    movlw .250
    call Zeit
    movlw .250
    call Zeit
    bcf PORTB, 0
    Warten1
    btfsc PORTA, 0
    goto Warten1
    Warten
    btfss PORTA, 0
    goto Warten
    movlw .3
    call Zeit
    btfsc PORTA, 0
    goto Warten1
    goto Main


    ;------------------------------------------------------------
    ; Unterprogramme


    ; Zeitschleife
    Zeit
    movwf zschl1 ; ms übertragen
    Zeit1
    nop ; warten
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    movlw D'47' ; Zeitkonstante für 1ms
    movwf zschl2 ; übertragen
    Zeit2
    nop ; warten
    movlw freq ; Zeitkonstante für Frequenz
    movwf zschl3 ; übertragen
    Zeit3
    nop ; warten
    nop
    decfsz zschl3, F ; vorbei?
    goto Zeit3 ; nein, noch nicht
    decfsz zschl2, F ; vorbei?
    goto Zeit2 ; nein, noch nicht
    decfsz zschl1, F ; vorbei?
    goto Zeit1 ; nein, noch nicht
    return ; Zeit abgelaufen


    END ; directive 'end of program'



    Die Einschiebungen hat der Editor hier leider nicht übernommen.
    Programm läuft einwandfrei.
    Was genau das Programm macht:


    Kommt eine Pwm < 1,5ms dann einfach aus
    Pwm >1,5ms dann 1sec lang Ventil auf(geschaltet)
    Danach wartet das Programm bis es wieder eine PWM < 1,5ms bekommt, bevor wieder geschaltet werden kann. Dadurch kann man nämlich solange wie man will den Ventilschalter an der Funke auf "an" stehen haben, jedoch wird das Ventil nur 1sec lang betätigt.


    Bin ich jetzt Elektrolurch? :D



    Edit: Das Unterprogramm "Zeit" hat Thorsten schon vor langer Zeit geschrieben und ich habe es einfach übernommen.
    Dadurch kann man für einen Wartebefehl der z.b 150ms dauern soll einfach movlw .150
    call Zeit


    schreiben


    Das geht ohne dieses Unterprogramm nicht, denn diese .150 steht eigentlich für 150 Befehle (Pic arbeitet 5mio in einer sec ab).

  • Quote

    Original von panzerbot
    Das ich nur ein wenig Assembler kann war in dem Sinne gemeint, das ich keine Ahnung von anderen Programmiersprachen habe und somit nicht wüsste was zu tun ist.


    Krümmel: Dann musste wohl lernen wie man Programmiert :D Kannst ja direkt mit Basic Anfangen, wir oft empfohlen. Viele sagen C, C++ und Java sind zu schwer für den Anfang, und solange du keinen Fahrtregler bauen willst mit Stufenloser Kennlinie sollte das Nötige Wissen recht schnell vorhanden sein.


    Gruß Kai


    Kai, das war kein Vorwurf, dass Du hier die Programmiersprache verwechselt hast. => Wollte Dich nur darauf hinweisen.


    Ich habe noch nie mit einem Prozessor gearbeitet, der schon einen Basic-Interpretor integriert hat. Aber eigentlich dürfte es auch damit möglich sein, einen Fahrtregler zu programmieren. Wo ich dabei Schwierigkeiten befürchte: Das "Abfangen" von den Empfängersignalen. Denn da muss man immer relativ zeitnah wissen, ob das Signal jetzt "high" oder "low" ist. Wenn der Basic-Interpretor da mal etwas zu lange mit sich beschäftigt ist, kann das Empfängersignal als "zu lange" gemessen werden. => Ist jetzt reine spekulation, ich habe keinerlei Erfahrung mit den Basic-Chips. Aber meine ganzen PC-Programme unter Windows bisher mit Visual-Basic gemacht. Das ist zum Einstieg zu Empfehlen. (Zumindest die alten Versionen, mit denen ich bisher gearbeitet habe. Unter Dot.Net habe ich auch noch nichts gemacht, weil ich keine kostenlose Basic-Version gefunden habe, die man hinterher auch weiterverwenden darf....)


    Das o.g. Programm von Thorsten ist jetzt in Assembler für einen PIC-Prozessor. (Endlich jemand aus der PIC-Fraktion und nicht immer nur Atmel. :D;) )
    Einen Failsafe hat Thorsten leider nicht integriert. Wenn mit einer Spektrum-Funke (also 2.4GHz) gearbeitet wird, dann befürchte ich auch keine Fehlauslösungen. Wenn da allerdings eine 40MHz-Funke eingesetzt wird, dann wäre ich etwas vorsichtig. Aber: Der Schalter kommt ja nicht einem CO2-Feather zum Einsatz, sondern in einem Ant. Eine Fehlauslösung ist also kein Problem.


    Quote

    Bin ich jetzt Elektrolurch? großes Grinsen


    Yep, darfst Dir bei den Rangabzeichen den ersten SMD-Widerstand auf die Schulterklappen nähen. :D
    Nein, im Ernst: Danke für's kümmern und das Listing hier. Ist ganz lehrreich für unseren µC-Nachwuchs hier.


    Was ich überlesen habe: Welchen Quarz hat Thorsten bei dem PIC verwendet? Oder braucht dieser PIC-Typ keinen Quarz, weil standardmäßig der interne RC-Oszillator verwendet wird? (=> hab' jetzt ehrlich gesagt keine Lust, das Datenblatt zu laden und durchzulesen. :rolleyes: )

  • Kann ich mit einem AVR ISP Programmer einen Pic programmieren? Kann ich das programm auch in einen Attiny Programmieren (weil die habe ich noch hier).
    Jetzt versteh ich noch weniger als vorher.

    Erfahrungen sind was sehr nützliches, leider macht man sie erst kurz nachdem man sie gebraucht hätte...

  • Quote

    Original von Krümmel
    Kann ich mit einem AVR ISP Programmer einen Pic programmieren? Kann ich das programm auch in einen Attiny Programmieren (weil die habe ich noch hier).
    Jetzt versteh ich noch weniger als vorher.


    Dass der AVR ISP-Programmer einen PIC-Prozessor programmieren kann, das bezweifle ich, möchte es aber nicht 100% ausschließen.


    Das o.g. PIC-Programm wird in einem Attiny aber keinesfalls laufen. Wie Du im o.g. Programm siehst, werden hier die Ports direkt angesprochen. Ausserdem sind das die speziellen Assembler-Befehle, die das Arbeiten mit dem PIC-Prozessor so schön erleichtern. Nämlich direkt ein Portbit setzen. Oder ein Zähler-Register mit einem einzigem Befehl um 1 verringern und gleichzeitig prüfen, ob es schon auf Null heruntergezählt hat (also am Ziel seiner Schleife ist). Das alles wird der Attiny nicht mit diesen Befehlen können.


    (Vergleichbar: Du kaufst Dir eine Waschmaschine, kriegst aber die Bedienungsanleitung von einem Geschirrspüler mit. Mit Ausnahme, dass der Stecker in die Steckdose passt, werden sich die beiden Geräte grundsätzlich unterscheiden.... ;) )

  • Pic läuft mit 20mhz. Werde nächstes We Platinen in auftrag geben, da kommt dann ein SMD Pic drauf mit interner 4mhz clock.


    Krümmel: wir könnens so machen das ich dir ne Lochrasterplatine mit fertiger Schaltung + Programmer schick, dann kann ich dir das Programm umschreiben wenn was nicht passt und du musst es nur auf den Pic machen. Oder ich mach auf die Platine nen Picsockel und schick dir paar Pics die auf verschiedene Zeiten Programmiert sind, dann kannste rumtesten.

  • Hab jetzt mal das Proramm umgechrieben:


    /************************************************************************************/
    // Schalterfunktionalität an einem Empfänger- RC- Ausgang
    //
    // -> erprobt mit ATtiny13
    //
    // Version: 0.2
    //
    // Datum: 01.02.2010
    //
    // Hardware bei ATtiny13 (Taktfrequenz (4,8Mhz, CKDIV8 Vorteiler Fuse gesetzt -> 600kHz):
    // R/C-Kanal an PB1 (INT0)
    // Error-LED an PB2
    // Schalt-LED1 an PB3
    // Schalt-LED2 an PB4


    // Hardware bei ATmega8 (Taktfrequenz (1,0Mhz interner RC- Takt):
    // R/C-Kanal an PD2 (INT0)
    // Error-LED an PB2
    // Schalt-LED1 an PB3
    // Schalt-LED2 an PB4
    /************************************************************************************/
    // Compiler- Warnungen


    #ifndef F_CPU
    #warning "F_CPU not defined"
    #define F_CPU 600000UL
    #endif


    /************************************************************************************/
    // Libraries


    #include <avr/io.h>
    #include <avr/interrupt.h>
    #include <avr/wdt.h> // für Watchdog- Funktionen
    #include <stdint.h>


    /************************************************************************************/
    // Pin- Belegung


    #define RC_KanalEingang PINB // Eingangssignal R/C- Empfänger
    #define RC_KanalPin PINB1 // Pin für Eingangssignal R/C- Empfänger
    #define RC_KanalPort PORTB // Port für Eingangssignal R/C- Empfänger


    #define LED_Port PORTB // Port für Ausgänge
    #define LED_PortDDR DDRB // Datenrichtungsregister für Ausgänge
    #define SchaltLED2 PB4 // Ausgang für Schalt LED 2


    /************************************************************************************/
    // Variablen


    static volatile uint8_t Reading; // Bit- Merker zur Sperrung der Hauptroutine während der erneuten Wertermittlung
    // Merker Flanke


    static volatile uint8_t RCvalue; // empfangener Wert von R/C- Empfänger -> wird von Timer runtergezählt


    /************************************************************************************/
    //Header


    void RC_Read();


    /************************************************************************************/
    // Interruptroutinen


    /* ISR für INT0 - R/C-Signal mit Timer lesen */
    ISR(INT0_vect)
    {
    RC_Read();
    }


    /************************************************************************************/
    // Hauptprogramm


    int main(void)
    {
    // Vorbereitung des RC- Eingangs
    // RC- Eingang ist schon nach Initialisierung des AVR ein Eingang
    RC_KanalPort |= (1<<RC_KanalPin); // interne Pull-Up-Widerstände aktivieren


    // Initialisierung LED- Ausgänge
    LED_PortDDR |= (1<<SchaltLED2); // Datenrichtung
    LED_Port |= (1<<SchaltLED2); // alle Portausgänge sind jetzt high
    // -> LED sind nun aus


    // Initialisierung Interrupteingang INT0
    MCUCR |= (1<<ISC00); // Interrupt wird bei jedem Pegelwechsel an INT0 ausgelöst
    GIMSK |= (1<<INT0); // Interrupt INT0 aktivieren


    // Initialisierung Timer0
    TIMSK0 |= (1<<TOIE0); // Timer0 Interrupt aktivieren

    // Initialisierung Watchdog auf 500, bedingt #include <avr/wdt.h>
    wdt_enable(WDTO_1S);


    // Vorbereitung Status- Flags - kein Fehler liegt an, momentan kein Datenenpfang
    Reading = 0;

    // globale Interrupptfreigabe
    sei();


    /***********************************************************************************/
    while(1)
    {
    // Watchdog zurücksetzen
    wdt_reset();



    // LED- Ausgabe während der langen Lesepause...
    if(Reading == 0)
    {
    // LED- Ausgänge schalten, je Timer- Wert -> erprobt mit ATmega8
    if(RCvalue > 100)
    {
    LED_Port |= ~(1<<SchaltLED2); // Portausgang Schalt- LED2 hig -> LED aus
    }

    if(RCvalue > 130)
    {
    LED_Port &= ~(1<<SchaltLED2); // Portausgang Schalt- LED2 low -> LED an
    _delay_ms (500); // 500 ms warten
    LED_Port |= ~(1<<SchaltLED2); // Portausgang Schalt- LED2 hig -> LED aus

    }
    }
    }
    }


    /***********************************************************************************/


    // ISR für INT0 - R/C-Signal mit Timer lesen
    void RC_Read()
    {
    // Timer starten mit steigender Flanke
    if(Reading == 0)
    {
    TCCR0B |= (1<<CS01); // Start Timer0 mit Vorteiler 8
    Reading = 1; // Merker Flanke setzten
    }

    // Timer stoppen mit fallender Flanke
    else
    {
    TCCR0B = 0x00; // Stop Timer0
    RCvalue = TCNT0; // Wert von Timer lesen
    TCNT0 = 0x00; // neuen Startwert für Timer laden
    Reading = 0; // Merker Flanke setzten
    }


    }



    // ISR für Timer0 - Fehlerhandling Timeroverflow
    void RC_Error()
    {
    TCCR0B = 0x00; // Stop Timer0
    RCvalue = 0; // Wert für Ausgänge annehmen
    TCNT0 = 0x00; // neuen Startwert für Timer zurücksetzen
    Reading = 0; // Merker Flanke setzten
    }






    Allerdings meckert der bei dem hier:


    if(RCvalue > 130)
    {
    LED_Port &= ~(1<<SchaltLED2); // Portausgang Schalt- LED2 low -> LED an
    _delay_ms (500); // 500 ms warten
    LED_Port |= ~(1<<SchaltLED2); // Portausgang Schalt- LED2 hig -> LED aus

    }



    Und Ich bekomme in AVR Studio 5 Keine Hex Datei zum programmieren erstellt.

    Erfahrungen sind was sehr nützliches, leider macht man sie erst kurz nachdem man sie gebraucht hätte...

  • Quote

    Kann es sein das das Gas nicht schnell genug expandiert (flüssig->gas)?


    Dafür ist der Buffertank gut.
    Der liegt direkt vor dem Ventil.
    Direkt verbunden mit dem Tank,
    aber SO, dass das Flüssiggas NICHT in den Buffertank
    läuft, da nichts direkt zwischen Tank und Buffertank steht, expandiert das Gas und "geht" in den Buffertank Gasförmig.
    Das ausgedehnte Gas liegt vor dem Ventil und kann nach dem öffnen DIREKT durchströmen.