PIC 16F688 Timereinstellung / Timerstart

[Stefan F. (stefan84)]

Hallo zusammen,

ich möchte gerne die Häuser meiner Modelleisenbahn in mehrere Zimmer
unterteilen und dann z.B. wie im beigefügten Code 4 Zimmer in
unterschiedlichen Abständen beleuchten.

Leider bin ich in der Programmierung des PIC 16F688 noch nicht so tief
eingedrungen, dass ich die Einstellungen für den Timer0 vernünftig
hinbekomme. Ich habe mir das Datenblatt schon mehrfach angesehen, aber
ich verstehe den Teil nicht richtig und habe auch schon nach anderen
Erläuterungen im Internet gesucht, aber leider gefunden, die ich
entsprechend in meinem Programm umsetzen kann.

Das Ziel ist, dass immer nach einer bestimmten Anzahl von Sekunden (die
ich in den Code entsprechend eingepflegt habe) ein neuer Status erreicht
werden soll, d.h. das weitere LEDs leuchten bzw. bisherige LEDs nicht
mehr leuchten.

Den Teil bzgl. des Timers habe ich aus einem Programm eines anderen PICs
übernommen und probiert auf meinen PIC 16F688 umzuschreiben, leider aber
anscheinend ohen Erfolg. Das Probelm ist, dass mir keine Fehlermeldungen
beim Simulieren/Brennen angezeigt werden, aber der Aufbau auf dem
Steckboard nicht funktioniert.


Könnt ihr mir bei den Einstellungen für den Timer bitte helfen:


Ich habe euch meinen kompletten Code als Anlage beigefügt.


Probleme habe ich in diesem nachfolgenden Bereich:

//Initialisiert den Timer 0 für einen Sekundentakt
void initTimer0( void ) {
      //Timer 0 ist ein 16-bit-Timer
            //Prescaler = 1:256
OPTION_REG = 0b00000111;
TMR1H = 0x00;
TMR1L = 0x00;
INTCONbits.GIE = 0;  //Interruptflag zurücksetzen
return;  
}


//Startet den Timer neu
void restartTimer0( void ) {
  int timerValue=0;
      //mit einem Prescaler von 1:256 ensteht nach einer Sekunde
           //ein Überlauf (4 MHz / 256 = 15625 Hz)
INTCONbits.GIE = 0;    //Interruptflag zurücksetzen
           //Timer Wert für 1s = 65535 - 15625 = 49910 = 0xC2F6
TMR1H = 0xC2;          //Das Highbyte muss zuerst
           //geschrieben werden.
TMR1L = 0xF6;         //Wenn das Lowbyte geschrieben wird,
      //wird das Highbyte aktuallisiert.
      //Dadurch wird es ermöglicht alle
      //16 bit auf einmal zu beschreiben
      //TMR0 = 0xC2F6; funktioniert an
      //Stelle nicht, da zuerst das
      //Lowbyte und dann das Highbyte
      //geschrieben wird.
INTCONbits.GIE = 1;  //Timer starten
return;
}

//wartet für die angegebene Anzahl von Sekunden
void wait( int seconds ) {
  int i=0;
  
        //prüft, ob der Timer übergelaufen ist
  for( i=0; i<seconds; i++ ) {
    restartTimer0();
        //warten, bis der Timer übergelaufen ist
    while( INTCONbits.GIE == 0 );      
  }
  return;
}

Vielen Dank und viele Grüße
Stefan

[fop (Gast)]

