10h - Timer

PICkit 3 (DV 164131, PICkit 3 Debug Express), ist auch bei reichelt.de erhältlich.
Das Programmierkabel ist ca. 94 cm lang. Jede 2 Ader des 10 adrigen Flachbandkabels ist auf Masse gelegt um Störungen zu vermeiden

Stromlaufplan groß (Achtung nach unten und rechts scrollen, sonst erscheint nur eine weiße Fläche)

Bauteile-Liste

Bei der ICSP-Stiftleiste (einreihig) wäre auch ein Wannenstecker, 10-polig, zweireihig, gerade, möglich und sinnvoll, reichelt.de

Steckergehäuse mit Eurostecker, weiß, Innenmaße (LxBxH): 88x66x35 mm, Außenmaße (LxBxH): 94x71x41 mm, pollin.de

Buzzer, Summer, der naximal 25 mA zieht, da der µC max. 25 mA pro Port schalten kann.
Der Summer F/TCW05 und SUMMER TDB 05 verbrauchen max. 30mA bei 5V laut Datenblättern.
Durch eine Reihenschaltung mit einem 47 Ohm-Widerstand wird der Strom auf max. 23,4 mA reduziert.
Die Lautstärke wird hierdurch etwas reduziert. Eine andere Möglichkeit ist den Summer mit einem Transistor anzusteuern wie beim Relais.
Eine weitere Möglichkeit ist 2 Ports zu benutzen, die über Dioden entkoppelt sind.

Datenblätter, allgemein: datasheetcatalog.com

// *******************************************************************
//
// 8, 9, 10 Stunden-Timer, einstellbar durch Schalter
//
// PIC18F15K50, Interner Takt 1 MHz (Defaultwert)
// Timer wird durch das Drücken und Loslassen des Tasters gestartet.
// Summer ertönt für 1 Sekunde. Relais zieht an.
// Zur optischen Kontrollen blinkt die gruene LED bei eingestelltem Timer von 8 Stunden
// 8 mal im 1 Sekundentakt gefolgt von einer Pause von 3 Sekunden. Dies wiederholt sich
// bis eine Stunde vergangen ist. Jetzt blinkt sie nur 7 mal und soweiter.
// Wenn die Zeit abgelaufen ist, ertönnt der Summer 5 mal und dann fällt das Relais ab.
//
// *******************************************************************

/** C O N F I G U R A T I O N B I T S ******************************/
#pragma config WDTEN = OFF         // Watchdog Timer OFF
#pragma config FOSC = IRC          // POR => Internal RC oscillator
#pragma config BOREN = ON          // Brown-out Reset enabled
#pragma config BORV = 19           // VBOR set to 3.0V
#pragma config HFOFST = ON         // Warten bis System-clock stabil
#pragma config LVP = OFF           // Low Voltage ICSP
#pragma config PWRTEN = ON         // Power-UP-Timer enabled
#pragma config MCLRE = ON        // MCLR pin enabled, RA3 input pin disabled
#pragma config STVREN = OFF        // Stack full/underflow will not cause Reset

/** I N C L U D E S **************************************************/
#include "p18f14k50.h"
#include "delays.h"
#include "adc.h"

/** D E C L A R A T I O N S ** Präprozessoranweisung ******************/
#define LEDgruen LATBbits.LATB4    // Grüne LED an RB4
#define Summer LATBbits.LATB5      // Summer an RB5
#define Relais LATBbits.LATB6      // Relais an RB6
#define LEDrot LATBbits.LATB7      // Rote LED an RB7
#define Schalter LATCbits.LATC7    // Schalter an RC7 ( = AN9)
#define Taster_Pin PORTCbits.RC2   // Taster an RC2
#define LEDgruenEin 1
#define LEDgruenAus 0
#define LEDrotEin 0                // Da die rote LED gegen VDD geschaltet ist leuchtet sie, wenn der Ausgang LOW-Pegel (0) hat (Lowaktiv)
#define LEDrotAus 1
#define RelaisEin 1
#define RelaisAus 0

/** D E C L A R A T I O N S *******************************************/
// unsigned int Verzoegerung_s = 0;
unsigned char SekundenZaehler;
unsigned int SekundenTakt;
unsigned int RestMinuten;
unsigned int result;
char i;
char z;
char SummerEin = 0;                 // Da Summer gegen VDD geschaltet ist ertönt er wenn der Ausgang LOW-Pegel hat (Lowaktiv)
char SummerAus = 1;
char Taster_gedrueckt;

/** P r o g r a m m e *******************************************/
void delay_s (int);

void Taster (void);

