Laminator Regelung AVR fehlfunktion

[Fritz B. (kleinfritzchen)]

Hallo,
bei der Regelung soll die Temperatur auf der einen Seite über ein Poti 
(durch versuch ermittelter Wert) eingestellt werden und auf der anderen 
Seite soll ein Relais die Heizung schalten.
Ich bin noch in der Versuchsphase und habe ein kleines Programm das 
momentan nur eine mit verschiedenen Frequenzen blinkende Diode hat 
geschrieben.
Es hat sich rausgestellt das der Attiny 13 anscheinend bei einem Regeln 
auf +5V sich "aufhängt" und erst nach einem Neustart wieder sauber 
funktoniert.
Meine Frage ist jetzt: Muss ich an der Sftware was ändern (evtl. 
Watchdog) oder liegt es an der Hardweare?
Der schaltplan spiegelt gerade den augenblicklichen Zustand auf dem 
Versuchs-Board wieder! Ist also noch nicht vollständig. Geplant ist als 
Sensor eine Diode zu verwenden deren Spannungsabfall mit dem Poti 
verglichen wird und dementsprechend das Relai geschaltet wird.

#include <avr/io.h>
#include <util/delay.h>
//#define F_CPU = 1200000UL
uint8_t leseKanal(uint8_t mux);
uint8_t verz=0, i;
int main (void){
  DDRB=0x03;
  
  
  while (1){
    PORTB ^= 0x01;
    verz =  leseKanal(0x23);
    for ( i=0;i<=verz;i++){
      _delay_ms(3);
    }
  } return 0;
  
}

//Routine zum einlesen eines Kanales
uint8_t leseKanal(uint8_t mux)
{
  uint8_t i;
  uint8_t ergebniss;
  uint8_t foo;
  ADCSRA |= (1<<ADEN) | (1<<ADPS0) | (1<<ADPS1);
    //ADC einschalten, Teiler auf 8
  ADMUX =mux;
  //lerlauf zum syncronisoeren
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC)){
    ;
  }
  foo = ADCL;
  foo = ADCH;
    
  foo = 0;
  //eigentlicher Abfragezyklus
  for(i=0;i<1;i++){
    
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC)){
      ;
    }
    ergebniss = ADCL;
    ergebniss = ADCH;
  }
  //ergebniss = foo;
  //ergebniss = (ergebniss>>2);
  return ergebniss;
  
}

[Mike (Gast)]

Fritz Bie schrieb:
> Meine Frage ist jetzt: Muss ich an der Sftware was ändern (evtl.
> Watchdog) oder liegt es an der Hardweare?

Der Watchdog hilft nur, wenn das Kind schon in den Brunnen gefallen ist.

Im Schaltplan ist ein grundlegender Fehler: Es fehlt ein 
Abblockkondensator am Prozessor. Und das Poti hat sicher auch einen 
bestimmten Wert?

[visitor (Gast)]

Hängt er sich tatsächlich auf, oder läuft dein Regler in die Sättigung 
und kommt von dort nicht mehr heraus um herunter zu regeln. Dies 
solltest du mal prüfen.

[Hubert G. (hubertg)]

ergebniss = ADCL;
ergebniss = ADCH;

Was wird in ergebniss stehen?
Der Wert von ADCL oder von ADCH ?

[Fritz B. (kleinfritzchen)]

Hallo,
erst mal zum Ergebniss. Das ergebniss ist ADCH weil man beim auslesen 
erst das Low und dann das High Byte. Die Reihenfolge ist laut Datenblatt 
vorgeschrieben. Ich habe  Das Bit 6 im ADMUX Register gesetzt was 
bedeutet das das Ergebniss linksbündig ausgegeben wird. Dies hat zur 
Folge das die unteren beiden Bit abgeschnitten werden wenn ich nur ADCH 
verwende.
Das mache ich aus dem Grund weil ich so die Störfaktoren ein wenig 
eingrenzen kann um ein klares Ergebniss zu haben.
Nun zu den C zwischen Masse und Vcc: hat nichts gebracht.
Das Poti hat 10k als Wert.
Ich bin am Überlegen ob ich den ADC auf 1V Referenz umschalte um eine 
besser ausnutzung des Messbereichs zu  bekommen. Die Diode die ich als 
Sensor  verwende verursacht einen Spannungsabfall von 20 °C = 0,534V zu 
250°C = 0,231V.
Dann könnte ich für das Poti 2k und 8k in reihe verwenden.
Die Diode müsste ich dann auch über einen Spannungsteiler versorgen.

Bezüglich der Sättigung weis ich leider nicht was das bedeutet (noch zu 
wenig Ahnung von der Materie). Der Regler (7805) liefert jedenfalls in 
jedem Fall die erforderliche Spannung.

