unterbrechbare Ausschaltverzögerung für Peak&Hold

[Thomas (Gast)]

Guten Morgen zusammen,
ich habe einen funktionierenden C-Code für eine Peak&Hold-Ansteuerung 
(siehe unten). Ziel der Peak&Hold ist es, sobald der Taster gedrückt 
wird, gibt es einen Peak z.B. 500ms und dannach geht er in den 
Haltezustand über. Sobald der Taster aber losgelassen wird, muss das 
Ausgangssignal sofort auf Null gehen (auch in der Peak-Phase).

Bei diesem Code wird ein Inkrement i++; verwendet. Ich habe mit Abbsicht 
kein "delay" verwendet, da wenn der Taster nicht mehr gedrückt wird, die 
gewünschte Unterbrechnung nicht funktioniert. Daher wurde das Inkrement 
verwendet und die Optimierung ausgeschaltet bzw. O0 gewählt.
Will ich nun weitere unabhänige Funktionsstrukturen mit in den C-Code 
einbauen, die ein "delay" verwenden, muss ich den Optimierer ja 
aktivieren. Dann wird das Inkrement aber entfernt.

Durch welche Programmierstruktur oder Abänderung kann das Problem 
angegangen werden? Hab schon überlegt mit Timer, wusster aber nicht so 
recht wie und ob überhaupt möglich.
Wäre froh wenn ihr mir ein paar Tipps geben könnt. Vielen Dank.
Gruß Thomas

#include <avr/io.h>          
#define F_CPU 3686400
#include <util/delay.h>
#include <stdint.h>


int main()
{
  // Konfiguration Timer/Counter 2
  TCCR2 = 0b01100001; // Timer Control Register 
  DDRB  = 0b00111000; // Data Direction Register B: 0=Eingänge; 1=Ausgänge


  // Konfiguration AD-Wandler
  ADMUX = 0xE0;
  ADCSRA = 0xE0;
    
  PORTB= 0b00000011;          // Pull-up Widerstand: 1=aktiv 
  char Taster=0b00000001;
  char z=0;
  char PEAK=180;
  char HOLD=20;
  char OFF=0;
  unsigned int HOLD_TIME=50000;
  unsigned int i=0;

  while(1)
  {
    switch(z)
    {
    case 0: OCR2 = OFF;
        i=0;

        if(!(PINB & Taster))
        z=1;
        else
        {
        z=0;
        }
        break;

    case 1:  OCR2 = PEAK;
        i++;
        
        if(PINB&Taster)
        z=0;
        else
        {
          if(!(PINB & Taster)&&(i<HOLD_TIME))
          z=1;
          else
          {
          z=2;
          }
        }
        break;
    
    case 2: OCR2 = HOLD;

        if(!(PINB & Taster)&&(i=HOLD_TIME))
        z=2;
        else
        {
        z=0;
        }
        break;
    }
  }
}

[Thomas (Gast)]

Hallo zusammen,
hab ich mich so schlecht ausgedrückt oder weiß das wirklich niemand 
hier?
Habe drei verschiedene Zustände "Peak", "Hold" und "Off". Diese sollen 
mit einem Taster gesteuert werden. Wird der Taster lange genug gedrückt, 
soll er nach der "Peak"-Phase in den "Hold"-Zustand übergehen. Sobald 
der Taster nicht mehr gedrückt wird, egal ob in der "Peak" oder "Hold" 
Phase soll am Ausgang Null bzw. "Off" anliegen.
Wie gesagt wär euch wirklich dankbar, wenn ihr mir Tipps für die 
programmiertechnische Umsetztung geben könnt.
Mit hoffnungsvollen Grüßen
Thomas

[Jobst M. (jobstens-de)]

Thomas schrieb:
> hab ich mich so schlecht ausgedrückt

Jop. es fehlt mindestens die Hälfte!

Du beschreibst Dinge, die im Code nicht vorkommen und keiner weiß, was 
aussen herum passiert.

Du redest z.B. von einem Ausgang. Wo ist der? Im Program und in der 
Hardware?

Also: Komplette Software (und dann auch bitte als Anhang) und Schaltplan 
schicken.


Gruß

Jobst

[Thomas (Gast)]

