打印
[创客交流]

基于纳瓦特MCU+RTC计时显示模块

[复制链接]
1716|4
手机看帖
扫描二维码
随时随地手机跟帖
跳转到指定楼层
楼主
     在NV32F100的内部也配有RTC功能,但它不同与常规的RTC 它在例程中并没有通过RTC初试值的设置与读取方法,为了实现RTC的计时功能,我们可以模拟其计时的进制关系来实现。此外,通过一个I2C接口的双色OLED屏可以将计时器显示出来,其效果如图所示。

OLED屏与NV32F100的连接关系为:
  VCC --  5V/3.3V
  GND --  GND
  SCL --  PE1
  SDA -- PE0


实现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++;
}


相关帖子

沙发
xyz549040622| | 2018-6-30 22:13 | 只看该作者
支持下,赞一个!

使用特权

评论回复
板凳
jinglixixi|  楼主 | 2018-7-1 09:32 | 只看该作者

感谢支持!!!

使用特权

评论回复
地板
123ycli| | 2018-7-22 22:53 | 只看该作者
不错,不错,RTC的精度如何呢?有单独的RTC供电电源吗?

使用特权

评论回复
5
jinglixixi|  楼主 | 2018-7-23 09:05 | 只看该作者
123ycli 发表于 2018-7-22 22:53
不错,不错,RTC的精度如何呢?有单独的RTC供电电源吗?

精度还可以,没长时间监测,短时间看不出。无单独的RTC供电电源,功耗不大时可长时间维持其供电以进行持续RTC计时。

使用特权

评论回复
发新帖 我要提问
您需要登录后才可以回帖 登录 | 注册

本版积分规则

464

主题

2783

帖子

38

粉丝