MAX1832

admin

1. /**
   
2. 
   
3. 型号：MAX1832
   
4. 功能：单节锂离子电池充电控制器
   
5. 电压宽度：4.5V - 14V
   
6. 温度范围：-40℃ ~ +85℃
   
7. 注意事项：禁止在超过14V的电源下使用
   
8. */
   
9. #include <reg52.h>
   
10. 
    
11. // 定义芯片内部寄存器地址
    
12. #define CONTROL_REG_ADDR 0x00
    
13. #define CHARGE_REG_ADDR  0x01
    
14. 
    
15. // 定义控制寄存器位
    
16. #define CHARGE_ENABLE_BIT 0
    
17. 
    
18. // 定义充电电流
    
19. #define CHARGE_CURRENT_500MA  0b000
    
20. #define CHARGE_CURRENT_750MA  0b001
    
21. #define CHARGE_CURRENT_1000MA 0b010
    
22. #define CHARGE_CURRENT_1500MA 0b011
    
23. #define CHARGE_CURRENT_2000MA 0b100
    
24. #define CHARGE_CURRENT_2500MA 0b101
    
25. #define CHARGE_CURRENT_3000MA 0b110
    
26. #define CHARGE_CURRENT_3500MA 0b111
    
27. 
    
28. /**
    
29. 
    
30. 函数名：setMaxChargeCurrent
    
31. 功能：设置充电电流
    
32. 参数：
    
33. makefile
    
34. Copy code
    
35. current: 充电电流，取值范围为0到7
    
36. Copy code
    
37. （0代表500mA，1代表750mA，以此类推）
    
38. 返回值：无
    
39. */
    
40. void setMaxChargeCurrent(unsigned char current)
    
41. {
    
42.     unsigned char chargeRegVal = current << 5;
    
43.     // 写入充电寄存器
    
44.     // 注意：这里需要先写入充电寄存器，再写入控制寄存器
    
45.     // 因为写入充电寄存器会触发充电器启动，如果写入控制寄存器时充电器还没启动，会导致充电器不响应
    
46.     writeI2C(CHARGE_REG_ADDR, chargeRegVal);
    
47. }
    
48. /**
    
49. 
    
50. 函数名：enableCharge
    
51. 功能：启用充电
    
52. 参数：无
    
53. 返回值：无
    
54. */
    
55. void enableCharge()
    
56. {
    
57.     // 读取控制寄存器的值
    
58.     unsigned char controlRegVal = readI2C(CONTROL_REG_ADDR);
    
59.     // 启用充电位设为1
    
60.     controlRegVal |= 1 << CHARGE_ENABLE_BIT;
    
61.     // 写入控制寄存器
    
62.     writeI2C(CONTROL_REG_ADDR, controlRegVal);
    
63. }
    
64. /**
    
65. 
    
66. 函数名：disableCharge
    
67. 功能：禁用充电
    
68. 参数：无
    
69. 返回值：无
    
70. */
    
71. void disableCharge()
    
72. {
    
73.     // 读取控制寄存器的值
    
74.     unsigned char controlRegVal = readI2C(CONTROL_REG_ADDR);
    
75.     // 启用充电位设为0
    
76.     controlRegVal &= ~(1 << CHARGE_ENABLE_BIT);
    
77.     // 写入控制寄存器
    
78.     writeI2C(CONTROL_REG_ADDR, controlRegVal);
    
79. }
    
80. /**
    
81. 
    
82. 函数名：readI2C
    
83. 功能：从I2C总线读取一个字节
    
84. 参数：
    
85. makefile
    
86. Copy code
    
87. addr: 要读取的设备地址
    
88. 返回值：读取到的*/
    
89. unsigned char readI2C(unsigned char addr)
    
90. {
    
91.     unsigned char val;
    
92.     // 启动I2C总线
    
93.     startI2C();
    
94.     // 发送设备地址和读取命令
    
95.     sendI2C(addr | 0x01);
    
96.     // 读取数据
    
97.     val = readByteI2C();
    
98.     // 停止I2C总线
    
99.     stopI2C();
    
100.     return val;
     
101. }
     
102. 
     
103. /**
     
104. 
     
105. 函数名：writeI2C
     
106. 功能：向I2C总线写入一个字节
     
107. 参数：
     
108. makefile
     
109. Copy code
     
110. addr: 要写入的设备地址
     
111. kotlin
     
112. Copy code
     
113. val: 要写入的数据
     
114. 返回值：无
     
115. */
     
116. void writeI2C(unsigned char addr, unsigned char val)
     
117. {
     
118.     // 启动I2C总线
     
119.     startI2C();
     
120.     // 发送设备地址和写入命令
     
121.     sendI2C(addr & 0xFE);
     
122.     // 发送数据
     
123.     sendByteI2C(val);
     
124.     // 停止I2C总线
     
125.     stopI2C();
     
126. }
     
127. /**
     
128. 
     
129. 函数名：startI2C
     
130. 功能：启动I2C总线
     
131. 参数：无
     
132. 返回值：无
     
133. */
     
134. void startI2C()
     
135. {
     
136.     // 启动总线
     
137.     SDA = 1;
     
138.     SCL = 1;
     
139.     delayI2C();
     
140.     SDA = 0;
     
141.     delayI2C();
     
142.     SCL = 0;
     
143. }
     
