STM32

STM32F407驱动DS1302，读出的数据一直为FF，请问如何处理，谢谢

2019-07-20 19:23发布

站内问答 / STM32/STM8
16149 9 1493
1.电路

1.jpg

2.ds1302.h
[mw_shl_code=c,true]extern uint8_t read[];
       

#define ds1302clk GPIO_Pin_0
#define ds1302dat GPIO_Pin_1
#define ds1302rst GPIO_Pin_2   
/* 变量 ----------------------------------------------------------------------*/
/* 函数声明 ------------------------------------------------------------------*/
/* 函数定义 ------------------------------------------------------------------*/

void DS1302_Init(void);
void write_1302byte(uint8_t dat);//写一个字节的数据sck上升沿写数据
void write_1302(uint8_t add,uint8_t dat);//向指定寄存器写入一个字节的数据
u8   read_1302(uint8_t add);//读数据
//void ds1302_init(uint8_t *write,uint8_t *time);//初始化1302
//void ds1302_data(uint8_t *read);//处理数据并通过串口打印

int DS1302_SetTime(pContext ctx);
int DS1302_GetTime(pContext ctx);[/mw_shl_code]

3.ds1302.c
[mw_shl_code=c,true]uint8_t read[]={0x81,0x83,0x85,0x87,0x89,0x8b,0x8d};//读秒、分、时、日、月、周、年的寄存器地址
uint8_t write[]={0x80,0x82,0x84,0x86,0x88,0x8a,0x8c};//写秒、分、时、日、月、周、年的寄存器地址
/*CLK RST配置为输出*/
/*DAT 配置为开漏模式，此模式下能够实现真正的双向IO口*/
//CLK PC0
//DAT PC1
//RST PC2
void DS1302_Init(void)
{
        GPIO_InitTypeDef  GPIO_InitStructure;
        RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);//使能GPIOC时钟
       
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_2;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
        GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_25MHz;//25MHz
        GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
        GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化
       
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
        GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;//开漏输出
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_25MHz;//25MHz
        GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
        GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化       
}

void write_1302byte(uint8_t dat)//写一个字节的数据sck上升沿写数据
{
        uint8_t i=0;
        GPIO_ResetBits(GPIOC,ds1302clk);
        //ds1302clk=0;
    delay_us(2);//延时大约2us
        for(i=0;i<8;i++)
        {
                GPIO_ResetBits(GPIOC,ds1302clk);
                //ds1302clk=0;
                if(dat&0x01)
                GPIO_SetBits(GPIOC,ds1302dat);
                else
                GPIO_ResetBits(GPIOC,ds1302dat);
                //ds1302dat=(dat&0x01);
                delay_us(2);
                GPIO_SetBits(GPIOC,ds1302clk);
                //ds1302clk=1;
                dat>>=1;
                delay_us(1);
        }       
}

uint8_t read_1302(uint8_t add)//读数据
{
        uint8_t i=0,dat1=0x00;
        GPIO_ResetBits(GPIOC,ds1302rst);
        GPIO_ResetBits(GPIOC,ds1302clk);
        //ds1302rst=0;
        //ds1302clk=0;
        delay_us(3);//略微延时2us
        GPIO_SetBits(GPIOC,ds1302rst);
        //ds1302rst=1;
        delay_us(3);//时间要大约3us
        write_1302byte(add);//先写寄存器的地址
        for(i=0;i<8;i++)
        {
                GPIO_SetBits(GPIOC,ds1302clk);
                //ds1302clk=1;
                dat1>>=1;
                GPIO_ResetBits(GPIOC,ds1302clk);
                //ds1302clk=0;//拉低时钟线，以便于数据的读入
                if(GPIO_ReadInputDataBit(GPIOC,ds1302dat)==1)//数据线此时为高电平
                {dat1=dat1|0x80;}
        }
        delay_us(1);
        GPIO_ResetBits(GPIOC,ds1302rst);
        //ds1302rst=0;
        return dat1;
}

void write_1302(uint8_t add,uint8_t dat)//向指定寄存器写入一个字节的数据
{
        GPIO_ResetBits(GPIOC,ds1302rst);
        GPIO_ResetBits(GPIOC,ds1302clk);
        //ds1302rst=0;
        //ds1302clk=0;
        delay_us(1);//略微延时
        GPIO_SetBits(GPIOC,ds1302rst);
        //ds1302rst=1;
        delay_us(2);//时间大约2us
        write_1302byte(add);
        write_1302byte(dat);
        GPIO_ResetBits(GPIOC,ds1302rst);
        GPIO_ResetBits(GPIOC,ds1302clk);
        //ds1302clk=0;
        //ds1302rst=0;
        delay_us(1);
}





