Zeitabhängige Spannungssteuerung

[AtroCty (Gast)]

Guten Morgen,

ich habe ein kleines Problem mit einer Schaltung:

Ich habe eine Solar-Steuerung über einen Mikrokontroller realisiert. 
Dazu wird die Ausgangsspannung nach einem DC-DC-Wandler zu einer 
bestimmten Zeit über ein Relais an den Endverbraucher zugeschaltet. 
Dabei ruft der µC über einen TWI (DS1307) die aktuelle Zeit ab, und soll 
je nachdem das Relais schalten.

Sobald ich die Zeit neu einstelle läuft das Programm eine Zeit lang so, 
wie es soll. (Das Relais wird pünktlich geschaltet, und schaltet auch 
pünktlich zum gewünschten Zeitpunkt wieder ab)

Jedoch bleibt der µC nach einer Zeit verweilen am aktuellen Zustand, bis 
er neu eingestellt wird. Ich vermute, dass der µC sich aufhängt. Ich 
schätze, dass es am Code liegt, ich habe bereits 3 µC getestet, alle mit 
dem gleichem Ergebnis.

Mein Code:

#define   F_CPU   3686400
#include <avr\io.h>
//---------------------------------------------------------------------------------
// TWI-Funktionssammlung
#ifndef TWI_CLOCK
#define TWI_CLOCK 100000 // Geschwindigkeit des TWI-Busses
#endif
// TWCR - Control-Register-Bits
#define _TWINT 0b10000000
#define _TWEA 0b01000000
#define _TWSTA 0b00100000
#define _TWSTO 0b00010000
#define _TWWC 0b00001000
#define _TWEN 0b00000100
#define _TWIE 0b00000001
uint8_t   twiAdr = 0xD0;
void twiInitMaster(uint8_t twiAdr);
#include <util\delay.h>
#include <util\delay.h>

//------------------------------------------------------------------------
// twiInitMaster
//------------------------------------------------------------------------
void twiInitMaster(uint8_t twiAdr)
{
  // Clock
  TWBR=((F_CPU/TWI_CLOCK)-16)*2;
  // TWI-Status-Register (Vorteiler)
  TWSR=0;
  // Bus-Addr
  TWAR=twiAdr;
  // Enable
  TWCR=_TWINT|_TWEN;
}
//------------------------------------------------------------------------
// Start TWI (ohne Interrupt)
//------------------------------------------------------------------------
void twiStart()
{
  uint8_t x=TWCR;
  x&=_TWEN|_TWIE;    // nur Beibehalten von Enable und InterruptJ/N 
  TWCR=x|_TWINT|_TWSTA;
  // warten bis fertig
  while( !(TWCR & _TWINT))
  {}
}
//------------------------------------------------------------------------
// Stopp TWI (ohne Interrupt)
//------------------------------------------------------------------------
void twiStop()
{
  uint8_t x=TWCR;
  x&=_TWEN|_TWIE;    // nur Beibehalten von Enable und InterruptJ/N 
  TWCR=x|_TWINT|_TWSTO;
}
//------------------------------------------------------------------------
// Write Byte per TWI (ohne Interrupt)
// PE: data = zu sendende Daten
//     ackn = wenn !=0 wird Acknowledge (=TWEA) gesetzt
//------------------------------------------------------------------------
void twiWriteByte(uint8_t data, uint8_t ackn)
{
  TWDR=data;      // Daten bereitlegen
  // Befehl zusammenstellen
  uint8_t x=TWCR;
  x&=_TWEN|_TWIE;      //nur Beibehalten von Enable und InterruptJ/N 
  x|=_TWINT;
  if(ackn)   
    x|=_TWEA;   // evt. TWEA setzen, für Datenanforderung
  TWCR=x;         // senden
  // warten bis fertig
  while( !(TWCR & _TWINT))
  {}
}
//------------------------------------------------------------------------
// Read Byte per TWI (ohne Interrupt)
// PE: ackn = wenn !=0 wird Acknowledge (=TWEA) gesetzt
// PA: Data
//------------------------------------------------------------------------
int twiReadByte(uint8_t ackn)
{
  // Befehl zusammenstellen
  uint8_t x=TWCR;
  x&=_TWEN|_TWIE;      //nur Beibehalten von Enable und InterruptJ/N 
  x|=_TWINT;
  if(ackn)   
    x|=_TWEA;   // evt. TWEA setzen, für Datenanforderung
  TWCR=x;         // senden
  // warten bis fertig
  while( !(TWCR & _TWINT))
  {}
  return TWDR;
}