[spess53 (Gast)]

Hi

>Das ergebniss ist ADCH weil man beim auslesen
>erst das Low und dann das High Byte. Die Reihenfolge ist laut Datenblatt
>vorgeschrieben.

Nicht ganz richtig. Entweder erst Low- dann Highbyte oder nur Highbyte. 
In deinem Fall ist das Lesen des Lowbytes also unnötig.

MfG Spess

[Felix P. (fixxl)]

Wo im Schaltplan ist der Spannungsregler mit seiner Beschaltung zu 
sehen? Grundsätzlich ist ein Abblockkondensator von 100nF an VCC 
jedenfalls nie verkehrt.

In der ADC-Auslese-Funktion würde ich es mir ersparen, immer eine neue 
Initialisierung zu starten. Eine Initialisierung vor der Endlosschleife 
wäre meines Erachtens die bessere Lösung.

[Fritz B. (kleinfritzchen)]

Das mit dem nur auslesen des ADCH hab ich zwar so nicht verstanden aber 
mein Englisch ist ...5  also nicht sonderlich. Ich hab jetzt einen 610 
Ohm Wiederstand in Reihe zum Poti geschaltet so das also die Max. 
Spannung nicht ganz Vcc wird.
Auf dem Bild ist meine Spannungsversorgung, gespeist wird sie von einem 
9V Block.

[Fritz B. (kleinfritzchen)]

Ich wusste gar ncht das eine Initialisierung reicht. Schließlich schalte 
ich den ADC immer wieder aus weil ich ja nur einen Zyklus durchlaufen 
lasse. Außerdem will ich mit der Funktion ja auch die Spannung an der 
Diode auslesen und in der Hauptschleife vergleichen um das Relais ein 
oder aus zu schalten.
Reicht es da aus wenn die Initialisierung nur einmal aufgerufen wird?

Ich hab grad mal im Datenblatt nachgeschaut und dort nichts wegen der 
Auslesereihenfolge gefunden. Im AVR Turorial sthet zwar was anderes aber 
ich probier es mal aus nur ADCH auszulesen.

[Peter D. (peda)]