int DS1302_SetTime(pContext ctx)
{
        uint8_t i=0;
        u8 time_buff[7];
        //uint8_t time_buff[7]={0,57,19,16,2,2,16};
       
        time_buff[0] = WTDecimalToBCD(ctx->datetime.tm_sec);     //秒
        time_buff[1] = WTDecimalToBCD(ctx->datetime.tm_min);     //分
        time_buff[2] = WTDecimalToBCD(ctx->datetime.tm_hour);    //时
        time_buff[3] = WTDecimalToBCD(ctx->datetime.tm_mday);    //日
        time_buff[4] = WTDecimalToBCD(ctx->datetime.tm_mon);     //月
        time_buff[5] = ctx->datetime.tm_wday;    //周
        time_buff[6] = WTDecimalToBCD(ctx->datetime.tm_year-2000);//年
       
        write_1302(0x8e,0x00);//去除写保护
        for(i=0;i<7;i++)//进行对时
        {
                write_1302(write,time_buff);
        }
        write_1302(0x8e,0x80);//加写保护       
        return 0;
}

int DS1302_GetTime(pContext ctx)
{
        u8 i;
        u8 time_buff[7];//秒分时日月周年
       
        for(i=0;i<7;i++)
        {
                time_buff=read_1302(read);
        }//读数据已经完成       
       
//        ctx->datetime.tm_sec  = BCDtoDec(time_buff+0 , 1);  //秒        //BCD转10
//        ctx->datetime.tm_min  = BCDtoDec(time_buff+1 , 1);  //分        //BCD转10
//        ctx->datetime.tm_hour = BCDtoDec(time_buff+2 , 1);  //时        //BCD转10
//        ctx->datetime.tm_mday = BCDtoDec(time_buff+3 , 1);  //日        //BCD转10
//        ctx->datetime.tm_mon  = BCDtoDec(time_buff+4 , 1);  //月        //BCD转10
//        ctx->datetime.tm_wday = BCDtoDec(time_buff+5 , 1);  //周        //BCD转10
//        ctx->datetime.tm_year = (BCDtoDec(time_buff+6 , 1)+2000);  //年        //BCD转10
//        if(ctx->datetime.tm_sec >=60) ctx->datetime.tm_sec = 0;
       
        if(time_buff[0] >=60) time_buff[0] = 0;
        ctx->datetime.tm_sec  = time_buff[0];
        ctx->datetime.tm_min  = time_buff[1];
        ctx->datetime.tm_hour = time_buff[2];
        ctx->datetime.tm_mday = time_buff[3];
        ctx->datetime.tm_mon  = time_buff[4];
        ctx->datetime.tm_wday = time_buff[5];
        ctx->datetime.tm_year = time_buff[6]+2000;
        return 0;
}





[/mw_shl_code]


4.main.c
初始化时调用DS1302_SetTime(ctx);//设置时钟的函数
之后每秒调用DS1302_GetTime(&context);//读取时钟

读到的结果是：DS1302的每个寄存器都是FF，请问问题出在哪里，谢谢各位！
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
该问题目前已经被作者或者管理员关闭, 无法添加新回复
9条回答
lijunlinv
1楼-- · 2019-07-21 01:05
本帖最后由 lijunlinv 于 2016-2-23 11:57 编辑

@八度空间     使用了你的驱动，每秒钟执行一次DS1302_Check()函数，test_value = DS1302_Read_Data(RAM_Address29 + 1);        //读出最后一个RAM地址里的数据test_value 一直是7F，不是0x55

1. ds1302.h
[mw_shl_code=c,true]                                  定义接口
                         所接的IO不一样请修改这里
           设置IO的方向请修改这里，对于不是具有准双向IO的MCU
******************************************************************************/
#define DS1302_SDA_IN()                {GPIOC->MODER&=~(3<<(1*2));GPIOC->MODER|=0<<1*2;}//PC1 输入模式
#define DS1302_SDA_OUT()        {GPIOC->MODER&=~(3<<(1*2));GPIOC->MODER|=1<<1*2;}//PC1 输出模式