void main (void)
{
    SekundenZaehler = 0;
    SekundenTakt = 0;
    RestMinuten = 1;

    TRISC = 0b11111111;                    // Alle Portpins von PORTC werden als Eingang geschaltet
                                           // PORTC , RC2 = Input Taster, 0= Output, 1 = Input, -, -, -, -, -, -,Taster, -, -
                                           // Der Defaultwert von jedem TRIS ist alle Eingang = 0b11111111

    ANSEL = 0b00000000;                    // Alle folgenden Eingänge werden als digitale Eingänge geschaltet
                                           // ANS7 ANS6 ANS5 ANS4 ANS3 - - - , 0 = Digital, 1 = Analog, ANSEL = ANalog SELect
                                           // RC3 RC2 RC1 RC0 RA4 - - -

    Taster_gedrueckt = 0;                  // Taster_gedrueckt wird auf 0 gesetzt

    do
    {
       Taster();                           // Funktion Taster wird aufgerufen
    }
    while (Taster_gedrueckt == 0);         // Schleife wird solange wiederholt bis der Taster als eindeutig gedrueckt erkannt wurde

    TRISB = 0b00000000;                    // PORTB wird komplett als Ausgang geschaltet
                                           // PORTB 0= Output, 1 = Input,
                                           // LED_rot, Relais, Summer, LED_gruen, -, -, -, -

    Relais = RelaisEin;                    // Relais Ein,

                                           // Summer ertönt für 1 Sekunde, um zu signalisieren, das der Verbraucher eingeschaltet worden ist
    Summer = SummerEin;                    // Ein
    delay_s(1);                            // Verzögerung 1 Sekunde
    Summer = SummerAus;                    // Aus

/* Initialisierung ADC (Analog-Digital-Converter */
    ADCON0=0b00100111;                     // ADCON0: A/D CONTROL REGISTER 0
                                           // bit 7-6 Unimplemented
                                           // bit 5-2 Bitmuster 1001 = AN9 ( = RC9 = Schalter)
                                           // bit 1 GO/DONE: A/D Conversion Status bit, 1 = A/D conversion cycle in progress
                                           // bit 0 ADON: ADC Enable bit, 1 = enable

    ADCON1=0b00000000;                     // ADCON1: A/D CONTROL REGISTER 1, default = 0b00000000
                                           // bit 7-4 Unimplemented: Read as ‘0’
                                           // bit 3-2 PVCFG<1:0>: Positive Voltage Reference select bit
                                           // 00 = Positive voltage reference supplied internally by VDD.
                                           // bit 1-0 NVCFG<1:0>: Negative Voltage Reference select bit
                                           // 00 = Negative voltage reference supplied internally by VSS

    OpenADC;                               // ADC (Analog Digital Converter) wird gestartet
    Delay10TCYx( 5 );                      // Delay für 50TCY, Verzögerung für 5 x 10 Taktzyklen (TCY)
    ConvertADC();                          // Start Wandlung Analog zu Digital
    while( BusyADC() );                    // Warten bis Wandlung beendet ist
    result = ReadADC();                    // Ergebnis (0 bis 65 535) wird in result kopiert
    CloseADC();                            // AD-Wandler wird geschlossen

    if (result<20000) RestMinuten = 8;     // Wenn Schalter auf 8 Stunden steht wird in die Variable RestMinuten der Wert 8                                            // kopiert
    if (result>20000) RestMinuten = 9;
    if (result>40000) RestMinuten = 10;

    while (RestMinuten > 0)
    {
       LEDrot = LEDrotEin;                  // LED rot Ein
       Delay1KTCYx(125);                    // Verzoegerung 500ms, 125 x 1000 = 125,000 Zyklen; 500ms bei 1MHz
       LEDrot = LEDrotAus ;                 // LED rot Aus
       LEDgruen = LEDgruenAus;              // LED gruen Aus
       Delay1KTCYx(125);                    // Verzoegerung 500ms, 125 x 1000 = 125,000 Zyklen; 500ms bei 1MHz

       ++SekundenZaehler;                   // SekundenZaehler inkrementieren
       ++SekundenTakt;                      // SekundenTakt inkrementieren

       if (SekundenTakt==3600) {--RestMinuten; SekundenTakt = 0;}          // Wenn SekundenTakt == 3600 wird die RestMinuten dekrementiert
       if (SekundenZaehler <= RestMinuten) LEDgruen = LEDgruenEin;         // Wenn SekundenZaehler kleiner/gleich RestMinuten LED gruen Ein
       if (SekundenZaehler >= RestMinuten + 2) SekundenZaehler = 0;        // Wenn SekundenZaehler == (RestMinuten + 2) wird der                                                                            //  SekundenZaehler auf 0 gesetzt
}

    Relais = RelaisAus;                     // Relais Aus, Verbraucher wird abgeschaltet

    for (i=0; i<3; i++)                     // Summer ertönt und grüne LED leuchtet mehrmals, um zu signalisieren, das der Verbraucher                                             // abgeschaltet worden ist
    {
      Summer = SummerEin;                   // Summer Ein
      LEDgruen = LEDgruenEin;               // LED gruen Ein
      delay_s(1);                           // Verzögerung 1 Sekunde
      Summer = SummerAus;                   // Summer Aus
      LEDgruen = LEDgruenAus;               // LED gruen Aus
      delay_s(10);                          // Verzögerung 10 Sekunden
    }                                       // ((void(*)(void)) 0x0) (); // Software-Reset
}

void delay_s(int Verzoegerung_s)            // Verzögerungs-Funktion
{
   for (z=0; z<Verzoegerung_s; z++)
   {
     Delay1KTCYx(250);                      // Verzögerung 250 000 Zyklen (25 x 10000); 1000ms bei 1 MHz
   }                                        // 1KT = 100000
}

void Taster (void)                          // Taster-Entprellen-Funktion, Im Abstand von 40ms wird mehrfach überprüft (Taster_Pin == 0)                                             // ob der Taster betätigt wurde?
{
                                            // Wenn dies zutrifft, wird "Taster_gedrueckt" auf "1" gesetzt und die Routine verlassen.
  char sample;
  char Taster_Sample_positiv = 0;
  for (sample=0; sample<4; ++sample)
    {
      if (Taster_Pin == 0) ++Taster_Sample_positiv;
      Delay1KTCYx(10);                                        // Verzögerung 40ms, 10 000 Zyklen (10 x 10000); 40ms bei 1 MHz
    }
  if (Taster_Sample_positiv > 3) Taster_gedrueckt = 1;
  Taster_Sample_positiv = 0;
}

10h-Timer