AT21CS01 单总线存储器驱动代码

最新推荐文章于 2024-11-01 15:47:02 发布
最新推荐文章于 2024-11-01 15:47:02 发布
阅读量202 收藏
点赞数 2
文章标签： mongodb 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33435604/article/details/138597358
版权

MSP430单片机驱动


 

#include "AT21CS01.h"
#include "delay.h"
#include  <msp430x24x.h>
#include "stdio.h"
#include <string.h>

u8 at21cs01_slaveAddress=0;
u8 CommSpeed=0;

void at21cs01_delay_us (u16 us)
{         
  u16 t;
  for(t=0;t<us;t++)
  {
	 delay_us(1);
  }
}

void at21cs01_delay_ms (u16 ms)
{         
  u16 t;
  for(t=0;t<ms;t++)
  {
	 delay_ms(1);
  }
}
void at21cs01_SIO_SetHigh()
{
  AT21CS01_IO_H;
}
void at21cs01_SIO_SetLow()
{
  AT21CS01_IO_L;	
}

u8 at21cs01_SIO_GetValue()
{        
     u8 dat;     
     AT21CS01_IO_Output;
     AT21CS01_IO_L;
     delay_us(1);  
     AT21CS01_IO_Input;  
     delay_us(1);      
      if(GPIO_ReadInputDataBit == 0x40)
          dat = 1;
      else
          dat = 0;
      //delay_us(14);
     AT21CS01_IO_Output;
     AT21CS01_IO_H;     
      delay_us(14);     
      return dat;
}

u8 at21cs01_ackNack()
{
    u8 temp;
    if (CommSpeed == 0)    
    {
    //AT21CS01_IO_Output;
     AT21CS01_IO_L;
     delay_us(1);  
     AT21CS01_IO_Input;  
     delay_us(1);      
      if(GPIO_ReadInputDataBit == 0x40)
          temp = 0x00;
      else
          temp = 0x01;
      //delay_us(14);
     AT21CS01_IO_Output;
     AT21CS01_IO_H;     
      delay_us(14);
    }

    else{
            AT21CS01_IO_L;
             delay_us(4);  
             AT21CS01_IO_Input;  
             delay_us(2);      
              if(GPIO_ReadInputDataBit == 0x40)
                  temp = 0x00;
              else
                  temp = 0x01;
              delay_us(34);
             AT21CS01_IO_Output;
             AT21CS01_IO_H;     
    }

     return temp;
}

u8 at21cs01_discoveryResponse()
{
    u8 temp;
    at21cs01_SIO_SetHigh();
    at21cs01_delay_us(200);
    at21cs01_SIO_SetLow();
    at21cs01_delay_us(500);
    at21cs01_SIO_SetHigh();
    at21cs01_delay_us(20);

    at21cs01_SIO_SetLow();
    at21cs01_delay_us(1);
    at21cs01_SIO_SetHigh();
    at21cs01_delay_us(2);
    if(at21cs01_SIO_GetValue() == 0){ temp = 0x01; }
    else { temp = 0x00; }
    at21cs01_delay_us(21);
    at21cs01_SIO_SetHigh();

    CommSpeed = 0;
return temp;
}

u8 at21cs01_Init()
{
   u8 err;
   AT21CS01_IO_Output;
   AT21CS01_IO_H;
  
  err=at21cs01_discoveryResponse(); 
   return err;
}
void at21cs01_startHS()
{
     at21cs01_SIO_SetHigh();
    if (CommSpeed == 0)    
    {
    	at21cs01_delay_us(200);
    }
    else    
    {
    	at21cs01_delay_us(650);
    }
}

void at21cs01_tx1()
{
    if (CommSpeed ==0)    
    {
    	at21cs01_SIO_SetLow();
        at21cs01_delay_us(1);
        at21cs01_SIO_SetHigh();
        at21cs01_delay_us(15);
    }
    else    
    {
    	at21cs01_SIO_SetLow();
        at21cs01_delay_us(4);
        at21cs01_SIO_SetHigh();
        at21cs01_delay_us(41);
    }
}