#define DS1302_RST                        PCout(2)        //RST
#define DS1302_SCL                        PCout(0)        //SCL
#define DS1302_SDA                        PCout(1)        //SDA
#define DS1302_IN_SDA                PCin(1)            //读取SDA上数据用到

/******************************************************************************
                                 定义时间结构
******************************************************************************/

typedef struct
{
        u8 year;        //年
        u8 month;        //月
        u8 date;        //日
        u8 week;        //星期
        u8 hour;        //小时
        u8 minute;        //分钟
        u8 second;        //秒钟
}Time_Typedef;

extern Time_Typedef TimeValue;        //定义时间数据缓存

#define test_data                                0x55        //此数据用来检测DS1302是否存在于总线上用，可以改用其他值

/******************************************************************************
                                定义相关命令宏
******************************************************************************/

#define Clock_Address_Bass                0x80        //基地址

#define Address_year                        (Clock_Address_Bass | 0x0c)        //年
#define Address_month                        (Clock_Address_Bass | 0x08)        //月
#define Address_date                        (Clock_Address_Bass | 0x06)        //日
#define Address_week                        (Clock_Address_Bass | 0x0a)        //星期
#define Address_hour                        (Clock_Address_Bass | 0x04)        //小时
#define Address_minute                        (Clock_Address_Bass | 0x02)        //分钟
#define Address_second                        (Clock_Address_Bass | 0x00)        //秒

#define Clock_Burst                                (Clock_Address_Bass | 0x3e)        //时钟软复位

//写保护寄存器
#define Address_WP                                (Clock_Address_Bass | 0x0e)        //写保护

#define WP_Enable                                0x80        //打开写保护
#define WP_Disable                                0x00        //关闭写保护

/******************************************************************************
电源管理寄存器位描述
    bit7  bit6  bit5  bit4  bit3  bit2  bit1  bit0
        TCS3  TCS2  TCS1  TCS0   DS1   DS0   RS1   RS0

        TCSx：充电电流大小选择，值为0xa0时打开充电，其他值时关闭，DS1302默认是关闭的
        DSx：设置VCC1和VCC2之间的二极管串联数量，0x01时为串联一只二极管，0x10时为串联两只二极管，0x00或0x11时关闭充电功能
        RSx：设置限流电阻大小，0x00为开路并关闭充电功能，0x01为2K，0x10为4K，0x11为8K
******************************************************************************/
//充电管理寄存器结构
typedef struct
{
        u8 TCSx;        //充电开关
        u8 DSx;        //串联二极管
        u8 RSx;        //限流电阻
}Charge_Typedef;

extern Charge_Typedef ChargeValue;        //定义充电寄存器

//电源管理
#define Trickle_Charger_Address        (Clock_Address_Bass | 0x10)        //管理电源，主电源供电时可以设置给备用电池充电

#define Open_Trickle_Charge                0x0a
#define Close_Trickle_Charge        0x00        //设置为其他值也可以

#define One_Diode                                0x01
#define Two_Diode                                0x10
#define None_Diode                                0x00        //or 0x11，断开串联并关闭充电功能

#define Resistor_For2K                        0x01
#define Resistor_For4K                        0x10
#define Resistor_For8K                        0x11
#define None_Resistor                        0x00        //断开串联限流电阻并关闭充电功能


//RAM地址
#define RAM_Address_Bass                0xc0        //基地址

#define RAM_Address0                        (RAM_Address_Bass | 0x00)        //RAM地址 = 基地址 + 地址偏移量
#define RAM_Address1                        (RAM_Address_Bass | 0x02)
#define RAM_Address2                        (RAM_Address_Bass | 0x04)
#define RAM_Address3                        (RAM_Address_Bass | 0x06)
#define RAM_Address4                        (RAM_Address_Bass | 0x08)
#define RAM_Address5                        (RAM_Address_Bass | 0x0a)
#define RAM_Address6                        (RAM_Address_Bass | 0x0c)
#define RAM_Address7                        (RAM_Address_Bass | 0x0e)

#define RAM_Address8                        (RAM_Address_Bass | 0x10)
#define RAM_Address9                        (RAM_Address_Bass | 0x12)
#define RAM_Address10                        (RAM_Address_Bass | 0x14)
#define RAM_Address11                        (RAM_Address_Bass | 0x16)
#define RAM_Address12                        (RAM_Address_Bass | 0x18)
#define RAM_Address13                        (RAM_Address_Bass | 0x1a)
#define RAM_Address14                        (RAM_Address_Bass | 0x1c)
#define RAM_Address15                        (RAM_Address_Bass | 0x1e)

