Hilfe mit dem Code (C#)

[Tobias N. (silberkristall)]

Hallo,

ich habe mir eine Schaltung zusammen gebaut und diese mit dem folgenden 
Code geflasht.

http://nopaste.info/d182180668.html

Der Käfer ist ein ATMega8. So weit läuft auch alles, der Fototransistor 
etc. alles klappt, allerdings habe ich ein problem ab Zeile 101.

Das ganze sollte folgendermassen laufen:

Wenn auf BLI (PC3) GND anliegt schalte den Transistor an BLO (PC1).
Liegt nach einer Sekunde immernoch GND an BLI dann schalte nicht mehr.
Liegt nach einer Sekunde kein GND mehr an Schalte BLO noch für 2 sek und 
schalte dann ab.

Das klappt auch soweit mit dem Code, allerdings brauche ich eine Lösung 
er kennt ob GND gehalten wird, und wenn ja, dann warte solange bis kein 
GND mehr anliegt, allerdings tue auch solange nicht.

Also, wird BLI kurz auf Masse gezogen schalte transistor für 3 sek. Wird 
BLI auf Masse gehalten tue nichts, auch wenn masse wieder abfällt nicht. 
Sondern erst wenn wieder auf Masse gezogen wird.

Ich hoffe das ist verständlich und jemand kann mit dabei weiter helfen.

[Karl H. (kbuchegg)]

Wenn man sich maximal unbeliebt machen will, dann verstreut man die 
Bestandteile seines Projekts auf möglichst vielen Web-Seiten, damit es 
für die Forenteilnehmer möglichst kompliziert wird, sich die Einzelteile 
anzusehen, zu studieren und mit deiner Beschreibung in Einklang zu 
bringen. Das gilt für Photos. Und in noch größerem Masse gilt es für 
Code

#include <avr/io.h>
#include <avr/interrupt.h>
 
#define LICHT    PC0    // Licht port
#define BLO      PC1    // Blinker links ausgangsport
#define BRO     PC2    // Bliner rechts ausgangsport
#define BLI      PC3    // Blinker links eingangsport
#define BRI      PC4    // Blinker rechts eingangsport
#define FOTOTR     PC5    // Fototransistor
#define STRPORT PORTC
#define STRDDR  DDRC
 
// Variablen
int timerstat = 0;
int lichtsek = 3;
int lichtstat = 0;
int blinkerlinkson = 0;
int blt = 10;    // Blinkerlinkstimerzeit
int brt = 10;    // Blinkerrechtstimerzeit
//Variable für die Zeit des Timers
volatile unsigned int sekunde;
 
// Timer ISR
ISR(TIMER1_OVF_vect) {       
    TCNT1 = 49911;      // Zaehlregister mit Vorladewert vorladen
    sekunde++;            // Variable hochzählen
    blt++;
    brt++;
}
 
 
/* ADC initialisieren */
void ADC_Init(void) {
 
  uint16_t result;
 
  // interne Referenzspannung als Refernz für den ADC wählen:
  ADMUX = (1<<REFS1) | (1<<REFS0);
 
  // Bit ADFR ("free running") in ADCSRA steht beim Einschalten
  // schon auf 0, also single conversion
  ADCSRA = (1<<ADPS1) | (1<<ADPS0);    // Frequenzvorteiler
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren
  /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
    also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
 
  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung
  while (ADCSRA & (1<<ADSC) ) {        // auf Abschluss der Konvertierung warten
  }
  /* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten
    Wandlung nicht übernommen. */
  result = ADCW;
}
 
/* ADC Einzelmessung */
uint16_t ADC_Read( uint8_t channel )
{
  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {  // auf Abschluss der Konvertierung warten
  }
  return ADCW;                    // ADC auslesen und zurückgeben
}
 
int main (void) {
 
// Setze Portausgänge
    STRDDR |= (1 << LICHT);    // Licht
    STRDDR |= (1 << BLO);         // Blinker Links
    STRDDR |= (1 << BRO);         // Blinker Rechts
    
// Setze Porteingänge
    STRDDR &= ~(1 << BLI);        // Blinker Links
    STRDDR &= ~(1 << BRI);     // Blinker Rechts
    STRDDR &= ~(1 << FOTOTR);     // Fototransistor
// Timer
  // Global Interrupts aktivieren
  sei();
     
    TIMSK |= (1<<TOIE1);
    TCCR1B |= (1<<CS11) |  (1<<CS10);    //Prescaler = 64
    TCNT1 = 0xFFFF;        //Zaehlregister vorladen mit FFFF zum Sofortstart
uint16_t adcval;
ADC_Init();
 
// Hauptcode
  while(1)
  {
 
    // Lichtsensor
    adcval = ADC_Read(5);  // Kanal 5
    if (adcval > 400) { STRPORT &= ~(1 << LICHT); } else { STRPORT |= (1 << LICHT); }
    
    // Blinker Links
   
    if (blt == 1)
        {
            if (!(PINC & 1<< BLI)) // Taster pressed
                {
                    blt = 10;
                    blinkerlinkson = 0;
                }
        }
        else
        {
            if (!(PINC & 1<< BLI)) // Taster pressed
                {
                    blt = 0;
                    blinkerlinkson = 1;
                }
        }
    if (blt == 3)
        {
            blinkerlinkson = 0;
        }
        
    if (blinkerlinkson == 1)
        {
            STRPORT |= (1 << BLO);
        }
        
    if (blinkerlinkson == 0)
        {
            STRPORT &= ~(1 << BLO);
        }
  }
}

[Tobias N. (silberkristall)]

sorry, ich bin es grundsätzlich gewöhnt ein pastebin zu nutzen. z.b. in 
einem chat (irc) kommt es nicht so gut wenn man einen ganzen code 
postet. zumal in einem pastebin der code auch editierbar dargestellt 
wird. aber ok, ich werde es mir merken den code direkt zu posten.

[Karl H. (kbuchegg)]

Tobias N. schrieb:

> Also, wird BLI kurz auf Masse gezogen schalte transistor für 3 sek. Wird
> BLI auf Masse gehalten tue nichts, auch wenn masse wieder abfällt nicht.
> Sondern erst wenn wieder auf Masse gezogen wird.
>
> Ich hoffe das ist verständlich und jemand kann mit dabei weiter helfen.

die Lösung deines Problems liegt darin, dass du weg musst von 'Ist eine 
Taste gedrückt' und hin musst zu 'Hat sich der Zustand des Eingangs 
verändert (im Vergleich zum letzten mal als nachgesehen wurde) und wenn 
ja, wie hat er sich verändert'. Du brauchst eine Flankenerkennung.


Im Prinzip kann das zb so aussehen

   ...

   oldLinks = jetziger Pin Status;

   while( 1 )    // Hauptschleife
   {
     newLinks = jetziger Pin Status;

     if( oldLinks != newLinks )    // Hoppla, am Pin hat sich was getan!
     {
       if( newLinks == Zustand Low )    // der Pin ist von 1 auf 0 gewechsel
       {
         mach was für den Fall einer fallenden Flanke
       }

       else                             // der Pin ist von 0 auf 1 gewechselt
       {
         mach was für den Fall einer steigenden Flanke
       }
     }
   }

Und in diese Flankenerkennung bettest du jetzt deine Zeitsteuerung ein.
Die im Prinzip so aussieht, dass du dir bei der fallenden Flanke den 
Wert einer vom Timer hochzählenden Variablen merkst und bei der 
steigenden Flanke mit dem dann aktuellen Wert vergleichst. Wenn die 
Differenz klein genug ist, dann war auch der Puls kurz genug und du 
machst dein Ding und startest die LED. Ist er aber größer als dein 
Grenzwert, dann machst du gar nichts.

Wobei ich das 'Nachleuchten' der LED so realisieren würde, dass in der 
Timer ISR (die auch auf weniger als 1 Sekunde einstelle), ein Zähler 
heruntergezählt wird, der im Prinzip eine Eieruhr realisiert und der bei 
erreichen von 0 dann die LED abschaltet.

volatile uint8 LEDLinks;

ISR( ... )
{
  if( LEDLinks > 0 )
  {
    LEDLinks--;
    if( LEDLinks == 0 )
      schalte Linke LED ab
  }

  ....
}

Im Hauptprogramm muss man dann nur noch die LED einschalten, den Zähler 
LEDLinks auf einen vernünftigen Wert setzen (hängt davon ab, wie oft die 
ISR aufgerufen wird), und nach Ablauf der mit diesem Wert verknüpften 
Zeit, schaltet die ISR die LED wieder ab.


Das sind so die Einzelteile, von denen ich denke, dass sie dir 
weiterhelfen. Vorausgesetzt ich hab deine Problembeschreibung richtig 
verstanden.

[Tobias N. (silberkristall)]

also das ganze soll halt erkennen ob eine taste gedrückt oder gehalten 
wird. also wird die taste nur einmal gedrückt schalte den transistor 3 
sek, danach schalte ab. wird die taste gehalten dann tue nichts, selbst 
wenn die taste wieder losgelassen wird. also reagiere auf tippen und 
nicht auf halten, wird gehalten dann tue solange nichts bis die taste 
wieder getippt wird.

also, wird der blinker links nur angetippt, blinke 3mal (etwa 3sek) wird 
der blinker aber komplett geschaltet (an einer ampel z.b. beim abbiegen) 
dann tue, selbst wenn der blinker nach der kurve von alleine ausgeht 
nichts, also tue nur was wenn der hebel angetippt wird.

das soll halt werden: 1x tippen, 3 x blinken

derzeigt erkennt man code zwar 1x tippen, 3 x blinken aber wenn man den 
hält und dann z.b. 10sek später den blinker ausmacht, dann schaltet der 
code 1sek später den blinker nochmal für 3 sek. und das muss ich 
irgendwie erkennen und "abschalten".

[Karl H. (kbuchegg)]

Tobias N. schrieb:
> also das ganze soll halt erkennen ob eine taste gedrückt oder gehalten
> wird. also wird die taste nur einmal gedrückt schalte den transistor 3
> sek, danach schalte ab. wird die taste gehalten dann tue nichts, selbst
> wenn die taste wieder losgelassen wird. also reagiere auf tippen und
> nicht auf halten, wird gehalten dann tue solange nichts bis die taste
> wieder getippt wird.

Ja.
Und da dein µC genausowenig wie du ein Hellseher ist, läuft es darauf 
hinaus, auszumessen wie lange die Taste gedrückt wurde. Wird die Taste 
niedergedrückt, dann startet eine Stoppuhr, wird sie losgelassen, dann 
stoppt die Stoppuhr. Und erst dann kannst du entscheiden ob das ein 
kurzes Antippen oder langes Halten war.

Und genau so läuft das dann auch im Code
Beim Niederdrücken die aktuelle 'Uhrzeit' merken. Beim Loslassen die 
dann aktuelle "Uhrzeit" holen, beide vergleichen und aus der Differenz 
der beiden die weiteren Schlüsse ziehen. 'Uhrzeit' ist nichts anderes 
als ein Zähler, der zb Timergesteuert alle 0.01 Sekunden um 1 hochzählt.

Aber der springende Punkt ist, dass du erst beim Loslassen der Taste 
diese Unterscheidung treffen kannst, wobei du zu kurze Tastendrücke als 
Tastenprellen gleich mit verwirfst.

[Karl H. (kbuchegg)]

Ich weiß schon, dass du von deinem Code retten willst, was zu retten 
ist.
Aber erstens ist das nicht viel Code und zweitens denke ich, dass du mit 
diesem Code nicht vernünftig weiter kommst. Du stehst fast am Ende in 
einer Sackgasse und die einzige Chance ist es umzudrehen und an den 
Anfang zurückzufahren.
So aufwändig ist das ganze ja nicht. Die paar Codezeilen hast du gleich.

[Tobias N. (silberkristall)]

ja, wie du schon sagst, viel is es nicht. und naja das bisschen kann ich 
wirklich neu machen. mir hing es da nur ein wenig an der umsetzung, nach 
deiner erklärung nun ist es für mich auch jetzt klarer geworden.

wurde taste gedrücke zähle solange taste gedrückt wird.
 danach werte aus, wurde taste länger als 1sek (ist ja dann veränderbar) 
gedrückt tue garnichts, ansonsten schalte den transistor 3 sek.