[创客交流] 基于纳瓦特MCU+RTC计时显示模块

#include "common.h"

#include "ics.h"

#include "rtc.h"

#include "uart.h"

#include "gpio.h"

#include "sysinit.h"

#include "start.h"



#include "oledfont.h"  

#define OLED_MODE 0

#define SIZE      8

#define XLevelL                0x00

#define XLevelH                0x10

#define Max_Column             128

#define Max_Row                64

#define Brightness             0xFF 

#define X_WIDTH                128

#define Y_WIDTH                64



#define OLED_SCLK_Clr() GPIO_PinClear(GPIO_PTE1);  

#define OLED_SCLK_Set() GPIO_PinSet(GPIO_PTE1); 



#define OLED_SDIN_Clr() GPIO_PinClear(GPIO_PTE0);  

#define OLED_SDIN_Set() GPIO_PinSet(GPIO_PTE0);  



#define OLED_CMD  0        

#define OLED_DATA 1



uint8_t hh=8,mm=30,ss=0;



void IIC_Start()

{

        OLED_SCLK_Set();

        OLED_SDIN_Set();

        OLED_SDIN_Clr();

        OLED_SCLK_Clr();

}

void IIC_Stop()

{

        OLED_SCLK_Set();

        OLED_SDIN_Clr();

        OLED_SDIN_Set();

}



void IIC_Wait_Ack()

{

        OLED_SCLK_Set() ;

        OLED_SCLK_Clr();

}



void Write_IIC_Byte(unsigned char IIC_Byte)

{

        unsigned char i;

        unsigned char m,da;

        da=IIC_Byte;

        OLED_SCLK_Clr();

        for(i=0;i<8;i++)                

        {

                m=da;

                m=m&0x80;

                if(m==0x80)

                {OLED_SDIN_Set();}

                else OLED_SDIN_Clr();

                da=da<<1;

                OLED_SCLK_Set();

                OLED_SCLK_Clr();

                }

}



void Write_IIC_Command(unsigned char IIC_Command)

{

   IIC_Start();

   Write_IIC_Byte(0x78);      

         IIC_Wait_Ack();        

   Write_IIC_Byte(0x00);                        

         IIC_Wait_Ack();        

   Write_IIC_Byte(IIC_Command); 

         IIC_Wait_Ack();        

   IIC_Stop();

}



void Write_IIC_Data(unsigned char IIC_Data)

{

   IIC_Start();

   Write_IIC_Byte(0x78);                        

   IIC_Wait_Ack();        

   Write_IIC_Byte(0x40);                        

   IIC_Wait_Ack();        

   Write_IIC_Byte(IIC_Data);

   IIC_Wait_Ack();        

   IIC_Stop();

}



void OLED_WR_Byte(unsigned dat,unsigned cmd)

{

        if(cmd)

        {

          Write_IIC_Data(dat);

        }

        else 

        {

          Write_IIC_Command(dat);

        }

}



void Delay_50ms(unsigned int Del_50ms)

{

        unsigned int m;

        for(;Del_50ms>0;Del_50ms--)

                for(m=6245;m>0;m--);

}



void Delay_1ms(unsigned int Del_1ms)

{

        unsigned char j;

        while(Del_1ms--)

        {        

                for(j=0;j<123;j++);

        }

}



void OLED_Set_Pos(unsigned char x, unsigned char y) 

{         

        OLED_WR_Byte(0xb0+y,OLED_CMD);

        OLED_WR_Byte(((x&0xf0)>>4)|0x10,OLED_CMD);

        OLED_WR_Byte((x&0x0f),OLED_CMD); 

}             



void OLED_Display_On(void)

{

        OLED_WR_Byte(0X8D,OLED_CMD);  

        OLED_WR_Byte(0X14,OLED_CMD);  

        OLED_WR_Byte(0XAF,OLED_CMD); 

}







void OLED_Clear(void)  

{  

        unsigned char i,n;                    

        for(i=0;i<8;i++)  

        {  

                OLED_WR_Byte (0xb0+i,OLED_CMD);    

                OLED_WR_Byte (0x00,OLED_CMD);      

                OLED_WR_Byte (0x10,OLED_CMD);        

                for(n=0;n<128;n++)OLED_WR_Byte(0,OLED_DATA); 

        } 

}



void OLED_Clearp(void)  

{  

        unsigned char i,n;                    

        for(i=2;i<6;i++)  

        {  

                OLED_WR_Byte (0xb0+i,OLED_CMD);    

                OLED_WR_Byte (0x00,OLED_CMD);      

                OLED_WR_Byte (0x10,OLED_CMD);        

                for(n=0;n<128;n++)OLED_WR_Byte(0,OLED_DATA); 

        } 

}





void OLED_ShowChar(unsigned char x,unsigned char y,unsigned char chr,unsigned char Char_Size)

{              

        unsigned char c=0,i=0;        

        c=chr-' ';                

        if(x>Max_Column-1){x=0;y=y+2;}

        if(Char_Size ==16)

        {

                 OLED_Set_Pos(x,y);        

                 for(i=0;i<8;i++)

                 OLED_WR_Byte(F8X16[c*16+i],OLED_DATA);

                 OLED_Set_Pos(x,y+1);

                 for(i=0;i<8;i++)

                 OLED_WR_Byte(F8X16[c*16+i+8],OLED_DATA);

        }

        else 

        {        

                 OLED_Set_Pos(x,y);

                 for(i=0;i<6;i++)

                 OLED_WR_Byte(F6x8[c][i],OLED_DATA);

        }

}



uint32_t oled_pow(unsigned char m,unsigned char n)

{

        uint32_t result=1;         

        while(n--)result*=m;    

        return result;

}                                  

                  