void at21cs01_tx0()
{
    if (CommSpeed == 0)    
    {
    	at21cs01_SIO_SetLow();
    	at21cs01_delay_us(8);
        at21cs01_SIO_SetHigh();
        at21cs01_delay_us(8);
    }
    else    
    {
    	at21cs01_SIO_SetLow();
    	at21cs01_delay_us(24);
        at21cs01_SIO_SetHigh();
        at21cs01_delay_us(21);
    }
}


u8 at21cs01_txByte(u8 dataByte)
{
      u8 temp;
      AT21CS01_IO_Output;
    for (u8 ii = 0; ii < 8 ; ii++)
    {
        if (0x80  & dataByte)  
        {   
          at21cs01_tx1();
        }
        else   
        {   
          at21cs01_tx0(); 
        }
        dataByte <<= 1;
    }
    temp = at21cs01_ackNack();
    //printf("at21cs01_ackNack = %d ",temp);
    return temp;
}

u8 at21cs01_readByte ()
{

   u8 temp;
   u8 dataByte = 0x00;

    if (CommSpeed == 0)    
    {
        for (u8 ii = 0; ii < 8 ; ii++)
        {
            temp = at21cs01_SIO_GetValue();
            dataByte = (u8)((dataByte << 1) | temp);
            at21cs01_delay_us(9);
        }
    }

    else    
    {
        for (u8 ii = 0; ii < 8 ; ii++)
        {
            temp = at21cs01_SIO_GetValue();
            dataByte = (u8)((dataByte << 1) | temp);
            at21cs01_delay_us(34);
        }
    }
return dataByte;
}

u8 at21cs01_scanDeviceAddress()
{

    u8 temp=0;
    u8 address=0;
    for(u8 ii =0; ii < 8; ii++)
	{
		if(at21cs01_discoveryResponse() == 0)
		{
			at21cs01_startHS();
			temp = ii;
			temp <<= 1;
			temp |= 0xA0;
			if(at21cs01_txByte(temp) == 0x00)
			{
                          //printf("发送成功 ");
				address = ii;
				address <<= 1;
				at21cs01_startHS();
				break;
			}
		}
	}
if(1)
{
printf("Slave Address = ");
if (address == 0x00)    {printf("000b\n");}
if (address == 0x02)    {printf("001b\n");}
if (address == 0x04)    {printf("010b\n");}
if (address == 0x06)    {printf("011b\n");}
if (address == 0x08)    {printf("100b\n");}
if (address == 0x0A)    {printf("101b\n");}
if (address == 0x0C)    {printf("110b\n");}
if (address == 0x0E)    {printf("111b\n");}
}
at21cs01_slaveAddress=address;
return address;
}

u8 at21cs01_eepromwrite(u8 cmd, u8 address, u8 Data[],u8 size)
{
  unsigned char temp=0x01;
  if(size>8)return 1;
   //cmd |=at21cs01_slaveAddress;

    at21cs01_startHS();
     temp &=at21cs01_txByte(cmd);
     temp &=at21cs01_txByte(address);
    for (u8 ii = 0; ii < size; ii++)	
    {
    	temp &=at21cs01_txByte(Data[ii]);
    }
    at21cs01_startHS();
    at21cs01_delay_ms(5);
    return temp;
}

u8 at21cs01_WriteToAddress(u8 address, u8 Data[],u8 size)
{
  return at21cs01_eepromwrite(AT21CS01_CMD_EEPROMREADWRITE,address,Data,size);
}