144. /**
     
145. 
     
146. 函数名：stopI2C
     
147. 功能：停止I2C总线
     
148. 参数：无
     
149. 返回值：无
     
150. */
     
151. void stopI2C()
     
152. {
     
153.     // 停止总线
     
154.     SDA = 0;
     
155.     SCL = 1;
     
156.     delayI2C();
     
157.     SDA = 1;
     
158.     delayI2C();
     
159. }
     
160. /**
     
161. 
     
162. 函数名：sendI2C
     
163. 功能：向I2C总线发送一个字节的设备地址或命令
     
164. 参数：
     
165. java
     
166. Copy code
     
167. byte: 要发送的字节
     
168. 返回值：无
     
169. */
     
170. void sendI2C(unsigned char byte)
     
171. {
     
172.     // 发送8位数据
     
173.     unsigned char i;
     
174.     for (i = 0; i < 8; i++) {
     
175.         SDA = byte & (1 << (7 - i)) ? 1 : 0;
     
176.         delayI2C();
     
177.         SCL = 1;
     
178.         delayI2C();
     
179.         SCL = 0;
     
180.     }
     
181.     // 等待应答
     
182.     SDA = 1;
     
183.     delayI2C();
     
184.     SCL = 1;
     
185.     while (SDA)
     
186.         ;
     
187.     SCL = 0;
     
188. }
     
189. /**
     
190. 
     
191. 函数名：sendByteI2C
     
192. 功能：向I2C总线发送一个字节的数据
     
193. 参数：
     
194. java
     
195. Copy code
     
196. byte: 要发送的字节
     
197. 返回值：无
     
198. */
     
199. void sendByteI2C(unsigned char byte)
     
200. {
     
201.     // 发送8位数据
     
202.     unsigned char i;
     
203.     for (i = 0; i < 8; i++) {
     
204.         SDA = byte & (1 << (7 - i)) ? 1 : 0;
     
205.         delayI2C();
     
206.         SCL = 1;
     
207.         delayI2C();
     
208.         SCL = 0;
     
209.     }
     
210.     // 等待应答
     
211.     SDA = 1;
     
212.     delayI2C();
     
213.     SCL = 1;
     
214.     while (SDA)
     
215.         ;
     
216.     SCL = 0;
     
217. }
     
218. 
     
219. /**
     
220. 
     
221. 函数名：readByteI2C
     
222. 功能：从I2C总线读取一个字节的数据
     
223. 参数：无
     
224. 返回值：读取到的数据
     
225. */
     
226. unsigned char readByteI2C()
     
227. {
     
228.     // 读取8位数据
     
229.     unsigned char i, val = 0;
     
230.     for (i = 0; i < 8; i++) {
     
231.         SCL = 1;
     
232.         delayI2C();
     
233.         val |= SDA ? (1 << (7 - i)) : 0;
     
234.         SCL = 0;
     
235.         delayI2C();
     
236.     }
     
237.     // 发送应答信号
     
238.     SDA = 0;
     
239.     delayI2C();
     
240.     SCL = 1;
     
241.     delayI2C();
     
242.     SCL = 0;
     
243.     SDA = 1;
     
244.     return val;
     
245. }
     
246. /**
     
247. 
     
248. 函数名：delayI2C
     
249. 功能：I2C总线的延迟函数
     
250. 参数：无
     
251. 返回值：无
     
252. */
     
253. void delayI2C()
     
254. {
     
255.     // 延迟一段时间
     
256.     unsigned int i;
     
257.     for (i = 0; i < 200; i++)
     
258.         ;
     
259. }
     
260. /**
     
261. 
     
262. 函数名：main
     
263. 功能：主函数
     
264. 参数：无
     
265. 返回值：无
     
266. */
     
267. void main()
     
268. {
     
269.     // 初始化外部芯片
     
270.     initMAX1832();
     
271.     // 读取外部芯片的状态
     
272.     unsigned char status = readMAX1832();
     
273.     // 判断是否超过限制电压
     
274.     if (status & 0x08) {
     
275.         // 警告
     
276.         alertMAX1832();
     
277.     }
     
278. }
     
279. /**
     
280. 
     
281. 函数名：initMAX1832
     
282. 功能：初始化MAX1832外部芯片
     
283. 参数：无
     
284. 返回值：无
     
285. */
     
286. void initMAX1832()
     
287. {
     
288.     // 配置P0口为输出
     
289.     P0 = 0x00;
     
290.     // 向MAX1832芯片写入配置寄存器
     
291.     writeI2C(MAX1832_ADDR, MAX1832_CFG);
     
292. }
     
293. /**
     
294. 
     
295. 函数名：readMAX1832
     
296. 功能：读取MAX1832外部芯片的状态寄存器
     
297. 参数：无
     
298. 返回值：状态寄存器的值
     
299. */
     
300. unsigned char readMAX1832()
     
301. {
     
302.     // 从MAX1832芯片读取状态寄存器
     
303.     return readI2C(MAX1832_ADDR);
     
304. }
     
305. /**
     
306. 
     
307. 函数名：alertMAX1832
     
308. 功能：警告超过限制电压
     
309. 参数：无
     
310. 返回值：无
     
311. */
     
312. void alertMAX1832()
     
313. {
     
314.     // 向P0口输出高电平
     
315.     P0 = 0xFF;
     
316.     // 延迟500ms
     
317.     delay(500);
     
318.     // 向P0口输出低电平
     
319.     P0 = 0x00;
     
320. }

复制代码