Nach 8 kommt 19 und danach 10 - 7 Seg Uhr mit MAX7219

/*

 * File:   main7219.c

 * Author: BeastyK

 *

 * Created on 9. Oktober 2016, 17:54

 */

#include <xc.h>

#include <delays.h>

#include <spi.h>

#include <timers.h>

#include <stdio.h>

#include <stdlib.h>

#include "m7219.h"

#define _XTAL_FREQ 20000000

void Timer1Init();

void interrupt_isr(void);

//void max7219_time_write(unsigned int std, unsigned int min, unsigned int sek);

/*****************************************************************************/  

/** C O N F I G U R A T I O N ************************************************/

/*****************************************************************************/

// PIC18F4455 Configuration Bit Settings

// 'C' source line config statements

// CONFIG1L

#pragma config PLLDIV = 5       // PLL Prescaler Selection bits (Divide by 5 (20 MHz oscillator input))

#pragma config CPUDIV = OSC1_PLL2// System Clock Postscaler Selection bits ([Primary Oscillator Src: /1][96 MHz PLL Src: /2])

#pragma config USBDIV = 2       // USB Clock Selection bit (used in Full-Speed USB mode only; UCFG:FSEN = 1) (USB clock source comes from the 96 MHz PLL divided by 2)

// CONFIG1H

#pragma config FOSC = HSPLL_HS  // Oscillator Selection bits (HS oscillator, PLL enabled (HSPLL))

#pragma config FCMEN = OFF      // Fail-Safe Clock Monitor Enable bit (Fail-Safe Clock Monitor disabled)

#pragma config IESO = OFF       // Internal/External Oscillator Switchover bit (Oscillator Switchover mode disabled)

// CONFIG2L

#pragma config PWRT = OFF       // Power-up Timer Enable bit (PWRT disabled)

#pragma config BOR = ON         // Brown-out Reset Enable bits (Brown-out Reset enabled in hardware only (SBOREN is disabled))

#pragma config BORV = 3         // Brown-out Reset Voltage bits (Minimum setting 2.05V)

#pragma config VREGEN = ON      // USB Voltage Regulator Enable bit (USB voltage regulator enabled)

// CONFIG2H

#pragma config WDT = OFF        // Watchdog Timer Enable bit (WDT disabled (control is placed on the SWDTEN bit))

#pragma config WDTPS = 32768    // Watchdog Timer Postscale Select bits (1:32768)

// CONFIG3H

#pragma config CCP2MX = ON      // CCP2 MUX bit (CCP2 input/output is multiplexed with RC1)

#pragma config PBADEN = OFF     // PORTB A/D Enable bit (PORTB<4:0> pins are configured as digital I/O on Reset)

#pragma config LPT1OSC = OFF    // Low-Power Timer 1 Oscillator Enable bit (Timer1 configured for higher power operation)

#pragma config MCLRE = ON       // MCLR Pin Enable bit (MCLR pin enabled; RE3 input pin disabled)

// CONFIG4L

#pragma config STVREN = ON      // Stack Full/Underflow Reset Enable bit (Stack full/underflow will cause Reset)

#pragma config LVP = OFF        // Single-Supply ICSP Enable bit (Single-Supply ICSP disabled)

#pragma config ICPRT = OFF      // Dedicated In-Circuit Debug/Programming Port (ICPORT) Enable bit (ICPORT disabled)

#pragma config XINST = OFF      // Extended Instruction Set Enable bit (Instruction set extension and Indexed Addressing mode disabled (Legacy mode))

// CONFIG5L

#pragma config CP0 = OFF        // Code Protection bit (Block 0 (000800-001FFFh) is not code-protected)

#pragma config CP1 = OFF        // Code Protection bit (Block 1 (002000-003FFFh) is not code-protected)

#pragma config CP2 = OFF        // Code Protection bit (Block 2 (004000-005FFFh) is not code-protected)

// CONFIG5H

#pragma config CPB = OFF        // Boot Block Code Protection bit (Boot block (000000-0007FFh) is not code-protected)

#pragma config CPD = OFF        // Data EEPROM Code Protection bit (Data EEPROM is not code-protected)

// CONFIG6L

#pragma config WRT0 = OFF       // Write Protection bit (Block 0 (000800-001FFFh) is not write-protected)

#pragma config WRT1 = OFF       // Write Protection bit (Block 1 (002000-003FFFh) is not write-protected)