//-------------------------------------------------------------------------
// rtcGetRtcData
//-------------------------------------------------------------------------
uint8_t rtcGetRtcData(uint8_t Register)
{
  // Adresse senden   
  twiStart();
  twiWriteByte(twiAdr,0);
  twiWriteByte(Register,1);
  // Daten lesen
  twiStart();
  twiWriteByte(twiAdr+1,1);
  uint8_t b = (uint8_t)twiReadByte(0);
  twiStop();
  return b;
}
//-------------------------------------------------------------------------
// rtcGetSeconds
//-------------------------------------------------------------------------
uint8_t rtcGetSeconds()
{
  return rtcGetRtcData(0) & 0x7F;
}
//-------------------------------------------------------------------------
// rtcGetMinute
//-------------------------------------------------------------------------
uint8_t rtcGetMinute()
{
  return rtcGetRtcData(1);
}
//-------------------------------------------------------------------------
// rtcGetHour
//-------------------------------------------------------------------------
uint8_t rtcGetHour()
{
  return rtcGetRtcData(2) & 0x3F;
}
//-------------------------------------------------------------------------
// rtcWaitMs
//-------------------------------------------------------------------------
void rtcWaitMs(int miliSec)
{
  _delay_loop_2( 1*(F_CPU/(1000/4)) * miliSec);   // 4 Zyklen warteschleife
}

//--------------------------------------------------------------------
// myWait_ms - Warte-Routine für x-Millisekunden (0-255)
// ein Millisekundenzyklus dauert 1,052 ms
// PE: Anzahl der zu wartenden Milisekunden
//--------------------------------------------------------------------
void myWait_ms(uint8_t dauer_ms)
{
  __asm__ volatile (
    "myWait_ms_0%=:\n"
    "push   %0\n"
    "ldi   %0,1\n"
    "myWait_ms_3%=:\n"
    "push   %0\n"
    "ldi   %0,5\n"
    "myWait_ms_2%=:\n"
    "push   %0\n"
    "ldi   %0,255\n"
    "myWait_ms_1%=:\n"
    "dec   %0   \n"
    "brne   myWait_ms_1%=\n"
    "pop   %0   ; Register wiederherstellen\n"
    "dec   %0   \n"
    "brne   myWait_ms_2%=\n"
    "pop   %0   ; Register wiederherstellen\n"
    "dec   %0   \n"
    "brne   myWait_ms_3%=\n"
    "pop   %0   ; Register wiederherstellen\n"
    "dec   %0   \n"
    "brne   myWait_ms_0%=\n"
    :
    :"d" (dauer_ms)
    );
}

//---------------------------------------------------------------------------
void waitMs(int miliSec)
{
  _delay_loop_2( 1*(F_CPU/(1000/4)) * miliSec);   // 4 Zyklen warteschleife
}

//------------------------------------------------------------------------
// Initialisierungen
//------------------------------------------------------------------------
void init()
{
  twiInitMaster(twiAdr);
}

//------------------------------------------------------------------------
// Zahlensystem-Wandler
//------------------------------------------------------------------------

int dectobcd(int dec)
{
  int BCD;
  BCD = (((dec / 10) * 16) + (dec % 10));
  return BCD;
}

int bcdtodec(int BCD)
{
  int dec;
  dec = ((((BCD >> 4)&0b111)*10)+(BCD&0b1111));
  return dec;
}

//------------------------------------------------------------------------
// Einstellung der Zeit
//------------------------------------------------------------------------

void define_time(int stunde, int minute, int sekunde)
{
  twiStart();
  twiWriteByte(twiAdr,0);
  twiWriteByte(0,1);
  sekunde = dectobcd(sekunde);
  twiWriteByte(sekunde,1);
  minute = dectobcd(minute);
  twiWriteByte(minute,1);
  stunde = dectobcd(stunde);
  twiWriteByte(stunde,1);
  twiStop();
}

//------------------------------------------------------------------------
// Ein/Ausschalten des Relais
//------------------------------------------------------------------------

int switcher(int stunde_on, int stunde_off)
{
  int stunde = 0;
  stunde = rtcGetHour();
  stunde = bcdtodec(stunde);
  if ((stunde>=stunde_on) && (stunde<stunde_off))
  {
    PORTC = 0x08;
  }
  else
  {
    PORTC = 0x00;
  }
}