void OLED_ShowNum(unsigned char x,unsigned char y,uint32_t num,unsigned char len,unsigned char size2)

{                 

        unsigned char t,temp;

        unsigned char enshow=0;                                                   

        for(t=0;t<len;t++)

        {

                temp=(num/oled_pow(10,len-t-1))%10;

                if(enshow==0&&t<(len-1))

                {

                        if(temp==0)

                        {

                                OLED_ShowChar(x+(size2/2)*t,y,' ',size2);

                                continue;

                        }else enshow=1; 

                          

                }

                 OLED_ShowChar(x+(size2/2)*t,y,temp+'0',size2); 

        }

} 



void OLED_ShowString(unsigned char x,unsigned char y,unsigned char *chr,unsigned char Char_Size)

{

        unsigned char j=0;

        while (chr[j]!='\0')

        {                OLED_ShowChar(x,y,chr[j],Char_Size);

                        x+=8;

                if(x>120){x=0;y+=2;}

                        j++;

        }

}



void OLED_ShowCHinese(unsigned char x,unsigned char y,unsigned char no)

{                                  

    unsigned char t,adder=0;

    OLED_Set_Pos(x,y);        

    for(t=0;t<16;t++)

    {

            OLED_WR_Byte(Hzk[2*no][t],OLED_DATA);

            adder+=1;

    }        

            OLED_Set_Pos(x,y+1);        

    for(t=0;t<16;t++)

    {        

             OLED_WR_Byte(Hzk[2*no+1][t],OLED_DATA);

             adder+=1;

    }                                        

}

      

void OLED_Init(void)

{ 

        //SSD1306    

        OLED_SCLK_Set();

        OLED_SDIN_Set(); 

        Delay_1ms(800); 

        OLED_WR_Byte(0xAE,OLED_CMD);

        OLED_WR_Byte(0x00,OLED_CMD);

        OLED_WR_Byte(0x10,OLED_CMD);

        OLED_WR_Byte(0x40,OLED_CMD); 

        OLED_WR_Byte(0xB0,OLED_CMD);

        OLED_WR_Byte(0x81,OLED_CMD); 

        OLED_WR_Byte(0xFF,OLED_CMD); 

        OLED_WR_Byte(0xA1,OLED_CMD); 

        OLED_WR_Byte(0xA6,OLED_CMD);

        OLED_WR_Byte(0xA8,OLED_CMD);

        OLED_WR_Byte(0x3F,OLED_CMD);

        OLED_WR_Byte(0xC8,OLED_CMD);

        OLED_WR_Byte(0xD3,OLED_CMD);

        OLED_WR_Byte(0x00,OLED_CMD);

        

        OLED_WR_Byte(0xD5,OLED_CMD);

        OLED_WR_Byte(0x80,OLED_CMD);

        

        OLED_WR_Byte(0xD8,OLED_CMD);

        OLED_WR_Byte(0x05,OLED_CMD);

        

        OLED_WR_Byte(0xD9,OLED_CMD);

        OLED_WR_Byte(0xF1,OLED_CMD);

        

        OLED_WR_Byte(0xDA,OLED_CMD);

        OLED_WR_Byte(0x12,OLED_CMD);

        

        OLED_WR_Byte(0xDB,OLED_CMD);

        OLED_WR_Byte(0x30,OLED_CMD);

        

        OLED_WR_Byte(0x8D,OLED_CMD);

        OLED_WR_Byte(0x14,OLED_CMD);

        

        OLED_WR_Byte(0xAF,OLED_CMD);

} 





void cd11()

{   

        OLED_Clear(); 

        OLED_ShowString(24,0,"RTC CLOCK",16);

        OLED_ShowString(24,4,"jinglixixi",16);

}



void myDelay (uint32_t ulTime)

{

    uint32_t i;

    i = 0;

while (ulTime--) 

{

        for (i = 0; i < 5000; i++);

    }

}



int main (void);

void RTC_Task(void);





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

int main (void)

{

    sysinit();

    cpu_identify();



    RTC_ConfigType  sRTCConfig;

    RTC_ConfigType  *pRTCConfig = &sRTCConfig;  



    pRTCConfig->u16ModuloValue = 9;                                      

    pRTCConfig->bInterruptEn   = RTC_INTERRUPT_ENABLE;    

    pRTCConfig->bClockSource   = RTC_CLKSRC_1KHZ;         

    pRTCConfig->bClockPresaler = RTC_CLK_PRESCALER_100;    

    

    RTC_SetCallback(RTC_Task);

    RTC_Init(pRTCConfig);



    GPIO_Init(GPIOB, GPIO_PTE7_MASK, GPIO_PinOutput);

    GPIO_Init(GPIOB, GPIO_PTE7_MASK, GPIO_PinOutput);

    GPIO_Init(GPIOB, GPIO_PTE0_MASK, GPIO_PinOutput);

    GPIO_Init(GPIOB, GPIO_PTE1_MASK, GPIO_PinOutput);

    OLED_Init();

    OLED_Clear(); 

    cd11();

    OLED_ShowString(24,6,"2018.6.30",16);

    

    while (1)

    {

                      OLED_ShowNum(24,2,hh,2,16);

                        OLED_ShowChar(40,2,':',16);

                        OLED_ShowNum(48,2,mm,2,16);

                        OLED_ShowChar(64,2,':',16);

                        OLED_ShowNum(72,2,ss,2,16);

                        if(ss==60) 

                        {

                          ss=0;

                                mm=mm+1;

                        }

                        if(mm==60) 

                        {

                          mm=0;

                                hh=hh+1;

                        }

                        if(hh==24) 

                        {

                          hh=0;

                        }

        }

}





void RTC_Task(void)

{



    GPIO_Toggle(GPIOB, GPIO_PTE7_MASK);

    ss++;

}