#define RAM_Address16                        (RAM_Address_Bass | 0x20)
#define RAM_Address17                        (RAM_Address_Bass | 0x22)
#define RAM_Address18                        (RAM_Address_Bass | 0x24)
#define RAM_Address19                        (RAM_Address_Bass | 0x26)
#define RAM_Address20                        (RAM_Address_Bass | 0x28)
#define RAM_Address21                        (RAM_Address_Bass | 0x2a)
#define RAM_Address22                        (RAM_Address_Bass | 0x2c)
#define RAM_Address23                        (RAM_Address_Bass | 0x2e)

#define RAM_Address24                        (RAM_Address_Bass | 0x32)
#define RAM_Address25                        (RAM_Address_Bass | 0x34)
#define RAM_Address26                        (RAM_Address_Bass | 0x36)
#define RAM_Address27                        (RAM_Address_Bass | 0x38)
#define RAM_Address28                        (RAM_Address_Bass | 0x3a)
#define RAM_Address29                        (RAM_Address_Bass | 0x3c)

#define RAM_BURST                                (RAM_Address_Bass | 0x3e)


//写秒为00并启动时钟
#define DS1302_Start_Second()        (DS1302_Write_Data(Address_second,0x00))

//写保护命令
#define        DS1302_WP_Enable()                (DS1302_Write_Data(Address_WP,WP_Enable))        //打开写保护
#define        DS1302_WP_Disable()                (DS1302_Write_Data(Address_WP,WP_Disable))        //关闭写保护

//关闭充电功能，可以直接调用
#define DS1302_Disable_Charge()        (DS1302_Write_Data(Trickle_Charger_Address,0x00))

/******************************************************************************
                                 外部功能函数
******************************************************************************/

void DS1302_GPIOInit(void);        //GPIO初始化

void DS1302_Init(Time_Typedef *Time);        //DS1302初始化

extern unsigned DS1302_Read_Data(u8 add);        //从DS1302某地址读取数据

extern void DS1302_Write_Data(u8 add,u8 dat);        //向DS1302某地址写入数据

extern u8 DS1302_Check(void);        //测试设备好坏

extern void DS1302_Charge_Manage(Charge_Typedef *CHG_dat);        //主电源对备用电池充电设置

extern void DS1302_RAM_WriteRead_Data(u8* pBuff,u8 WRadd,u8 num,u8 RW);        //DS1302内置的RAM读写操作


#endif  /* end ds1302.h */

[/mw_shl_code]

2.ds1302.c
[mw_shl_code=c,true]/******************************************************************************
                                  定义变量
******************************************************************************/

Time_Typedef TimeValue;        //定义时间数据指针

Charge_Typedef ChargeValue;        //定义充电寄存器