u8 at21cs01_ReadFromAddress(u8 address, u8 *readData, u8 size)
{
        u8 temp=0x01;
	u8 cmd=0xA0;
	//cmd |=at21cs01_slaveAddress;

	at21cs01_startHS();
	temp &=at21cs01_txByte(cmd);
	temp &=at21cs01_txByte(address);
	at21cs01_startHS();
	temp &=at21cs01_txByte((u8)(cmd | 0x01));
    for (u8 ii = 0; ii < size; ii++)	
    {
        readData[ii] = at21cs01_readByte();
        if (ii < (size-1)) 
        {   
          at21cs01_tx0(); 
        }
    }
    at21cs01_tx1();
    at21cs01_startHS();
    if(1)
    {
   printf("    Data Read =");
    for (u8 ii = 0; ii < size; ii++)  
    {
        //printf(" 0x");
        printf("%d \n", readData[ii]);
    }
    printf("\n");
    }
    return temp;
}

void at21cs01_currentRead(u8 cmd, u8 *readData, u8 size)
{

	cmd |= at21cs01_slaveAddress;

	at21cs01_startHS();
	at21cs01_txByte((u8)(cmd | 0x01));
    for (u8 ii = 0; ii < size; ii++)
    {
        readData[ii] =  at21cs01_readByte();
        if (ii < (size-1))
        {   
          at21cs01_tx0();
        }
    }
    at21cs01_tx1();
    at21cs01_startHS();
    if(1)
    {
    printf("    Current Address =");
    for (u8 ii = 0; ii < size; ii++)  
    {
        //printf(" 0x");
        printf("%d", readData[ii]);
    }
    printf("\n");
    }
}

u8 at21cs01_setCommuncationSpeed(u8 speed)
{
    u8 temp;
    speed |= at21cs01_slaveAddress;

    at21cs01_startHS();
    temp = at21cs01_txByte((u8)(speed));
    at21cs01_startHS();
    if (((speed & 0xF0) == AT21CS01_SPEED_SLOW) & (temp == 0x00))
    {
    	CommSpeed = 1;
    }
    else    
    {
    	CommSpeed = 0;
    }
return temp;
}

u8 at21cs01_checkCommuncationSpeed(u8 speed)
{

    u8 temp;
    speed |= at21cs01_slaveAddress;

    at21cs01_startHS();
    temp = at21cs01_txByte((u8)(speed|0x01));
    at21cs01_startHS();

    if(temp == 0x00){
        if((speed & 0xF0) == AT21CS01_SPEED_SLOW){
            printf("    Standard Speed ACK\n");
        }
        if((speed & 0xF0) == AT21CS01_SPEED_FAST){
            printf("    High-Speed ACK\n");
        }
    }
    else    {
        if((speed & 0xF0) == AT21CS01_SPEED_SLOW){
            printf("    Standard Speed NACK\n");
        }
        if((speed & 0xF0) == AT21CS01_SPEED_FAST){
            printf("    High-Speed NACK\n");
        }
    }
return temp;
}

void at21cs01_FillWholeMemory(u8 byte)
{
	u8 data[128];
	memset(data,byte,128);
	u8 addr=0x00;
	 for(u8 z=0;z<16;z++)
         {
	    at21cs01_eepromwrite(AT21CS01_CMD_EEPROMREADWRITE,addr,data,8);
	    addr+=8;
	 }
}

void at21cs01_Connect()
{
	at21cs01_slaveAddress = at21cs01_scanDeviceAddress();
	//at21cs01_setCommuncationSpeed(at21cs01_Settings->prefCommunicationSpeed);
	//if(debug==1)
	//at21cs01_checkCommuncationSpeed(at21cs01_Settings->prefCommunicationSpeed);
}