Naja ich weiß nicht ob die komplette Software hilfreich ist. Anbei habe 
ich sie hinzugefügt. Es geht um die Ansteuerung auf ein LCD-Display. 
Hier benötige ich eben die "delay"-Befehl.

Wie gesagt mit dem "Inkrement" funktioniert die Peak&Hold-Ansteuerung 
einwandfrei. Wird die Darstellung auf dem LCD-Display mit eingebunden 
und der Optmierer aktiviert, funktioniert die Peak&Hold nicht mehr.

Hoff wirklich auf einen guten Tipp. Danke!

/********************************************************************
*                                  *
*              LCD-Text                *
*                                  *
*********************************************************************
*                                  *
*  Funktion:  Textausgabe auf myAVR LCD-Display im 4-BitModus    *
*  Schaltung:  myAVR-Display am Stecker angesteckt          *
*        PortD Bit 4-7:  Daten                *
*        PortD Bit 2:   RS, high=Daten, low=Kommando    *
*        PortD Bit 3:   E, high-Impuls für gültige Daten  *
*                                  *
*********************************************************************
*                                  *
*  Autor:    Prof. Dr.-Ing. U. Kosiedowski            *
*  Version:  1.0                          *
*  Datum:    13.04.2010                      *
*                                  *
********************************************************************/



//==================================================================
//        Funktion für LCD-Kommandos
//==================================================================
//  Name:    lcd_cmd(cmd)
//  Funktion:  sendet ein Kommando an das LCD-Display
//  Argument:  cmd: Kommando, 1 Byte
//==================================================================

#include <avr/io.h>            // Bezeichnungen für Register
#define F_CPU 3686400
#include <util/delay.h>
#include <stdint.h>

void lcd_cmd(unsigned char cmd)
{
  unsigned char tmp = cmd;  // Kommando in Arbeitsvariable speichern
  tmp &= 0xF0;        // unteres Halbbyte ausblenden, RS=0, E=0
  PORTD = tmp;        // Signalausgabe
  tmp |= 0x08;        // Bit 3 setzen -> E=1
  PORTD = tmp;        // Signalausgabe
  tmp &= 0xF7;        // Bit 3 rücksetzen -> E=0
  PORTD = tmp;        // Signalausgabe
  
  tmp = cmd<<4;        // Kommando unteres Halbbyte -> Arbeitsvariable
  PORTD = tmp;        // Signalausgabe
  tmp |= 0x08;        // Bit 3 setzen -> E=1
  PORTD = tmp;        // Signalausgabe
  tmp &= 0xF7;        // Bit 3 rücksetzen -> E=0
  PORTD = tmp;        // Signalausgabe
  _delay_ms(1);        // Verzögerung 1ms -> Ausführung
}

//==================================================================
//        Funktion zur Anzeige einer Zeichenkette
//==================================================================
//  Name:    lcd_text(char* pText)
//  Funktion:  sendet eine Zeichenkette an das LCD-Display
//        Zeichenkette muss mit 0x00 abgeschlossen sein
//  Argument:  cmd: Zeiger auf Anfang der Zeichenkette, 1 Byte
//==================================================================
void lcd_text(char* pText)
{
  int j = 0;            // Zählvariable für Zeichen
  while(pText[j]!=0)        // Ausgabe bis 0-Zeichen als Ende-Kennung
  {
    unsigned char tmp = pText[j];  // Text in Arbeitsvariable speichern
    tmp &= 0xF0;        // unteres Halbbyte ausblenden, RS=1, E=0
    tmp |= 0x04;        // Bit 2 setzen -> RS=1
    PORTD = tmp;        // Signalausgabe
    tmp |= 0x08;        // Bit 3 setzen -> E=1
    PORTD = tmp;        // Signalausgabe
    tmp &= 0xF7;        // Bit 3 rücksetzen -> E=0
    PORTD = tmp;        // Signalausgabe
    
    tmp = pText[j]<<4;      // Kommando unteres Halbbyte -> Arbeitsvariable
    tmp |= 0x04;        // Bit 2 setzen -> RS=1
    PORTD = tmp;        // Signalausgabe
    tmp |= 0x08;        // Bit 3 setzen -> E=1
    PORTD = tmp;        // Signalausgabe
    tmp &= 0xF7;        // Bit 3 rücksetzen -> E=0
    PORTD = tmp;        // Signalausgabe
    
    _delay_ms(1);        // Verzögerung 1ms -> Ausführung
    j++;            // Index auf nächstes Zeichen setzen
  }
}