/******************************************************************************
* Function Name --> GPIO初始化
* Description   --> none
* Input         --> none
* Output        --> none
* Reaturn       --> none
******************************************************************************/
void DS1302_GPIOInit(void)
{
        GPIO_InitTypeDef GPIO_InitStructure;

        RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);        //开启GPIOC外设时钟
        /*        初始化GPIOC        */
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_2;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
        GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
        GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
        GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化        
        
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
        GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;//开漏输出
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
        GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
        GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化        
}
/******************************************************************************
* Function Name --> DS1302写入一个字节数据
* Description   --> none
* Input         --> dat：要写入的数据
* Output        --> none
* Reaturn       --> none
******************************************************************************/
void DS1302_Write_Byte(u8 dat)
{
        u8 i;
        DS1302_SDA_OUT();        //设置为输出口
        for(i=0;i<8;i++)
        {
                DS1302_SCL = 0;        //时钟线拉低
                if(dat & 0x01)        DS1302_SDA = 1;        //数据线放上数据，先发低位
                else        DS1302_SDA = 0;        
                dat >>= 1;        //数据右移一位
                DS1302_SCL = 1;        //发送数据，上升沿有效
        }
}
/******************************************************************************
* Function Name --> DS1302读出一个字节数据
* Description   --> none
* Input         --> none
* Output        --> none
* Reaturn       --> 读到的数据
******************************************************************************/
unsigned DS1302_Read_Byte()
{
        u8 ReData=0x00;
        u8 i;
        DS1302_SDA_IN();        //设置为输入口
        for(i=0;i<8;i++)
        {
                if(DS1302_IN_SDA == 1)
                {        ReData |= 0x80;        }        //读出一位数据是“1”
                DS1302_SCL = 0;        //时钟线拉低
                ReData >>= 1;        //数据右移一位，先读取低位，数据补“0”
                delay_us(3);
                DS1302_SCL = 1;        //上升沿读取数据
        }
        return(ReData);        //返回读取到的数据
}
/******************************************************************************
* Function Name --> 向DS1302某地址写入数据
* Description   --> none
* Input         --> add：要操作的地址
*                   dat：要写入的数据
* Output        --> none
* Reaturn       --> none
******************************************************************************/
void DS1302_Write_Data(u8 add,u8 dat)
{
        DS1302_RST = 0;        //复位脚拉低
        DS1302_SCL = 0;        //时钟线拉低
        DS1302_RST = 1;        //复位脚拉高
        DS1302_Write_Byte(add);        //写入要操作地址
        DS1302_Write_Byte(dat);        //写入数据
        DS1302_RST = 0;
        DS1302_SCL = 0;
}
/******************************************************************************
* Function Name --> 从DS1302某地址读取数据
* Description   --> none
* Input         --> add：要操作的地址
* Output        --> none
* Reaturn       --> 要读取的寄存器的数值
******************************************************************************/
unsigned DS1302_Read_Data(u8 add)
{
        u8 Temp;
        DS1302_RST = 1;
        DS1302_Write_Byte(add);        //写入要操作地址
        Temp = DS1302_Read_Byte();        //开始读取数据
        DS1302_RST = 0;
        return(Temp);        //返回读取到的数据
}
/******************************************************************************
* Function Name --> 主电源对备用电池充电设置
* Description   --> 如果备用电池接的是可充电的锂电池或者其他可充电电池的时候，
*                   可以打开DS1302的充电电路，利用主供电对电池进行充电，免的换电池的麻烦
* Input         --> *CHG_dat：寄存器控制指针
* Output        --> none
* Reaturn       --> none
******************************************************************************/
void DS1302_Charge_Manage(Charge_Typedef* CHG_dat)
{
        u8 CHG_Value;

    CHG_Value = (CHG_dat->TCSx << 4) | (CHG_dat->DSx << 2) | CHG_dat->RSx;  

        DS1302_WP_Disable();        //取消写保护
        DS1302_Write_Data(Trickle_Charger_Address,CHG_Value);
        DS1302_WP_Enable();        //打开写保护
}
/******************************************************************************
* Function Name --> DS1302内置的RAM读写操作
* Description   --> none
* Input         --> *pBuff：读写数据存放区
*                   WRadd：读写起始地址，范围在RAM_Address0 ~ RAM_Address28之间，最后一位地址有其他用途
*                   num：读写字节数据的数量，范围在1 ~ 28之间
*                   RW：读写判断位。0x00为写操作，0x01为读操作
* Output        --> none
* Reaturn       --> none
******************************************************************************/
void DS1302_RAM_WriteRead_Data(u8* pBuff,u8 WRadd,u8 num,u8 RW)
{                                                                                                                        
        u8 i;        

        if(WRadd == RAM_Address29)        return;        //要写入数据的RAM地址是最后一个，直接退出
                                                                                //因为最后一个字节是用来检测DS1302的
        if(RW == 0x00)        //写数据操作
        {
                for(i = 0;i < num;i++)
                {
                        DS1302_WP_Disable();        //取消写保护
                        DS1302_Write_Data(WRadd+(i<<1),pBuff);
                        DS1302_WP_Enable();        //打开写保护
                }
        }
        else
        {
                for(i = 0;i < num;i++)
                {
                        DS1302_WP_Disable();        //取消写保护
                        pBuff = DS1302_Read_Data(WRadd+1+(i<<1));
                        DS1302_WP_Enable();        //打开写保护
                }
        }
}
/******************************************************************************
* Function Name --> 测试设备好坏
* Description   --> 在DS1302芯片的RAM的最后一个地址写入一个数据并读出来判断
*                   与上次写入的值相等，不是第一次上电，否则则初始化时间
* Input         --> none
* Output        --> none
* Reaturn       --> 0：设备正常并不是第一次上电
*                   1：设备错误或者已损坏
******************************************************************************/
u8 DS1302_Check(void)
{
        u8 test_value;

        DS1302_WP_Disable();        //取消写保护
        test_value = DS1302_Read_Data(RAM_Address29 + 1);        //读出最后一个RAM地址里的数据
        DS1302_WP_Enable();        //打开写保护
        if(test_value == test_data)        //判断数据是否对
        {
                DPRINTF(("[DS1302]时钟正常 "));
                return 0;        //设备正常，不是第一次上电
        }
        else
        {
//                return 1;        //不是第一次上电或者设备异常               
                DPRINTF(("[DS1302]时钟异常 "));
                DS1302_WP_Disable();        //取消写保护
                DS1302_Write_Data(RAM_Address29,0x55);        //向RAM最后一个地址里写入数据
                DS1302_WP_Enable();        //打开写保护
               
                //_nop_();_nop_();
                delay_us(3);
               
                DS1302_WP_Disable();        //取消写保护
                test_value = DS1302_Read_Data(RAM_Address29 + 1);        //读出最后一个RAM地址里的数据
                DS1302_WP_Enable();        //打开写保护
               
                if(test_value == test_data)        return 0;        //设备正常，不是第一次上电
        }
        return 1;        //设备不在线或者已损坏
}
/******************************************************************************
* Function Name --> DS1302初始化
* Description   --> none
* Input         --> *Time: 时间结构体指针
* Output        --> none
* Reaturn       --> none
******************************************************************************/
void DS1302_Init(Time_Typedef* Time)
{        
        DS1302_RST = 0;
        DS1302_SCL = 0;
        DS1302_WP_Disable();        //取消写保护
        DS1302_Write_Data(Address_year,Time->year);        //写年数据
        DS1302_Write_Data(Address_week,Time->week);        //写星期数据
        DS1302_Write_Data(Address_month,Time->month);//写月数据
        DS1302_Write_Data(Address_date,Time->date);        //写日数据
        DS1302_Write_Data(Address_hour,Time->hour);        //写小时数据
        DS1302_Write_Data(Address_minute,Time->minute);        //写分钟数据
        DS1302_Write_Data(Address_second,Time->second);        //写秒数据并使时钟运行
        DS1302_WP_Enable();        //打开写保护

               
        DS1302_WP_Disable();        //取消写保护
        DS1302_Write_Data(RAM_Address29,test_data);        //向RAM最后一个地址里写入数据
        DS1302_WP_Enable();        //打开写保护
}                                                  