/////////////////////////////////////////////////////////////////////////////
// Main-Funktion
/////////////////////////////////////////////////////////////////////////////
main()
{
  //Variablen-Initialisierung
  int zeit1,zeit2;

  init();               // Initialisierungen

  //Zur Zeiteinstellung Kommentare entfernen!
  /*zeit1 = rtcGetHour();
  zeit2 = rtcGetMinute();

  
  if ((zeit1==0)&&(zeit2==0))
  {
    define_time(8,19,31);          
  }*/
  
  // Alternativ: direkte Überschreibung
  // define_time(10,10,15);
  
  DDRC = 0x08;

  while (true)              // Mainloop-Begin
  {
    switcher(11,13);
    _delay_ms(1000);
  }

Das ganze wurde zunächst mit dem Code-Wizard von myAVR erstellt, da ich 
die gleichen Bauteile der AVR-Boards verwendet habe.

Weiß jemand Rat?

Grüße

[Karl H. (kbuchegg)]

> Ich vermute, dass der µC sich aufhängt.

Wär möglich.
Relais-Spulen können schon ordentlich Schmutz auf den 
Versorgungsspannungen erzeugen, wenn sie schalten.



Hast du ein Anzeigeelement, wie zb in LCD im System?
Dann könntest du dir dort laufend Ausgaben machen und zb auch die 
Uhrzeit von der RTC ausgeben lassen, dann würde man schon mehr sehen.

Wenn nicht, dann hilft es auch, sich eine LED an einen Port zu verkabeln 
und die in der Hauptschleife blinken zu lassen. Wenn das Blinken 
aufhört, dann ist der µC höchst wahrscheinlich abgeschmiert.
Aber um ehrlich zu sein würde ich mir als allererstes in ein neues 
Projekt eine Möglichkeit für Ausgaben einbauen. UART ist gut, LCD ist 
meistens besser. Ohne eine Chance sich auch mal Variablenwerte life und 
in Farbe direkt am Objekt ansehen zu können, ist alles andere immer ein 
Stochern im Nebel.

[Anon Y. (anonymous)]

Hallo  AtroCty,

mir gefallen deine delays nicht. Verwende doch die eingebauten 
Funktionien.

Ich habe in meinem Code in grauer Vorzeit die i2c Funktionien 
umgeschrieben. Der Code blockt nämlich für immer, wenn etwas bei der i2c 
Kommunikation nicht stimmt. D.h. alle while(!blahh); habe ich ersetzt 
durch
while{!blahhh){
if(!timeout--) break;
}

Der Sinn ist ein ungenaues timeout (weil abhängig von der 
Ausführungszeit der Schleife). Wenn die entsprechend vorinitialisierte 
Variable abgelaufen ist wird im Code weiter gemacht. Das hat sich als 
sehr sinnvoll erwiesen, weil manchmal einfach i2c Nachrichten verloren 
gehen / sinnlose states angenommen werden.

[AtroCty (Gast)]

@Buchegger:

Beim Relais habe ich eine Freilaufdiode verbaut, der sollte diese 
Schmutzspannungen eigentlich abfangen...

Nein, ich habe kein LCD verbaut, und ja, es ist leider ein "stochern", 
weil dies eigentlich nur eine simple Funktion bieten sollte ohne weitere 
Modifikationen.

@Anon Ymous:

Wie genau würde der Code dann oben aussehen?
Ich weiß leider nicht genau wie du das meinst...

[Karl H. (kbuchegg)]

Du hast zb hier

int twiReadByte(uint8_t ackn)
{
  // Befehl zusammenstellen
  uint8_t x=TWCR;
  x&=_TWEN|_TWIE;      //nur Beibehalten von Enable und InterruptJ/N 
  x|=_TWINT;
  if(ackn)   
    x|=_TWEA;   // evt. TWEA setzen, für Datenanforderung
  TWCR=x;         // senden
  // warten bis fertig
  while( !(TWCR & _TWINT))
  {}
  return TWDR;
}

mit dem while eine potentielle Endlosschleife, wenn aus irgendeinem 
Grund _TWINT nicht so tut, wie es soll.

Ich kenn jetzt das Timing nicht, aber man kann mit Sicherheit ein 
zeitliche Obergrende festlegen, nach der diese Schleife und damir der 
Read als gescheitert zu betrachten ist (jetzt mal unabhängig von der 
Ursache warum das so ist). Ich sach jetzt einfach mal als Hausnummer: 
wenn sich nach 100 Millisekunden da noch nichts getan hat, dann ist da 
was schief gelaufen.
Also macht man sich eine Beschränkung rein, die diese Schleife auf jeden 
Fall nach 100ms abwürgt.

int twiReadByte(uint8_t ackn)
{
  // Befehl zusammenstellen
  uint8_t x=TWCR;
  x&=_TWEN|_TWIE;      //nur Beibehalten von Enable und InterruptJ/N 
  x|=_TWINT;
  if(ackn)   
    x|=_TWEA;   // evt. TWEA setzen, für Datenanforderung
  TWCR=x;         // senden
 
 // warten bis fertig
  uint8_t timeout = 100;
  while( !(TWCR & _TWINT) && timeout > 0)
  {
    _delay_ms( 1 );
  }

  // warum gings aus der Schleife raus. Hat es etwa zu lange
  // gedauert?
  if( timeout == 0 )
    return 0;

  // Nö. Alles ok. TWDR enthält das Ergebnis
  return TWDR;
}

wie du dann weiter mit dem Fehlerfall umgehst, das musst du selbst 
entscheiden. Sicherheitshalber solltest du ihn aber auf jeden Fall 
melden! Zb. in dem eine LED an geht!

> weil dies eigentlich nur eine simple Funktion bieten sollte ohne weitere

Es ist NIE einfach nur 'simpel'. Sobald man reale Projekte machen will, 
abseits vom Übungstisch, kommt man um eine Ausgabemöglichkeit nicht rum. 
In einfachsten Fall sind das ein paar LED, dann braucht man aber immer 
noch Phantasie um sich zu überlegen, wie man die jetzt sinnvoll 
einsetzen kann um sich besondere Zustände anzeigen zu lassen. Oder aber 
im einfachsten Fall eine UART oder ein LCD. Eine UART kann man fast 
immer nachrüsten, sofern die Pins frei sind. Das muss ja nicht schön 
sein - es muss zweckmässig sein. 2 fliegend verlötete Drähte auf eine 
kleine Hilfsplatine mit einem MAX232 (oder einem FT232) und von dort 
weiter zum PC und schon ist man im Geschäft.

Und im übrigen:
Wie stellst du eigentlich die Schaltzeiten ein? Wie handhabst du die 
Sommer/Winterzeit Umstellung. Was machst du, wenn bei der RTC mal die 
Batterie leer ist?

[AtroCty (Gast)]

Sollte ich den timeout nicht dekrementieren, wie Ano Nymus gesagt hatte?

Schaltzeiten etc. sind egal, ebenso wenn Batterie leer ist.

[Karl H. (kbuchegg)]

AtroCty schrieb:
> Sollte ich den timeout nicht dekrementieren, wie Ano Nymus gesagt hatte?

Ja, natürlich.
Bitte schreib das dem Umstand zu, dass ich den Code hier direkt 
eintippe.

[AtroCty (Gast)]

An welcher Stelle sollte ich dies denn am besten tun?
 Sollte ich den timeout nicht auch zurücksetzen?

[Karl H. (kbuchegg)]

 // warten bis fertig
  uint8_t timeout = 100;
  while( !(TWCR & _TWINT) && timeout-- > 0)
  {
    _delay_ms( 1 );
  }

und kauf dir ein C-Buch.
Das ist ja furchtbar. Mit Code zusammenkopieren wirst du nicht weit 
kommen.

[AtroCty (Gast)]

Ich besitze eins, bin mir nur im unklaren im Zusammenhang mit 
Mikrokontrollern, da ich bisher nur reine Anwendungsentwicklung gemacht 
habe.

[MaWin (Gast)]

> und kauf dir ein C-Buch.
> Das ist ja furchtbar. Mit Code zusammenkopieren wirst du nicht weit
> kommen.

Was bitte gefällt dir an dem Code nicht ?
Daß er nicht wie dein BASCOM aussieht ?

[AtroCty (Gast)]

Ich kann so den Zusammenhang dieser Schleife mit der Arbeitsprozedur des 
µC nicht wirklich erkennen. Ich weiß gerade nicht wirklich, was diese 
Schleifenabhängigkeit des timeouts bewirkt.

[AtroCty (Gast)]

Und zusammenkopiert ist es nicht wirklich, das meiste des Codes kommt 
aus eigener Hand bis auf die Teile des twi's, die sind vom CodeWizard 
vorgegeben. Und da es genau an dem Teil anscheinend hapert würde ich 
schon eine Erklärung bevorzugen, da ich schon gerne die Funktionsweise 
erkennen können würde, jedoch ist mir die Arbeitsweise des µC noch ein 
wenig schleierhaft...

[Karl H. (kbuchegg)]

MaWin schrieb:
>> und kauf dir ein C-Buch.
>> Das ist ja furchtbar. Mit Code zusammenkopieren wirst du nicht weit
>> kommen.
>
> Was bitte gefällt dir an dem Code nicht ?
> Daß er nicht wie dein BASCOM aussieht ?

Ich verwende kein BASCOM.
UNd mit 'furchtbar' war eigentlich gemeint, dass man in einem Vorschlag, 
der sich über 3 Zeilen Code hinzieht nicht selbst die Stelle findet, an 
der man ein -- einfügen kann bzw. muss, um eine bereits vorgegebene 
Funktionalität (Timeout einer potentiellen Endlosschleife) zu 
realisieren.

[AtroCty (Gast)]

Ich verstehe die Wirkungsweise dieses timeouts einfach nicht. Wenn ich 
an einer Stelle den Timer wieder resete würde mir das einleuchten, denn 
da ist die Position der Dekrementierung klar.

€DIT: Ich könnt mich selber für meine Blödheit schlagen g
Hatte das einfach nicht gerallt, dass das damit einfahc verhindert wird, 
dass die Schleife aufhören soll zu wirken sobald er keine Daten 
empfängt.

So ergibt das natürlich wieder Sinn. Ist einfach zu heiß hier in der 
Werkstatt ;)