#pragma config WRT2 = OFF       // Write Protection bit (Block 2 (004000-005FFFh) is not write-protected)

// CONFIG6H

#pragma config WRTC = OFF       // Configuration Register Write Protection bit (Configuration registers (300000-3000FFh) are not write-protected)

#pragma config WRTB = OFF       // Boot Block Write Protection bit (Boot block (000000-0007FFh) is not write-protected)

#pragma config WRTD = OFF       // Data EEPROM Write Protection bit (Data EEPROM is not write-protected)

// CONFIG7L

#pragma config EBTR0 = OFF      // Table Read Protection bit (Block 0 (000800-001FFFh) is not protected from table reads executed in other blocks)

#pragma config EBTR1 = OFF      // Table Read Protection bit (Block 1 (002000-003FFFh) is not protected from table reads executed in other blocks)

#pragma config EBTR2 = OFF      // Table Read Protection bit (Block 2 (004000-005FFFh) is not protected from table reads executed in other blocks)

// CONFIG7H

#pragma config EBTRB = OFF      // Boot Block Table Read Protection bit (Boot block (000000-0007FFh) is not protected from table reads executed in other blocks)

// #pragma config statements should precede project file includes.

// Use project enums instead of #define for ON and OFF.

/*****************************************************************************/

/**** M A I N  P R O G R A M  ************************************************/

/*****************************************************************************/

unsigned char i;

unsigned int second = 0, minute = 0, hour = 0;

void Timer1Init() {

    //Timer1 ist ein 16bit Timer (FFFFh oder 65535) mit jeweils 8bit Timer High 

    //und 8bit Timer Low mit externen Uhrenquarz von 32768Hz wird der Interrupt nach

    //2 Sekunden gesetzt, daher wird TMR1H auf 80h gesetzt (8000h ist der gesamte 

    //Timer1 aus TMR1H und TMR1L und entspricht 32768)

TMR1H = 0x80;                //setzt Msb des oberen 8bit des Timer1 auf 1     

TMR1L = 0;                //setzt die unteren 8bit des Timers1 auf Null

  TRISCbits.TRISC0 = 1;       //setzt TRISC0 auf Eingang (warum aber nicht TRISC1?)

  LATBbits.LATB6 = 1;        //setzt den PM-Zeit bit

  T1CON = 0b00001111;           // 2x8bit, externer Takt, Osc enabled, asynch, start!

    PIE1bits.TMR1IE = 1;

    INTCONbits.PEIE = 1;

    //RCONbits.IPEN=0x01;

    //IPR1bits.TMR1IP=0x01;            // TMR1 high priority ,TMR1 Overflow Interrupt Priority bit

    INTCONbits.GIE = 1;

    PIR1bits.TMR1IF = 0;        //setzt den Timerinterrupt von Timer1 auf Null

}

void interrupt  isr(void)

{

//TMR1H |= 0x80;

  if (PIR1bits.TMR1IF) 

  {

    unsigned int d = 0, e = 0, f = 0, std = 0, min = 0, sek = 0;

        second++;

  //  max7219new++;

    TMR1H = 0x70;    

    //PIR1bits.TMR1IF = 0;    //TMR1IF überlauf muß per software zurückgesetzt werden (Datenblatt Seite 102)

    if (second >= 60)     //ist second gleich oder größer 60 dann

      {

        minute++;      //Variable minute um 1 erhöhen (60 Sekunden sind eine Minute)

          second = 0;      //die Variable second beim Timerinterrupt wieder von 0 anfangen lassen zu zählen

      }

  if (minute >= 60)    //ist minute gleich oder größer 60 dann

      {

        hour++;        //Variable hour um 1 erhöhen (60 Minuten sind eine Stunde)

          minute = 0;      //die Variable minute wieder auf 0 setzen damit eine neue Minute gezählt wird

      }

  if (hour >= 24)

      {

        hour = 0;

      }

    //if (max7219new >= 1)

  //    {

  //      max7219_time_write(hour, minute, second);

  //      max7219new = 0;

  //    }

  //d = hour / 10;

  //std = hour - (d * 10);

  //max7219_digitwrite(3, d);

  //max7219_digitwrite(4, std);

  //e = minute / 10;

  //min = minute - (e * 10);

  //max7219_digitwrite(5, e);

  //max7219_digitwrite(6, min);

  f = second / 10;

  sek = second - (f * 10);

  max7219_digitwrite(7, f);

  max7219_digitwrite(8, sek);

    PIR1bits.TMR1IF = 0;    //TMR1IF überlauf muß per software zurückgesetzt werden (Datenblatt Seite 102)

  }

}