//==================================================================
//        Funktion zur Initialisierung des LCD-Displays
//==================================================================
//  Name:    lcd_goto(int row, int col)
//  Funktion:  Positionierung des Cursors
//  Argumente:  row: Zeile 1..2, integer
//        col: Spalte 1..16, integer
//==================================================================
void lcd_goto(char row, char col)
{
  row--;        // Null-basierend
  row&=0x01;      // sicherheitshalber
  row*=0x40;      // Zeile nach Bit 6 bringen
  col--;        // Null-basierend
  col&=0x0f;      // sicherheitshalber
  char tmp=row|col;
  tmp|=0x80;      // Cursor setzen
  lcd_cmd(tmp);    // senden
}

//==================================================================
//        Funktion zur Initialisierung des LCD-Displays
//==================================================================
//  Name:    lcd_init()
//  Funktion:  Initialisierung der Ports
//        Initialisierung des LCD-Displays
//  Argument:  N/A
//==================================================================
void lcd_init()
{
  DDRD=0xff;            // Port D als Ausgang konfigurieren
  PORTD=0;            // Port D löschen bis LCD gebootet hat
  _delay_ms(50);          // LCD-Bootvorgang -> Verzögerung 50ms
    
  // Soft-RESET Kommando 3x senden          
  PORTD = 0x30;          // Soft-Reset Kommando, E=0, RS=0
  PORTD = 0x38;          // Soft-Reset Kommando, E=1, RS=0
  PORTD = 0x30;          // Soft-Reset Kommando, E=0, RS=0
  _delay_ms(5);          // Befehlsausführung -> Verzögerung 5ms
  
  PORTD = 0x38;          // Soft-Reset Kommando, E=1, RS=0
  PORTD = 0x30;
  _delay_ms(1);          // Befehlsausführung -> Verzögerung 1ms
  
  PORTD = 0x38;          // Soft-Reset Kommando, E=1, RS=0
  PORTD = 0x30;
  _delay_ms(5);          // Befehlsausführung -> Verzögerung 5ms
  
  // 4-BitModus einschalten
  PORTD=0x20;            // oberes Halbbyte, E=0, RS=0
  PORTD=0x28;            // oberes Halbbyte, E=1, RS=0
  PORTD=0x20;  
  _delay_ms(1);          // Befehlsausführung -> Verzögerung 5ms
  
  // ab hier läuft das LCD im 4-Bit-Modus
  lcd_cmd(0x28);          // Funktions-Set: 2 Zeilen, 5x7 Matrix, 4 Bit
  lcd_cmd(0x06);          // Entry Mode
  lcd_cmd(0x0E);          // LCD einschalten
  lcd_cmd(0x01);
  _delay_ms(1);          // Befehlsausführung -> Verzögerung 2ms
}






//==================================================================
//        Funktion zur Umwandlung von Zahlen in Text
//==================================================================
//  Name:    lcd_zahl()
//  Funktion:  Zahl in Text
//  Argument:  Zahl, Zahl_T
//==================================================================
  void lcd_zahl(unsigned int zahl,char *Zahl_T)

  {
    unsigned char Ziffer100=0;
    unsigned char Ziffer10=0;
    unsigned char Ziffer1=0;

    while(zahl>=100)        // Hunderterstelle
    {
    Ziffer100++;
    zahl-=100;
    }

    while(zahl>=10)          // Zehnerstelle
    {
    Ziffer10++;
    zahl-=10;
    }
    
    while(zahl>=1)           // Einserstelle
    {
    Ziffer1++;
    zahl-=1;
    }

    Zahl_T[0]=Ziffer100+0x30;
    Zahl_T[1]=Ziffer10+0x30;
    Zahl_T[2]=Ziffer1+0x30;
  }