Fritz Bie schrieb:
> for ( i=0;i<=verz;i++){

Bei verz = 255 -> endlos

[spess53 (Gast)]

Hi

>Ich wusste gar ncht das eine Initialisierung reicht. Schließlich schalte
>ich den ADC immer wieder aus weil ich ja nur einen Zyklus durchlaufen
>lasse.

An welcher Stelle schaltest du ihn aus?

>Ich hab grad mal im Datenblatt nachgeschaut und dort nichts wegen der
Auslesereihenfolge gefunden. Im AVR Turorial sthet zwar was anderes aber
ich probier es mal aus nur ADCH auszulesen.

Was hältst du davon (Datenblatt):

Consequently, if
the result is left adjusted and no more than 8-bit precision is 
required, it is sufficient to read ADCH.

MfG Spess

[qwertzuiopü+ (Gast)]

Auch wenn Peter Dannegger das Problem schon gefunden hat, was soll diese 
Zeile?

Fritz Bie schrieb:
> for(i=0;i<1;i++){

Is doch Schwachsinn eine for-Schleife für einen Durchlauf zu 
programmieren.

[Fritz B. (kleinfritzchen)]

Die Zeile stammt noch aus der ersten Version die mit Word Werten lief.
Ist jetzt so nicht nötig weil ich nicht wie forher den Durchschnitt aus 
4 durchläufen ziehen kann.
Ich versuche grad mir einen Spannungsteiler aus ein paar Wiederständen 
zu basteln. Mit welchem Strom sollte man da arbeiten. Bei dem reinen 10k 
Poti sind es ja 0.0005A. Ich nehme an man sollte nicht wesentlich 
niedriger gehen. Das Problem ist das ich nur 1k,10k,und 25k Potis hab. 
Ich muss erst mal sehen was ich noch so alles an Wiederständen finde.
Ach ja, wenn ich nur einen Abfragezyklus hab bleibt dann die 
Initialisierung erhalten ohne das ich beim neuen abfragen noch mal 
Initialisieren muss?

[Felix P. (fixxl)]

Hier als Beispiel mal ADC-Funktionen, wie sie aussehen könnten.

Diese Funktion initialisiert den ADC vor der Hauptschleife:

void adc_init(void) {
  uint8_t __attribute__ ((unused)) result;

  ACSR |= 1 << ACD;                         // Komparator abschalten
        ADMUX |= 1<<ADLAR;                        // Resultat linksbündig

  ADCSRA |= ((1 << ADPS1) | (1 << ADPS0));  // Frequenzvorteiler 8
  ADCSRA |= (1 << ADEN);                    // ADC aktivieren

  ADCSRA |= (1 << ADSC);                    // eine ADC-Wandlung
  while (ADCSRA & (1 <<ADSC));              // auf Abschluss der Konvertierung warten

  result = ADCH;
}

Und diese Funktion wird dann immer zum Auslesen aufgerufen:

uint8_t adc_read(uint8_t channel) {
  uint8_t adcwert;
  channel &= 0x0F;               // Sicherstellen, dass Kanal im erlaubten Bereich liegt
  ADMUX &= 0xF0;                 // Kanalbits 0 setzen
  ADMUX |= channel;              // Kanal einstellen
  ADCSRA |= (1 << ADSC);         // eine Wandlung "single conversion"
  while (ADCSRA & (1 << ADSC));  // auf Abschluss der Konvertierung warten
  adcwert = ADCH;

  return adcwert;
}

Das gibt keine Probleme, solange du die ADC-Register nicht zwischendurch 
anderweitig überschreibst.

[Fritz B. (kleinfritzchen)]

danke
ich werd das mal nachher umschreiben. Ich bin jetzt auf die Idee 
gekommen nur die Abfrage des Poti's mit Vcc zu machen und die Abfrage 
der Diode mit der internen Referenz von 1V. Auf diese Weise hoffe ich 
das es funktioniert.
Ich wüsste jetzt nicht wie man die ADC Register anderweitig 
überschreiben könnte. Ich war immer der Meinung das diese Register bei 
interner Verwendung vom Controler automatisch auf dem Stack gesichert 
und wiederhergestellt werden.
Als Ziel ist ja nur ein Vergleich der beiden Abfragen von Poti und Diode 
und daraus resultierend ein Schalten eines Relais für die Heizung. Ich 
denke das man da nicht alzuviel verkehrt machen kann.

[spess53 (Gast)]

Hi

>ich werd das mal nachher umschreiben. Ich bin jetzt auf die Idee
>gekommen nur die Abfrage des Poti's mit Vcc zu machen und die Abfrage
>der Diode mit der internen Referenz von 1V. Auf diese Weise hoffe ich
>das es funktioniert.

Warum verstärkst du das Diodensignal nicht einfach auf eine vernünftige 
Größe?

MfG Spess

[Cyblord -. (cyblord)]

Wenn man eben davon absehen würde, heute noch den altbackenen Tiny13 zu 
nehmen, dann könnte man einen Tiny85 nehmen, der bereits eine 
zuschaltbare 20x Verstärkung für die ADCs eingebaut hat.

Und sogar diff. ADCs besitzt. Kann man immer brauchen.

[Fritz B. (kleinfritzchen)]

Hier mal das fertige Programm (erster Versuch)

#include <avr/io.h>
#include <util/delay.h>
//#define F_CPU 1200000UL
#define led  1
#define relais  2

void adc_init(void);
uint8_t leseKanal(uint8_t mux);
uint8_t poti=0, dioden_wert;
int main (void){
  DDRB=0x03;
  adc_init();
  
  while (1){
    
    poti =  leseKanal(0b00100011); //ADLAR Linksbuendig,
                    //ADC3 (Pin 2)
    dioden_wert = leseKanal(0b0110001); //Interne Referenzspannung,
                      //ADLAR Linksbuendig,
                      //ADC1 (Pin 7)
    if (poti>dioden_wert){
      PORTB |= (1<<relais); //Heizung einschalten
      PORTB |= (1<<led);  //Betriebsanzeige einschalten 
    }else{
      PORTB &= ~(1<<relais);  //Heizung ausschalten
      PORTB &= ~(1<<led);    //Betriebsanzeige ausschalten
    }
    _delay_ms(1000);
    
  } return 0;
  
}

//ADC Initialisieren
void adc_init(void) {
  uint8_t __attribute__ ((unused)) result;

  ACSR |= 1 << ACD;                         // Komparator abschalten
        ADMUX |= 1<<ADLAR;                        // Resultat linksbündig

  ADCSRA |= ((1 << ADPS1) | (1 << ADPS0));  // Frequenzvorteiler 8
  ADCSRA |= (1 << ADEN);                    // ADC aktivieren

  ADCSRA |= (1 << ADSC);                    // eine ADC-Wandlung
  while (ADCSRA & (1 <<ADSC));              // auf Abschluss der Konvertierung warten

  result = ADCH;
}

//Routine zum einlesen eines Kanales
uint8_t leseKanal(uint8_t mux)
{
  
  uint8_t ergebniss;
  
  
  //eigentlicher Abfragezyklus
  
    
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC)){
      ;
    }
    //ergebniss = ADCL;
    ergebniss = ADCH;
  
  //ergebniss = foo;
  //ergebniss = (ergebniss>>2);
  return ergebniss;
  
}