/*void max7219_time_write(unsigned int std, unsigned int min, unsigned int sek)

{

  unsigned int d = 0, e = 0, f = 0;

  d = std / 10;

  std = std - (d * 10);

  max7219_digitwrite(3, d);

  max7219_digitwrite(4, std);

  e = min / 10;

  min = min - (e * 10);

  max7219_digitwrite(5, e);

  max7219_digitwrite(6, min);

  f = sek / 10;

  sek = sek - (f * 10);

  max7219_digitwrite(7, f);

  max7219_digitwrite(8, sek);

}

*/

void main(void)

{

  __delay_ms(25);  //Delay of 100ms

  __delay_ms(25);

  __delay_ms(25);  

  __delay_ms(25);

  OpenSPI(SPI_FOSC_16, MODE_00, SMPMID);  // MODE besteht aus CKP/CKE, ist CKP gleich 1, SCK sendet nicht bei hohen Pegel oder CKP ist 0, SCK

                      //sendet nicht bei niedrigen Pegel.           

  __delay_ms(25);  //Delay of 100ms

  __delay_ms(25);

  __delay_ms(25);  //Delay of 100ms

  __delay_ms(25);

  TRISC &= 0xFB;    // 1111 1011

  TRISD = 0xF0;      // 1111 0000  

  LATDbits.LATD0 = 1; //Set D0 high  

  __delay_ms(25);  //Delay of 100ms

  __delay_ms(25);

  __delay_ms(25);  //Delay of 100ms

  __delay_ms(25);

  max7219_init();

  __delay_ms(25);  //Delay of 100ms

  __delay_ms(25);

  __delay_ms(25);  //Delay of 100ms

  __delay_ms(25);

  Timer1Init();

  __delay_ms(25);  //Delay of 100ms

  __delay_ms(25);

  __delay_ms(25);  //Delay of 100ms

  __delay_ms(25);

while(1)

  {

  } 

}

//MAX 7219 chip_util Library

#include <p18f4455.h>

#include <spi.h>

#define SELMAX      PORTCbits.RC2 = 1;

#define DESELMAX    PORTCbits.RC2 = 0;

void max7219_init() {

  SELMAX;           // SELECT MAX

  WriteSPI(0x09);         // BCD mode for digit decoding

  WriteSPI(0xFF);

  DESELMAX;              // DESELECT MAX

  SELMAX;           // SELECT MAX

  WriteSPI(0x0A);

  WriteSPI(0x0F);         // Segment luminosity intensity

  DESELMAX;              // DESELECT MAX

  SELMAX;           // SELECT MAX

  WriteSPI(0x0B);

  WriteSPI(0x07);

 // WriteSPI(x-1);         // Set how many digits mit max7219_init(int x)

  DESELMAX;              // DESELECT MAX

  SELMAX;           // SELECT MAX

  WriteSPI(0x0C);

  WriteSPI(0x01);         // Turn on the display

  DESELMAX;              // DESELECT MAX

  SELMAX;           // SELECT MAX

  WriteSPI(0x00);

  WriteSPI(0xFF);         // No test

  DESELMAX;              // DESELECT MAX

}

void max7219_clear(int x) {

unsigned char ii;

  for (ii = 1; ii<=x; ii++)

  {

    SELMAX;          // select max7219

    WriteSPI(ii);           // send i to max7219 (digit place)

    WriteSPI(0);         // send i to max7219 (digit)

    DESELMAX;             // deselect max7219

  }

}

void max7219_digitwrite(int x, int y) {

    SELMAX;          // select max7219

    WriteSPI(x);           // send i to max7219 (digit place)

    WriteSPI(y);         // send i to max7219 (digit)

    DESELMAX;             // deselect 

    return;

}

void max7219_write(unsigned int value) {

unsigned int d;

    d = value / 10000;

    value=value-(d*10000);

    max7219_digitwrite(5,d);

    d = value / 1000;

    value=value-(d*1000);

    max7219_digitwrite(4,128+d);

    d = value / 100;

    value=value-(d*100);

    max7219_digitwrite(3,d);

    d = value / 10;

    value=value-(d*10);

    max7219_digitwrite(2,d);

    max7219_digitwrite(1,value);

}