//Ack_t AT21CS01_Reset(void)
//{
//   u8 pulse_time=0;  
//   AT21CS01_IO_Output; 
//   AT21CS01_IO_L;
//   delay_us(600);//在器件上电后或主器件复位器件（将 SI/O 线保持低电平并持续 tRESET或 tDSCHG）后
//   AT21CS01_IO_H;//主器件必须释放SI/O 线,该线随后将通过外部上拉电阻拉为高电平
//   delay_us(15); // 主器件必须再等待一段最小 tRRT 时间，然后才能请求从器件获取发现响应应答
//   AT21CS01_IO_L;//在发现响应应答序列中，首先是主器件将 SI/O 线驱动为低电平
//   delay_us(1);//T-MSDR 2~6us主器件必须继续将此线驱动为低电平并持续 tDRR
//    
//    AT21CS01_IO_Input;//主器件释放总线，准备采样从器件应答信号
//    //delay_us(1);      
//    while((GPIO_ReadInputDataBit==0)&&pulse_time<10)//这里来获得低电平的持续时间，来确定器件是否响应正常
//     {//在 tDRR 时间内，AT21CS01/11 将以并发的方式将 SI/O 驱动为低电平来进行响应
//       pulse_time++;//器件会继续将 SI/O 线驱动为低电平，总时长为 tDACK。主器件应从 tDRR 开始的 tMSDR 后对 SI/O 线的状态进行采样
//       delay_us(1);
//     }
//     delay_us(200);
//     AT21CS01_IO_Output;//释放ACK结束
//     AT21CS01_IO_H;
//     if( pulse_time >=4 )//如果器件将 SI/O 驱动为低电平的时间大于4us则说明器件响应是正常的
//      { 
//        return ACK;// ACK
//      }      
//     else
//      {
//        return NACK; //NACK
//      }
//}
//
//void AT21CS01_Start(void)
//{
//  AT21CS01_IO_Output;
//  AT21CS01_IO_H;
//  delay_us(300);
//}
//
//Ack_t AT21_init(void)
//{
//   Ack_t err;
//   AT21CS01_IO_Output;
//   AT21CS01_IO_H;
//  
//  at21cs01_discoveryResponse(); 
//   return err;
//}
//
//}
//
//


#define REVERSE8(data)									\
{														\
	data = ((data & 0xF0) >> 4) | ((data & 0x0f) << 4);	\
	data = ((data & 0xCC) >> 2) | ((data & 0x33) << 2);	\
	data = ((data & 0xAA) >> 1) | ((data & 0x55) << 1);	\
}

/*序列号最后1byte为前7byte的CRC*/
u8 CRC8_MAXIM(u8* input, u16 num)
{
	u8 data = 0, crc = 0x00;
	u16 i = 0;
	
	for (; num > 0; num--)
	{
		data = *input++;
		REVERSE8(data);
		crc = crc ^ data;
		for (i = 0; i < 8; i++)
		{
			if (crc & 0x80)
				crc = (crc << 1) ^ 0x31;
			else
				crc <<= 1;
		}
	}
	REVERSE8(crc);
	crc = crc ^ 0x00;
	return crc;
}


#ifndef __AT21CS01_H
#define __AT21CS01_H

#define  u8      unsigned char 
#define  uint     unsigned int 
#define  ulong     long int
#define  u16     unsigned short int

#define AT21CS01_SPEED_SLOW 0xD0
#define AT21CS01_SPEED_FAST 0xE0
#define AT21CS01_CMD_EEPROMREADWRITE 0xA0

#define  AT21CS01_IO_Output             P2DIR|=BIT6    //output
#define  AT21CS01_IO_Input              P2DIR&=~BIT6 ; //input

#define  AT21CS01_IO_H                  P2OUT|=BIT6   //set
#define  AT21CS01_IO_L                  P2OUT&=~BIT6  //reset

#define  GPIO_ReadInputDataBit          (P2IN&BIT6)

u8 at21cs01_Init();
u8 at21cs01_discoveryResponse();
u8 at21cs01_scanDeviceAddress();
void at21cs01_FillWholeMemory(u8 byte);
u8 at21cs01_ReadFromAddress(u8 address, u8 *readData, u8 size);
u8 at21cs01_eepromwrite(u8 cmd, u8 address, u8 Data[],u8 size);
#endif