Du wirfst hier glaube ich 2 Dinge in einen Topf. Genauer gesagt 2 Bits 
bzw. Flags.
Eines sagt aus, ob das Ereignis für einen Interrupt aufgetreten ist und 
das andere legt fest, ob dieses Ereignis auch zu einem Interrupt führen 
soll.
Der große Unterschied für Dein Programm ist also : ersteres wird 
ungefragt gesetzt. Das zweite bleibt so, wie Dein Programm es setzt.
Einen echten Interrupt willst Du ja nicht, denn dann müsstest Du eine 
Routine dafür bereit stellen. Er bringt Dich auch nicht weiter, da Du 
die Zeit bis dahin eh vertrödelst. Also wird das Interrupt Freigabe 
Flag auf 0 gesetzt.
Meist hat es ein E wie enable im Namen.
Das worauf Du warten willst ist das Andere. Meist hat es ein F wie Flag 
im Namen.
Kommen wir zur letzten Hürde : ohne Interrupt wird dieses Flag nur beim 
Überlauf gesetzt. Und dann sitzt es....
Doof, wenn nach einmal einer Sekunde warten alles in einem Rutsch 
abläuft.
Also muss Dein Programm, dieses Flag löschen. Entweder gleich nachdem es 
gesehen hat, dass das Flag gesetzt ist oder bei Deiner Software böte 
sich die Funktion restartTimer0() dafür an.
Damit das nicht so einfach wird, löscht man so Flags oft nicht intuitiv, 
in dem man eine 0 auf sie schreibt. Es soll verhindert werden, dass man 
andere Flags im selben Register mitlöscht. Also gibt es so lustige 
Mechanismen, die Flags löschen, auf die man eine 1 schreibt und dafür 
die, auf die man eine 0 schreibt unangetastet lassen.
Merke Dein PIC kann immer nur 8 Bit auf einmal schreiben. Befehle, die 
Dir vorgaukeln ein Bit zu ändern, ziehen sich 8 Bit rein, beackern eines 
davon und schreiben alle 8 zurück.

[McMix (Gast)]

Du vermischt Timer0 und Timer1.
Timer 0 ist ein 8 Bit-Timer für den der Prescaler eingestellt werden 
kann.
Dieser Timer wird über Register TMR0 geladen.
Du schreibst aber immer nach TMR1L und TMR1H. Das sind jedoch die 
Register für Timer1. Der kann aber nicht über den Prescaler angesteuert 
werden.
Ausserdem fehlt die Initialiserung für die Timer.
Und wie oben schon beschrieben, mit dem GIE Flag gibst du den Interrupt 
global frei - du kannst dort aber nicht den Überlauf eines Timers 
abfragen.
Das ginge über T0IF bzw. TMR1IF in den entsprechenden Registern.
Ich glaube nicht, dass du das ans fliegen kriegst, ohne dir das 
Datenblatt mal genauer anzuschauen :-)

[Stefan F. (stefan84)]

Hallo ihr beiden,

vielen Dank für eure beiden Antworten.

Wenn ich euch richtig verstanden habe, dann muss ich mich auf jeden Fall 
mit dem Timer 0 auseinandersetzen, da ich mit Hilfe des Prescaler die 
Sekunden bis zum nächsten Wechsel des Status festlegen möchte. Das ist 
doch so korrekt oder?

Im Datenblatt des PIC 16F688 muss ich mich dann mit den Seiten 45 - 47 
auseinandesetzen oder? Dort ist der Timer 0 beschrieben.

@McMix: Wie genau initialisiere ich den Timer?

Sorry, dass es sich noch um so absolute Anfänger fragen handelt, aber in 
dem PIC-Mikrocontroller Buch, welches ich mir besorgt habe, ist dieses 
leider alles mit einem anderen PIC beschrieben und ich bin in der 
Materie wirklich ein absoluter Neuling.

[Stefan (Gast)]

Für 10ms sieht es so aus:

void InitTimer0(){
  OPTION_REG   = 0x86;
  TMR0     = 100;
  INTCON   = 0xA0;
}

void Interrupt(){
  if (TMR0IF_bit){
    TMR0IF_bit   = 0;
    TMR0     = 100;
    //Enter your code here
  }
}

[Stefan (Gast)]

Bei 8MHz sind es ca. 10ms

[Apollo M. (Firma: @home) (majortom)]

Stefan F. schrieb:
> Leider bin ich in der Programmierung des PIC 16F688 noch nicht so tief
> eingedrungen,