/*======================================================================================
        HAUPTPROGRAMM
======================================================================================*/
 
 int main()
{
  // Konfiguration Timer/Counter 2
  TCCR2 = 0b01100001; // Timer Control Register 
  DDRB  = 0b00111000; // Data Direction Register B: 0=Eingänge; 1=Ausgänge


  // Konfiguration AD-Wandler
  ADMUX = 0xE0;
  ADCSRA = 0xE0;
    
  PORTB= 0b00000011;          // Pull-up Widerstand: 1=aktiv 
  char Zahl_T[1];
  char Taster=0b00000001;
  char z=0;
  char PEAK=180;
  char HOLD=20;
  char OFF=0;
  unsigned int HOLD_TIME=50000;
  unsigned int i=0;

  lcd_init();              // Initialisierung des Displays
  lcd_goto(1,1);            // Positionierung des Cursors
  lcd_text("AD-Wandler 0-255");    // erste Textzeile
  lcd_goto(2,1);            // Positionierung des Cursors
  lcd_text("P1:");          // zweite Textzeile

  while(1)
  {
    switch(z)
    {
    case 0: OCR2 = OFF;
        i=0;
        lcd_zahl(OFF,Zahl_T);
        lcd_goto(2,5);          // Positionierung des Cursors
        lcd_text(Zahl_T);

        if(!(PINB & Taster))
        z=1;
        else
        {
        z=0;
        }
        break;

    case 1:  OCR2 = PEAK;
        i++;
        lcd_zahl(PEAK,Zahl_T);
        lcd_goto(2,5);          // Positionierung des Cursors
        lcd_text(Zahl_T);

        if(PINB&Taster)
        z=0;
        else
        {
          if(!(PINB & Taster)&&(i<HOLD_TIME))
          z=1;
          else
          {
          z=2;
          }
        }
        break;
    
    case 2: OCR2 = HOLD;
        lcd_zahl(HOLD,Zahl_T);
        lcd_goto(2,5);          // Positionierung des Cursors
        lcd_text(Zahl_T);

        if(!(PINB & Taster)&&(i=HOLD_TIME))
        z=2;
        else
        {
        z=0;
        }
        break;
    }
  }
}

[Yalu X. (yalu) (Moderator)]

Bitte längeren Quellcode nicht in den Beitragstext übernehmen, sondern
als Datei anhängen. Kürzeren Quellcode, der im Beitragstext steht,
kannst du mit

[c]
C-Quelltext...
[/c]

farbig darstellen lassen.

Thomas schrieb:
> Will ich nun weitere unabhänige Funktionsstrukturen mit in den C-Code
> einbauen, die ein "delay" verwenden, muss ich den Optimierer ja
> aktivieren. Dann wird das Inkrement aber entfernt.

Wieso sollte der Compiler Inkrement wegoptimieren? Das Ergebnis des
Inkrementierens wird in der Abfrage i<HOLD_TIME genutzt, und diese
Abfrage hat einen Einfluss auf den weiteren Programmablauf, also darf
das Inkrement nicht wegoptimiert werden.

Wenn du allerding zusätzlichen Code in die Schleife mit aufnimmst,
stimmt die Wartezeit nicht mehr und ist evtl. nicht einmal mehr
konstant.

> Hab schon überlegt mit Timer, wusster aber nicht so recht wie und ob
> überhaupt möglich.

Das ist die richtige Überlegung. Hast du das hier schon gelesen?

  AVR-GCC-Tutorial/Die Timer und Zähler des AVR

Im Wesentlichen brauchst du nur zu Beginn einen Timer zu initialiseren,
die Variable i durch das Timer-Register zu ersetzen und HOLD-TIME
entsprechend anzupassen, damit die Wartezeit wieder 500ms sind.
Alternativ kannst du alles, was jetzt in der While-Schleife steht, in
einem vom Timer generierten zyklischen Interrupt ausführen und
nichtzyklisch ausgeführter Code ins Hauptoriogramm schreiben.


Dein jetziger Code hat aber noch Fehler:

Zahl_T ist als Array mit nur 1 Zeichen definiert. In lcd_zahl() werden
aber 3 Zeichen hineingeschrieben. Außerdem fehlt die String-Ende-Null,
die noch ein viertes Element belegen würde.

In

              if(!(PINB & Taster)&&(i=HOLD_TIME))

möchtest du i auf Gleichheit mit HOLD_TIME prüfen. '=' macht aber eine
Zuweisung, der Vergleichsoperator heißt '=='. Der Vergleich ist hier
aber unnötig, da i im Zustand z=2 immer gleich HOLD_TIME ist.