[AtroCty (Gast)]

kleines Update: Ich habe jetzt eine LED's an einem Ausgang verbaut, 
diese soll bei einem Fehler an dieser Stelle aufleuchten. Jedoch 
leuchtet die LED nicht, noch hat der µC seine gewünschte Funktionsweise 
konstant. (nach 30 Minuten hing er sich auf, die Zeit blieb auf dem 
Display stehen, das Relais blieb geschaltet.)

[Karl H. (kbuchegg)]

Dann würde ich an deiner Stelle zum Testen jetzt erst mal das Relais 
weglassen :-)

[AtroCty (Gast)]

Schon getan, liegt am µC.

[AtroCty (Gast)]

Der µC schaltet ja nur einen Transistor, nicht das Relais direkt, weil 
das der µC nicht aushalten würde.

[Michael A. (Gast)]

AtroCty schrieb:
> Der µC schaltet ja nur einen Transistor, nicht das Relais direkt, weil
> das der µC nicht aushalten würde.

Und was ändert das? Wenn das Relais auf der Versorgungsspannung rumsaut, 
ist das ganz egal, ob in der Ansteuerung noch ein Transistor sitzt.

Wie sieht es denn mit Abblockkondensatoren auf VCC bei µC und 
Relais/Diode aus?

[AtroCty (Gast)]

Sind vorhanden, aber wie gesagt, ich habe es bereits auch mit einer 
externen Platine ohne Relais getestet mit gleichem Ergebnis.

Kann vom aktuellem Netz keine Bilder hochladen, aber ja, 
Stützkondensatoren sind vorhanden für die IC's (µC & TWI), sowie 
Freilaufdiode für das Relais. Spannung wird aus einem DC-DC-Wandler 
bezogen.

[AtroCty (Gast)]

!Bump!

Bin mittlerweile echt ratlos, da der Fehler wohl definitiv am Code/µC 
aufzufinden ist...

Was ist denn an den delay-Funktionen auszusetzen?

Ebenfalls kann ich am Code keine Stelle feststellen, die den Speicher 
overflown... Würde es an den Spannungen liegen würde der µC abstürzen 
und nicht stehen bleiben.

[AtroCty (Gast)]

Nochmal !BUMP!

bin gerade wieder dabei mich daran zu setzen, doch mir gehen die Ideen 
aus...

[AtroCty (Gast)]

Haben das Problem endlich gelöst: Die Fuse-Bits waren nicht richtig 
eingestellt.