... ich würde mal den simulator im mplab benutzen!
dann kannst du alles im trail and error ausprobieren, da du ja die recht 
einfache beschreibung im data sheet nicht verstehst und auch alles 
andere durcheinander bringst.

von deinem code und der hilflosen beschreibeung ist erkennbar, dass du 
beim programmieren eher auch bei ground zero startest.
daher solltest du mal mehr zeit investieren um dir grundsätzliches 
klarzumachen bevor du den nächsten hilfeschrei hier abgibst.


mt

[Apollo M. (Firma: @home) (majortom)]

Stefan schrieb:
> Bei 8MHz sind es ca. 10ms

höre auf mit dem klippschule frage-antwort-spiel und erarbeite dir das 
selber!
im simulator kannst du dir auch das timing anschauen und musst hier dann 
nicht jeden mist posten.

das wird so nichts, was du in kurzer zeit zusammen basteln kannst. weil 
du erstmal grundsätzliche funktionen des pic's dir erarbeiten musst.


mt

[Stefan F. (stefan84)]

Apollo M. schrieb:
> Stefan schrieb:
>> Bei 8MHz sind es ca. 10ms
>
> höre auf mit dem klippschule frage-antwort-spiel und erarbeite dir das
> selber!

Die Frage habe ich gar nicht gestellt, sondern der vorherige Autor hat 
dieses ergänzt. Aber vielen Dank für die Belehrung.

Wie gesagt, fange ich mit der ganzen Thematik gerade erst an.

Leider hat der Simulator von MPLAB keinerlei Fehler ausgewiesen, anhand 
derer ich dann auch meine Einstellungen testen und verbessern könnte.

[fop (Gast)]

Prinzipiell kann ein 8-bit Timer maximal 256 Mal zählen bevor er 
überläuft, ein 16-bit Timer maximal 65536 Mal.
Wie oft er zählen muss, bis eine Sekunde um ist, hängt von seinem Takt 
ab. Und damit bist Du bei dem IMHO am verwirrendsten in Datenblättern 
beschriebenen Teil : oft über mehrere Kapitel und mit inkonsistenten 
Bezeichnungen.
Wenn der Vorteiler des 8-bit Timers nicht höher als :256 einstellbar 
ist, kommst Du nicht auf längere Zeiten als mit dem 16-bit Timer ohne 
Vorteiler.
Der 8-bit Timer ist dann einfacher bedienbar, die Zeit bis zum Überlauf 
aber nicht so fein abstufbar.
Wenn der Timer alleine nicht auf eine Sekunde kommt, musst Du halt in 
Software mehrere Überläufe abwarten. Nach dem Motto 16 * 61,5 ms + 16 ms 
sind auch eine Sekunde. Die Software hat ja sonst nix zu tun.

[fop (Gast)]

So, habe mir mal das Datenblatt zu Deinem PIC reingezogen. Würde Dir 
jetzt doch den 16-bit Timer empfehlen. Der 8-bit Timer ist mit dem 
Watchdog verkäkelt.
Die gute Nachricht : Das Flag, ob ein Überlauf des Timers stattgefunden 
hat lässt sich doch ganz intuitiv durch Schreiben einer 0 löschen. Es 
heißt TMR1IF und ist Bit 0 von PIR1.
Das Initialisieren des Timers beschränkt sich fast auf das Setzen des 
T1CON Registers.
Bis ca. 2 MHz Systemtakt sollte der Timer eine Dauer von einer Sekunde 
auf einmal schaffen.
Und da wäre das Problem : welchen Takt nutzt Du ? Hast Du einen Quarz 
angeschlossen ? Wie hast Du die Configuration Bits gesetzt ?

[... (Gast)]

> in
> dem PIC-Mikrocontroller Buch, welches ich mir besorgt habe, ist dieses
> leider alles mit einem anderen PIC beschrieben

Die Timer 0, 1 und 2, sind bei den 14 bit PICs nahezu identisch.
Mitunter ist fuer Extrafunktionen noch etwas dazugehaekelt.