qq_33435604
关注
【大数据之路5-1】数据仓库工具 Hive
程序员五哥
06-09 1162
大数据：历史数据，预测未来Hive 由 FaceBook 实现并开源，是基于 Hadoop 的一个数据仓库工具，可以将结构化的数据映射为一张数据库表，并提供 HQL（Hive SQL）查询 功能，底层数据存储在 HDFS 上。Hive 的本质是将 HQL 语句转换为 MapReduce 任务运行，使不熟悉 MapReduce 的用户很方便的使用 HQL 处理和计算 HDFS 上结构化的数据，适用于离线的批量数据计算。分条：基于 Hadoop：Hive 依赖于 HDFS 存储数据，Hive 将 HQL 转换成
AT21CS01资料
04-24
Low‑Voltage Operation: – AT21CS01 is self-powered via the 1.7V to 3.6V pull‑up voltage on the SI/O line – AT21CS11 is self-powered via the 2.7V to 4.5V pull‑up voltage on the SI/O line
基于STM32的AT21CS01 EEPROM驱动代码(MASTER)
XiaoMing_的博客
07-04 986
T21CS01/11 是一种 2 引脚存储器（SI/O 信号和地），其从信号引脚获取电能，从而为集成电路供电。它提供 1024 位串行电可擦除的可编程只读存储器（Electrically-Erasable Programmable Read-Only Memory，EEPROM），该存储器划分为 128 个 8 位字。...
AT21CS01/AT21CS11
08-10
AT21cs01原版和新版手册，EEprom,1K单线串行通信。最高波特率125Kbps。
AT21CS01/AT21CS11 datasheet中文版.pdf
07-09
AT21CS01/AT21CS11 datasheet中文版，完整翻译版，适合新手阅读开发。
AT21CS01/AT21CS11 datasheet
09-06
AT21CS01/AT21CS11 datasheet Single-Wire, I/O Powered 1-Kbit (128 x 8) Serial EEPROM with a Unique, Factory-Programmed 64-Bit Serial Number
霍尼韦尔STR735D-21CC1E0-AFMAA21A0-A-AHS-11C-B-11A0法兰变送器
dkl113821586的博客
04-15 764
霍尼韦尔STR735D-21CC1E0-AFMAA21A0-A-AHS-11C-B-11A0法兰变送器 STR700远传法兰变送器 简介 作为SmartLine*产品系列的成员，STR700是一 款高性能的远传法兰变送器。通过远传法兰和毛细管内的充油，实现压力的传递和优化。霍尼韦尔采用SmartLine高性能传感技术，优化了机械和液压设计，从而大幅度降低了温度对远传法兰测量的常见影响。 同类最佳的特性: 校验量程的精度高达0.075% 自动静压和温度补偿 高达100:1的量程比 易于使用和直观的显示功能 外
sql删除元组_SQL笔记
weixin_39564151的博客
11-21 4589
SQL笔记MARCUS_YANGSQL基本概念SQL（Structured Query Language）结构化查询语言，是关系数据库的标准语言特点:SELECT Sno, Grade FROM SC WHERE Cno= '3' ORDER BY Grade DESC; //从表 SC 中选取学号 Sno 和成绩 Grade 满足条件课程号 Cno=“3”按照成绩 Gradel 降序排列 综合统...
中断处理程序！
datoplay
11-19 1366
本章将深入到DOS系统内部探讨中断处理程序的内容。与其他计算机编程不一样，中断处理程序这个名词听起来就很难懂。用最简单的话来说，中断处理程序就是对应于中断激活的程序。 读者可能已发现，中断处理实际上并不是件很难办的事。事实上，在某些地方中断处理很容易管理。但是，其中仍然有些“黑洞”，一旦陷入便不能自拔。本章的信息可让你不致于迷失在黑洞中。 人们谈论中断已有好多年了。当它第一次作为...
DOS程序员手册（七）
weixin_30575309的博客
07-11 181
第11章 中断处理程序 本章将深入到DOS系统内部探讨中断处理程序的内容。与其他计算机编程不一样， 中断处理程序这个名词听起来就很难懂。用最简单的话来说，中断处理程序就是对应于中 断激活的程序。 读者可能已发现，中断处理实际上并不是件很难办的事。事实上，在某些地方中断处 理很容易管理。但是，其中仍然有些“黑洞”，一旦陷入便不能自拔。本章的信息可让你不 致于...
STM32驱动 AT21CS01 单总线eeprom 源码
05-09
STM32驱动AT21CS01单总线EEPROM源码详解 在嵌入式系统设计中，数据存储是一个至关重要的环节。AT21CS01是一款由Atmel公司生产的单总线（One-Wire）EEPROM，适用于低功耗、小体积的应用场合。STM32系列微控制器是意...
C语言-基于STM32的AT21CS01 EEPROM驱动代码(MASTER)
08-10
基于STM32的AT21CS01 EEPROM驱动代码(MASTER)。 AT21CS01/11 是一种 2 引脚存储器（SI/O 信号和地），其从信号引脚获取电能，从而为集成电路供电。它提供 1024 位串行电可擦除的可编程只读存储器（Electrically-...
【复习】原生Js实现文件上传
夏2同学的博客
07-18 5570
Demo 效果：如上图所示 起步 首先，要想实现文件上传，至少得有两个标签。 input，用来输入文件， button，用来触发文件上传函数 <div> 选择文件(可多选): <input type="file" id="f1" multiple /><br /><br /> <button type="button" id="btn-submit">上 传</button> </div&gt
04.20计组总结
LittleBerlin2的博客
04-27 8471
4、执行周期未操作的节拍安排 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4PAgXjak-1587457219410)(C:\Users\DELL\Pictures\Saved Pictures\QQ图片20200420165154 (2)].png) [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ofmD6ePD-1587457...
STM32单总线EEPROM AT21CS01驱动源码分享
综合以上内容，STM32驱动AT21CS01单总线eeprom的源码为嵌入式开发者提供了快速访问单总线EEPROM存储器的工具。通过该源码，开发者能够有效地在STM32微控制器项目中集成AT21CS01存储器，实现数据的存储与检索。这类...
mongodb指定引擎并设置内存使用大小
菠菜的专栏
10-31 212
WiredTiger 存储引擎：默认的存储引擎为 WiredTiger 存储引擎，非常适合大多数工作负载，建议用于新部署。WiredTiger 提供文档级并发模型、检查点和数据压缩等功能。In-Memory 存储引擎：In-Memory 存储引擎在 MongoDB Enterprise 中可用。它不是将文档存储在磁盘上，而是将它们保留在内存中以获得更可预测的数据延迟。虽然默认引擎就是wiredTiger 但是非常有必要知道应该怎么设置引擎。
Linux环境下Mongodb部署
杨树林er的博客
10-28 654
Linux环境下Mongodb部署，保姆级教程，从安装到部署，到配置用户，再到外部连接，手把手教你部署自己的mongoDB服务器
【MongoDB】Windows/Docker 下载安装，MongoDB Compass的基本使用、NoSQL、MongoDB的基础概念及基础用法（超详细）
最新发布
A的博客
11-01 565
NoSQL是“Not Only SQL”的缩写，代表了一类非关系型数据库，主要用于处理大规模数据存储和高并发访问。与传统的关系型数据库（如MySQL、PostgreSQL）不同，NoSQL数据库没有固定的表结构，能够灵活存储多种数据类型，包括结构化、半结构化和非结构化数据。这里可以按需选择安装MongoDB Compass,选择会稍微慢一些，但为了方便还是建议直接顺手安装。安装完会自动打开如下界面，开启你的MongoDB操作。按需选择下载,我这里下载的是Windows x64。给创建的数据库添加数据。
MongoDB 6.0 主从复制配置
yine的专栏
10-28 449
7. 将从节点添加到复制集中：在主节点的 MongoDB shell 中执行以下命令： rs.add("IP:PORT") 其中， IP:PORT 分别是从节点的主机名和端口号。可以在主节点上进行写入操作，在从节点上进行读取操作，当主节点发生故障时，从节点会自动选举一个新的主节点。4. 初始化复制集：连接到主节点的 MongoDB shell 中，并执行以下命令： rs.initiate() 此时，主节点已经启动了复制集，并成为其中的唯一成员。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值