[/mw_shl_code]


xuyan021
2楼-- · 2019-07-21 02:25
你是用硬件IIC吗？
lijunlinv
3楼-- · 2019-07-21 06:30
 精彩回答 2  元偷偷看……
八度空间
4楼-- · 2019-07-21 12:17
lijunlinv 发表于 2016-2-23 10:53
@八度空间     使用了你的驱动，每秒钟执行一次DS1302_Check()函数，test_value = DS1302_Read_Data(RAM_Ad ...

你的移植没成功
lijunlinv
5楼-- · 2019-07-21 17:12
 精彩回答 2  元偷偷看……
ChanTselin5213
6楼-- · 2019-07-21 18:21
本帖最后由 ChanTselin5213 于 2016-3-6 13:50 编辑

@八度空间
unsigned DS1302_Read_Byte()
{
        u8 ReData=0x00;
        u8 i;
        DS1302_SDA_IN();        //设置为输入口
        for(i=0;i<8;i++)
        {
                if(DS1302_IN_SDA == 1)
                {        ReData |= 0x80;        }        //读出一位数据是“1”
                DS1302_SCL = 0;        //时钟线拉低
                ReData >>= 1;        //数据右移一位，先读取低位，数据补“0”
                delay_us(3);
                DS1302_SCL = 1;        //上升沿读取数据
        }
        return(ReData);        //返回读取到的数据
可以解释一下这部分为什么要这样写么
  if(DS1302_IN_SDA == 1)
                {        ReData |= 0x80;        }        //读出一位数据是“1”

ReData他的值是0 然后|0x80的话 那就变成10000000 这样子的话按照这个逻辑下去 ReData不就是变成0xFF（恒值）么
这个一直没看懂 卡了好几天了（因为我是把IO理解成恒为1了）
1 2 下一页

一周热门 更多>