Du solltest also das Buch wohl noch mal lesen.

Ob ein Timer zaehlt, sieht man im Simulator, am Stand
des entsprechenden Registerinhalts im Einzelschrittbetrieb.

[fop (Gast)]

Na, noch am Lesen ? Hier ein ungetesteter Vorschlag von mir :

#include "config.h"
#include <xc.h>
#include <pic16f688.h>
/* Zimmerbeleuchtung fuer das Haus */
#define RAUM_1a  PORTAbits.RA0
/* 1. LED fuer Raum 1 liegt an Port A RA0 */
#define RAUM_1b  PORTAbits.RA1
/* 2. LED fuer Raum 1 liegt an Port A RA1 */
#define RAUM_2a  PORTCbits.RC1
/* 1. LED fuer Raum 2 liegt an Port C RC1 */
#define RAUM_2b  PORTCbits.RC2
/* 2. LED fuer Raum 2 liegt an Port C RC2 */
#define RAUM_3a  PORTCbits.RC3
/* 1. LED fuer Raum 3 liegt an Port C RC3 */
#define RAUM_3b  PORTCbits.RC4
/* 2. LED fuer Raum 3 liegt an Port C RC4 */
#define DGa      PORTAbits.RA3
/* 1. LED fuer DG liegt an Port A RA3 */
#define DGb      PORTCbits.RC5
/* 2. LED fuer DG liegt an Port C RC5 */
/* Status der Beleuchtung der Zimmer */
#define EINGANG  0
#define EINGANG_KUECHE 1
#define EINGANG_KUECHE_AUSGANG 2
#define KUECHE_AUSGANG 3
#define KUECHE 4
#define KUECHE_DG 5
#define DG_ABEND 6
#define NACHT 7
#define DG_MORGEN 8
#define KUECHE_DG_MORGEN 9
#define KUECHE_MORGEN 10
#define KUECHE_EINGANG_MORGEN 11
#define KUECHE_EINGANG_AUSGANG_MORGEN 12
#define KUECHE_EINGANG_ZWEI 13
#define EINGANG_MORGEN 14
#define ARBEIT 15
/* PROTOTYPES */
void allLEDoff(void);
void initTimer0(void);
void restartTimer0(void);
void wait(int seconds);
/* HAUPTPROGRAMM */
void main(void)     /* hier faengt das Programm an */
{
    char state = EINGANG;
    allLEDoff(); /* alle LED's ausschalten */
    TRISA = 0x00;
    TRISC = 0x00;
    initTimer0(); /* initialisiert den Timer */
    while (1)
    {
        /* Hauptschleife */
        switch (state)
        {
            case EINGANG:
                RAUM_1a = 1;
                RAUM_1b = 1;
                RAUM_2a = 0;
                RAUM_2b = 0;
                RAUM_3a = 0;
                RAUM_3b = 0;
                DGa = 0;
                DGb = 0;
                wait(5);
                state = EINGANG_KUECHE;        /* naechster Zustand ist Eingangszimmer und Kueche */
                break;
            case EINGANG_KUECHE:
                RAUM_1a = 1;
                RAUM_1b = 1;
                RAUM_2a = 1;
                RAUM_2b = 1;
                RAUM_3a = 0;
                RAUM_3b = 0;
                DGa = 0;
                DGb = 0;
                wait(5);
                state = EINGANG_KUECHE_AUSGANG;        /* naechster Zustand ist ALLE Zimmer im EG */
                break;
            case EINGANG_KUECHE_AUSGANG:
                RAUM_1a = 1;
                RAUM_1b = 1;
                RAUM_2a = 1;
                RAUM_2b = 1;
                RAUM_3a = 1;
                RAUM_3b = 1;
                DGa = 0;
                DGb = 0;
                wait(5);
                state = KUECHE_AUSGANG;        /* naechster Zustand ist Kueche und Ausgang */
                break;
            case KUECHE_AUSGANG:
                RAUM_1a = 0;
                RAUM_1b = 0;
                RAUM_2a = 1;
                RAUM_2b = 1;
                RAUM_3a = 1;
                RAUM_3b = 1;
                DGa = 0;
                DGb = 0;
                wait(5);
                state = KUECHE;        /* naechster Zustand ist Kueche */
                break;
            case KUECHE:
                RAUM_1a = 0;
                RAUM_1b = 0;
                RAUM_2a = 1;
                RAUM_2b = 1;
                RAUM_3a = 0;
                RAUM_3b = 0;
                DGa = 0;
                DGb = 0;
                wait(5);
                state = KUECHE_DG;        /* naechster Zustand ist Kueche und DG */
                break;
            case KUECHE_DG:
                RAUM_1a = 0;
                RAUM_1b = 0;
                RAUM_2a = 1;
                RAUM_2b = 1;
                RAUM_3a = 0;
                RAUM_3b = 0;
                DGa = 1;
                DGb = 1;
                wait(5);
                state = DG_ABEND;        /* naechster Zustand ist DG abends */
                break;
            case DG_ABEND:
                RAUM_1a = 0;
                RAUM_1b = 0;
                RAUM_2a = 0;
                RAUM_2b = 0;
                RAUM_3a = 0;
                RAUM_3b = 0;
                DGa = 1;
                DGb = 1;
                wait(10);
                state = NACHT;        /* naechster Zustand ist Nacht - alle schlafen */
                break;
            case NACHT:
                RAUM_1a = 0;
                RAUM_1b = 0;
                RAUM_2a = 0;
                RAUM_2b = 0;
                RAUM_3a = 0;
                RAUM_3b = 0;
                DGa = 0;
                DGb = 0;
                wait(20);
                state = DG_MORGEN;        /* naechster Zustand ist DG Morgens */
                break;
            case DG_MORGEN:
                RAUM_1a = 0;
                RAUM_1b = 0;
                RAUM_2a = 0;
                RAUM_2b = 0;
                RAUM_3a = 0;
                RAUM_3b = 0;
                DGa = 1;
                DGb = 1;
                wait(7);
                state = KUECHE_DG_MORGEN; /* naechster Zustand ist DG + Kueche Morgens */
                break;
            case KUECHE_DG_MORGEN:
                RAUM_1a = 0;
                RAUM_1b = 0;
                RAUM_2a = 1;
                RAUM_2b = 1;
                RAUM_3a = 0;
                RAUM_3b = 0;
                DGa = 1;
                DGb = 1;
                wait(3);
                state = KUECHE_MORGEN; /* naechster Zustand ist nur Kueche Morgens */
                break;
            case KUECHE_MORGEN:
                RAUM_1a = 0;
                RAUM_1b = 0;
                RAUM_2a = 1;
                RAUM_2b = 1;
                RAUM_3a = 0;
                RAUM_3b = 0;
                DGa = 0;
                DGb = 0;
                wait(7);
                state = KUECHE_EINGANG_MORGEN; /* naechster Zustand ist Kueche und Eingang Morgens */
                break;
            case KUECHE_EINGANG_MORGEN:
                RAUM_1a = 1;
                RAUM_1b = 1;
                RAUM_2a = 1;
                RAUM_2b = 1;
                RAUM_3a = 0;
                RAUM_3b = 0;
                DGa = 0;
                DGb = 0;
                wait(5);
                state = KUECHE_EINGANG_AUSGANG_MORGEN;        /* naechster Zustand ist alle EG Morgens */
                break;
            case KUECHE_EINGANG_AUSGANG_MORGEN:
                RAUM_1a = 1;
                RAUM_1b = 1;
                RAUM_2a = 1;
                RAUM_2b = 1;
                RAUM_3a = 1;
                RAUM_3b = 1;
                DGa = 0;
                DGb = 0;
                wait(3);
                state = KUECHE_EINGANG_ZWEI;        /* naechster Zustand ist Kueche und Eingang Zwei */
                break;
            case KUECHE_EINGANG_ZWEI:
                RAUM_1a = 1;
                RAUM_1b = 1;
                RAUM_2a = 1;
                RAUM_2b = 1;
                RAUM_3a = 0;
                RAUM_3b = 0;
                DGa = 0;
                DGb = 0;
                wait(5);
                state = EINGANG_MORGEN;        /* naechster Zustand ist Eingangszimmer Morgens */
                break;
            case EINGANG_MORGEN:
                RAUM_1a = 1;
                RAUM_1b = 1;
                RAUM_2a = 0;
                RAUM_2b = 0;
                RAUM_3a = 0;
                RAUM_3b = 0;
                DGa = 0;
                DGb = 0;
                wait(3);
                state = ARBEIT;        /* naechster Zustand ist Arbeit */
                break;
            case ARBEIT:
                RAUM_1a = 0;
                RAUM_1b = 0;
                RAUM_2a = 0;
                RAUM_2b = 0;
                RAUM_3a = 0;
                RAUM_3b = 0;
                DGa = 0;
                DGb = 0;
                wait(30);
                state = EINGANG;        /* naechster Zustand ist Eingangszimmer */
                break;
            default:
                /* sollte nie vorkommen */
                RAUM_1a = 1;
                RAUM_1b = 1;
                RAUM_2a = 0;
                RAUM_2b = 0;
                RAUM_3a = 0;
                RAUM_3b = 0;
                DGa = 0;
                DGb = 0;
                state = EINGANG;
                break;
        }
    }
}

void allLEDoff(void)
{
    PORTA = 0x00; /* LED's an Port A ausschalten */
    PORTC = 0x00; /* LED's an Port C ausschalten */
}

/* Initialisiert den Timer 1 fuer einen Sekundentakt */
void initTimer0(void)
{
    PIE1bits.TMR1IE = 0;    /* Timer Interrupt aus */
    T1CONbits.TMR1ON = 0;   /* Timer aus zum Verstellen */
    OSCCON = 0b01010001;    /* Takt 2 MHz aus internem Oszillator */
    /* Timer 1 ist ein 16-bit-Timer */
    T1CON = 0b00110100;
    /* Prescaler = 1:8  -> 62,5 kHz */
}

/* Startet den Timer neu */
void restartTimer0(void)
{
    /* Timer Wert fuer 1s ist 65536 - 62500 = 3036 */
    T1CONbits.TMR1ON = 0;   /* Timer aus zum Verstellen */
    TMR1 = 3036;
    T1CONbits.TMR1ON = 1;
    PIR1bits.TMR1IF = 0; /* Flag loeschen */
}

/* wartet fuer die angegebene Anzahl von Sekunden */
void wait(int seconds)
{
    int i;
    /* prueft, ob der Timer uebergelaufen ist */
    for (i = 0; i < seconds; i++)
    {
        restartTimer0();
        /* warten, bis der Timer uebergelaufen ist */
        while (PIR1bits.TMR1IF == 0);
    }
}

[Tobi P. (Gast)]

https://www.mikroe.com/timer-calculator


"Timer Calculator is a lightweight software which creates timer 
interrupts code for mikroC™, mikroBasic™ and mikroPascal™. ... Pick from 
over 1000 presets or set the desired parameters manually and hit 
“Calculate”."


Ist ganz praktisch und funzt gut, auch mit anderen Conpilern.

[Stefan F. (stefan84)]

Hallo fop, Hallo Tobi,

vielen Dank für den Quellcode und den Tipp mit dem Timer Calculater. Ich 
werde heute Abend mal den Code testen und mir die Tage dann auch die 
Webseite ansehen.

[Stefan F. (stefan84)]

Hallo fop,

ich habe den Code getestet. Er war super. Ich habe noch eine kleine 
Ergänzung

ANSEL = 0x00;

 vornehmen müssen und seit dem läuft es super. Es funktionieren nur zwei 
I/O Ports nicht, aber das werde ich entsprechend durchtesten und dann 
anpassen.

Noch einmal vielen Dank für deine Hilfe :-)