devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

USB转I2C芯片操作EEPROM--CH347应用

作者：羊村懒王 | 2024-02-14 21:00:53

赞

踩

usb转i2c

USB转I2C芯片简介

        高速USB转接芯片CH347是一款集成480Mbps高速USB接口、JTAG接口、SPI接口、I2C接口、异步UART串口、GPIO接口等多种硬件接口的转换芯片。

接口示意图：

CH347-I2C接口特点

  • USB传输采用USB2.0高速（480Mbps）
  • 工作在 Host/Master主机模式；
  • 硬件信号：SCL、SDA；
  • 支持4种传输速度：低速20KHz、标准100KHz、快速400KHz、高速750KHz；
  • 支持I2C时序参数调节；
  • 提供计算机端驱动程序和USB转I2C函数库，支持二次开发

使用芯片准备工作

选择CH347工作模式

        CH347包括CH347T和CH347F两款型号，CH347T芯片使用I2C功能需要额外模式选择，芯片在复位时，会根据DTR1（CFG0）和RTS1（CFG1）引脚的电平状态配置其工作模式，各工作模式及功能说明如下：

工作模式

模式说明

CFG0

CFG1

Mode0

480Mbps高速USB转双UART（Baudrate最高9Mbps）

1

1

Mode1

480Mbps高速USB转UART+SPI+I2C（厂商驱动模式）

0

1

Mode2

480Mbps高速USB转UART+SPI+I2C（系统HID驱动模式）

1

0

Mode3

480Mbps高速USB转UART+JTAG（厂商驱动模式）

0

0

        CH347可使用I2C的模式有两种，其区别在Mode1需要安装厂商驱动，Mode3可以使用系统内置HID驱动无需额外安装，只需在编程时调用CH347动态库进行软件编程即可，本博客使用Mode1来进行操作。

        CH347F芯片不需要进行额外的模式选择，该型号默认支持所有接口功能。

驱动安装

window驱动安装

        从WCH官网下载CH347转SPI/I2C/JTAG/GPIO驱动：CH341PAR.EXE - 南京沁恒微电子股份有限公司

        驱动下载后进行一次安装，后续即可实现系统“免驱”效果无需二次安装。未插入设备时安装会显示“驱动预安装成功”，此时驱动已经正常安装，硬件即插即用。

        Windows驱动通过微软数字签名认证，支持32/64位 Windows 11/10/8.1/8/7/VISTA/XP/2000，SERVER 2019/2016/2012/2008/2003等系统，无需担心Windows不同系统兼容性问题。

        官方同时提供驱动资源包CH341PAR.ZIP - 南京沁恒微电子股份有限公司，可将驱动安装文件打包至成熟产品一齐发布，且支持无界面安装操作，可通过软件编程调用命令行操作，只需执行“SETUP /S”命令即可静默驱动安装。

        点击安装之后，等待弹出安装成功窗口后点击确定即可。

Linux驱动安装

        下载Linux驱动、应用库和软件包：CH341PAR_LINUX.ZIP - 南京沁恒微电子股份有限公司USB转JTAG/SPI/I2C/并口/GPIO等接口的Linux设备驱动程序，支持CH341的USB转SPI/I2C/EPP并口/MEM并口等，支持CH347的480Mbps高速USB转JTAG/SPI/I2C/GPIO等，支持32/64位操作系统。icon-default.png?t=N7T8https://www.wch.cn/downloads/CH341PAR_LINUX_ZIP.html         按照压缩包内的说明资料使用驱动和其他资料。

        1、执行 sudo make install 可自动编译与安装驱动；

        2、插入USB设备可查看到生成前缀为ch34x_pis的设备节点。

使用USB操作EEPROM

        本次操作CH347开发板板载EEPROM：24LC515H。

        除此之外，CH347也可操作AT24xxx、M24xxx等等EEPROM

调用函数

        WCH提供了一套公用的库函数接口，即Windows&Linux平台接口函数名称与参数一致，其库函数接口特性如下：

        操作SPI、I2C、GPIO等的接口在任何工作模式下都可使用同一API，在进行软件编写时，只需调用接口完成代码操作逻辑而不用关注当前硬件工作模式。提供插拔检测函数可动态监测设备插拔信息，更方便进行设备管理。

        具体详细内容可参考官方开发手册：CH347EVT.ZIP - 南京沁恒微电子股份有限公司 【目录：CH347EVT\EVT\PUB\CH347应用开发手册.PDF】

  1. /***************插拔监测函数************/
  2. BOOL    WINAPI  CH347SetDeviceNotify(                                           // 设定设备事件通知程序
  3.                                      ULONG                  iIndex,             // 指定设备序号,0对应第一个设备
  4.                                      PCHAR                  iDeviceID,          // 可选参数,指向字符串,指定被监控的设备的ID,字符串以\0终止
  5.                                      mPCH347_NOTIFY_ROUTINE iNotifyRoutine );   // 指定设备事件回调程序,为NULL则取消事件通知,否则在检测到事件时调用该程序
  6. /********IIC接口函数通用于Mode1/2***********/
  7. // 设置串口流模式
  8. BOOL    WINAPI  CH347I2C_Set(ULONG          iIndex,  // 指定设备序号
  9.                              ULONG          iMode );  // 指定模式,见下行
  10. // 位1-位0: I2C接口速度/SCL频率, 00=低速/20KHz,01=标准/100KHz(默认值),10=快速/400KHz,11=高速/750KHz
  11. // 其它保留,必须为0
  12.  
  13. // 设置硬件异步延时,调用后很快返回,而在下一个流操作之前延时指定毫秒数
  14. BOOL    WINAPI  CH347I2C_SetDelaymS(ULONG           iIndex,       // 指定设备序号
  15.                                     ULONG           iDelay ) ;    // 指定延时的毫秒数
  16.  
  17.  // 处理I2C数据流,2线接口,时钟线为SCL引脚,数据线为SDA引脚
  18. BOOL    WINAPI  CH347StreamI2C( ULONG           iIndex,        // 指定设备序号
  19.                                 ULONG           iWriteLength,  // 准备写出的数据字节数
  20.                                 PVOID           iWriteBuffer,  // 指向一个缓冲区,放置准备写出的数据,首字节通常是I2C设备地址及读写方向位
  21.                                 ULONG           iReadLength,   // 准备读取的数据字节数
  22.                                 PVOID           oReadBuffer ); // 指向一个缓冲区,返回后是读入的数据
  23. #ifndef _CH341_DLL_H
  24. typedef enum    _EEPROM_TYPE {// EEPROM型号
  25.     ID_24C01,
  26.     ID_24C02,
  27.     ID_24C04,
  28.     ID_24C08,
  29.     ID_24C16,
  30.     ID_24C32,
  31.     ID_24C64,
  32.     ID_24C128,
  33.     ID_24C256,
  34.     ID_24C512,
  35.     ID_24C1024,
  36.     ID_24C2048,
  37.     ID_24C4096
  38. } EEPROM_TYPE;
  39. #endif
  40.  
  41. // 从EEPROM中读取数据块,速度约56K字节
  42. BOOL    WINAPI  CH347ReadEEPROM(ULONG           iIndex,     // 指定设备序号
  43.                                 EEPROM_TYPE     iEepromID,  // 指定EEPROM型号
  44.                                 ULONG           iAddr,      // 指定数据单元的地址
  45.                                 ULONG           iLength,    // 准备读取的数据字节数
  46.                                 PUCHAR          oBuffer );  // 指向一个缓冲区,返回后是读入的数据
  47. // 向EEPROM中写入数据块
  48. BOOL    WINAPI  CH347WriteEEPROM(ULONG          iIndex,     // 指定设备序号
  49.                                  EEPROM_TYPE    iEepromID,  // 指定EEPROM型号
  50.                                  ULONG          iAddr,      // 指定数据单元的地址
  51.                                  ULONG          iLength,    // 准备写出的数据字节数
  52.                                  PUCHAR         iBuffer );  // 指向一个缓冲区,放置准备写出的数据

操作流程

代码示例

Windows例程

        可参考官方开发资料：CH347EVT.ZIP - 南京沁恒微电子股份有限公司 【目录：CH347EVT\EVT\TOOLS\CH347Demo】

        界面读写示例如下：

Linux例程

可参考如下代码，链接地址：CH341PAR_LINUX.ZIP - 南京沁恒微电子股份有限公司USB转JTAG/SPI/I2C/并口/GPIO等接口的Linux设备驱动程序，支持CH341的USB转SPI/I2C/EPP并口/MEM并口等，支持CH347的480Mbps高速USB转JTAG/SPI/I2C/GPIO等，支持32/64位操作系统。icon-default.png?t=N7T8https://www.wch.cn/downloads/CH341PAR_LINUX_ZIP.html

  1. /*
  2.  * ch347 application demo
  3.  *
  4.  * Copyright (C) 2023 Nanjing Qinheng Microelectronics Co., Ltd.
  5.  * Web:      http://wch.cn
  6.  * Author:   WCH <tech@wch.cn>
  7.  *
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * Cross-compile with cross-gcc -I /path/to/cross-kernel/include
  14.  *
  15.  * V1.0 - initial version
  16.  * V1.1 - add operation for HID mode
  17.  * V1.2 - add serial port operation in HID and TTY mode
  18.  * V1.3 - update with new library
  19.  * V1.4 - add gpio interrupt funciton, update with new library,
  20.  *      - support more SPI and I2C stretching
  21.  *      - support I2C clock stretch
  22.  */
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include <string.h>
  26. #include <stdbool.h>
  27. #include <stdint.h>
  28. #include <unistd.h>
  29. #include <sys/ioctl.h>
  30. #include <sys/types.h>
  31. #include <sys/time.h>
  32. #include <sys/stat.h>
  33. #include <fcntl.h>
  34. #include <time.h>
  35. #include <endian.h>
  36. #include <linux/hidraw.h>
  37.  
  38. #include "ch347_lib.h"
  39.  
  40. #define CMD_FLASH_SECTOR_ERASE 0x20
  41. #define CMD_FLASH_BYTE_PROG    0x02
  42. #define CMD_FLASH_READ	       0x03
  43. #define CMD_FLASH_RDSR	       0x05
  44. #define CMD_FLASH_WREN	       0x06
  45. #define CMD_FLASH_JEDEC_ID     0x9F
  46.  
  47. #define SPI_FLASH_PerWritePageSize 256
  48.  
  49. typedef enum _CH347FUNCTYPE {
  50. 	FUNC_UART = 0,
  51. 	FUNC_SPI_I2C_GPIO,
  52. 	FUNC_JTAG_GPIO,
  53. 	FUNC_SPI_I2C_JTAG_GPIO,
  54. } CH347FUNCTYPE;
  55.  
  56. struct ch34x {
  57. 	int fd;
  58. 	char version[100];
  59. 	CHIP_TYPE chiptype;
  60. 	uint32_t dev_id;
  61. 	CH347FUNCTYPE functype;
  62. };
  63.  
  64. static struct ch34x ch347device;
  65.  
  66. bool CH347_SPI_Init()
  67. {
  68. 	bool ret;
  69. 	mSpiCfgS SpiCfg = { 0 };
  70.  
  71. 	/* set spi interface in [mode3] & [15MHz] & [MSB] & output [0xFF] by default */
  72. 	SpiCfg.iMode = 3;
  73. 	SpiCfg.iSpiSpeedHz = 30e6;
  74. 	SpiCfg.iByteOrder = 1;
  75. 	SpiCfg.iSpiOutDefaultData = 0xFF;
  76. 	SpiCfg.iChipSelect = 0x80;
  77.  
  78. 	/* init spi interface */
  79. 	ret = CH347SPI_Init(ch347device.fd, &SpiCfg);
  80. 	if (!ret) {
  81. 		printf("Failed to init SPI interface.\n");
  82. 		return false;
  83. 	}
  84.  
  85. 	return true;
  86. }
  87.  
  88. bool CH347_I2C_Init()
  89. {
  90. 	bool ret;
  91. 	int iMode;
  92.  
  93. 	/* set i2c interface in 750KHZ */
  94. 	iMode = 0x03;
  95.  
  96. 	/* init i2c interface */
  97. 	ret = CH347I2C_Set(ch347device.fd, iMode);
  98. 	if (!ret) {
  99. 		printf("Failed to init I2C interface.\n");
  100. 		return false;
  101. 	}
  102.  
  103. 	return true;
  104. }
  105.  
  106. bool Flash_ID_Read()
  107. {
  108. 	int iChipSelect;
  109. 	int iLength;
  110. 	uint8_t ioBuffer[4] = { 0 };
  111. 	uint32_t Flash_ID;
  112.  
  113. 	iChipSelect = 0x80;
  114. 	iLength = 4;
  115. 	ioBuffer[0] = CMD_FLASH_JEDEC_ID;
  116. 	memset(ioBuffer + 1, 0xFF, 3);
  117.  
  118. 	if (CH347SPI_WriteRead(ch347device.fd, false, iChipSelect, iLength, ioBuffer) == false)
  119. 		return false;
  120. 	else {
  121. 		ioBuffer[0] = 0x00;
  122. 		memcpy(&Flash_ID, ioBuffer, 4);
  123. 	}
  124. 	Flash_ID = htole32(Flash_ID);
  125. 	printf("Read flash ID: 0x%x.\n", Flash_ID);
  126.  
  127. 	if (Flash_ID == 0x000000 || Flash_ID == 0xffffff00) {
  128. 		printf("Read flash ID error.\n");
  129. 		return false;
  130. 	}
  131.  
  132. 	return true;
  133. }
  134.  
  135. unsigned int Flash_Block_Read(unsigned int address, uint8_t *pbuf, unsigned int len)
  136. {
  137. 	int iChipSelect;
  138. 	int iLength;
  139. 	int oLength;
  140. 	uint8_t ioBuffer[8192] = { 0 };
  141.  
  142. 	iChipSelect = 0x80;
  143. 	iLength = 0x04;
  144. 	oLength = len;
  145. 	ioBuffer[0] = CMD_FLASH_READ;
  146. 	ioBuffer[1] = (uint8_t)(address >> 16);
  147. 	ioBuffer[2] = (uint8_t)(address >> 8);
  148. 	ioBuffer[3] = (uint8_t)(address);
  149.  
  150. 	if (!CH347SPI_Read(ch347device.fd, false, iChipSelect, iLength, &oLength, ioBuffer)) {
  151. 		printf("Flash_Block_Read read %d bytes failed.\n", len);
  152. 		return 0;
  153. 	} else
  154. 		memcpy(pbuf, ioBuffer, oLength);
  155.  
  156. 	return oLength;
  157. }
  158.  
  159. bool Flash_Block_Read_Test()
  160. {
  161. 	double UseT;
  162. 	uint32_t DataLen, FlashAddr, i;
  163. 	uint8_t ioBuffer[8192] = { 0 };
  164. 	char FmtStr1[8 * 1024 * 3 + 16] = "";
  165.  
  166. 	static struct timeval t1, t2;
  167. 	int delta_sec, delta_usec;
  168.  
  169. 	FlashAddr = 0x00;
  170. 	DataLen = 0x500;
  171.  
  172. 	gettimeofday(&t1, NULL);
  173. 	DataLen = Flash_Block_Read(FlashAddr, ioBuffer, DataLen);
  174. 	if (DataLen <= 0) {
  175. 		printf("\tFlash Read: Addr[0x%x] read %d bytes failed.\n", FlashAddr, DataLen);
  176. 		return false;
  177. 	}
  178. 	gettimeofday(&t2, NULL);
  179.  
  180. 	delta_sec = t2.tv_sec - t1.tv_sec;
  181. 	delta_usec = t2.tv_usec - t1.tv_usec;
  182. 	UseT = (float)delta_sec + (float)delta_usec / 1000000;
  183.  
  184. 	printf("\tFlash Read: Addr[0x%x] read %d bytes in %.3f seconds.\n", FlashAddr, DataLen, UseT);
  185. 	for (i = 0; i < DataLen; i++)
  186. 		sprintf(&FmtStr1[strlen(FmtStr1)], "%02x ", ioBuffer[i]);
  187. 	printf("\nRead: \n%s\n\n", FmtStr1);
  188.  
  189. 	return true;
  190. }
  191.  
  192. bool Flash_Write_Enable()
  193. {
  194. 	int iChipSelect;
  195. 	int iLength;
  196. 	uint8_t ioBuffer;
  197.  
  198. 	iChipSelect = 0x80;
  199. 	iLength = 1;
  200. 	ioBuffer = CMD_FLASH_WREN;
  201.  
  202. 	return CH347SPI_WriteRead(ch347device.fd, false, iChipSelect, iLength, &ioBuffer);
  203. }
  204.  
  205. bool Flash_Wait()
  206. {
  207. 	int iChipSelect;
  208. 	int iLength;
  209. 	uint8_t ioBuffer[2];
  210. 	uint8_t status;
  211. 	int retry_times = 1000;
  212.  
  213. 	iChipSelect = 0x80;
  214. 	iLength = 2;
  215.  
  216. 	do {
  217. 		ioBuffer[0] = CMD_FLASH_RDSR;
  218. 		if (CH347SPI_WriteRead(ch347device.fd, false, iChipSelect, iLength, ioBuffer) == false)
  219. 			return false;
  220. 		status = ioBuffer[1];
  221. 		usleep(100);
  222. 	} while ((status & 0x01) && (retry_times--));
  223.  
  224. 	if ((status & 0x01) == 0)
  225. 		return true;
  226. 	else
  227. 		return false;
  228. }
  229.  
  230. bool Flash_Sector_Erase(uint32_t StartAddr)
  231. {
  232. 	int iChipSelect;
  233. 	int iLength;
  234. 	uint8_t ioBuffer[4];
  235.  
  236. 	if (Flash_Write_Enable() == false)
  237. 		return false;
  238.  
  239. 	iChipSelect = 0x80;
  240. 	iLength = 4;
  241. 	ioBuffer[0] = CMD_FLASH_SECTOR_ERASE;
  242. 	ioBuffer[1] = (uint8_t)(StartAddr >> 16 & 0xff);
  243. 	ioBuffer[2] = (uint8_t)(StartAddr >> 8 & 0xf0);
  244. 	ioBuffer[3] = 0x00;
  245.  
  246. 	if (CH347SPI_WriteRead(ch347device.fd, false, iChipSelect, iLength, ioBuffer) == false)
  247. 		return false;
  248.  
  249. 	if (Flash_Wait() == false)
  250. 		return false;
  251.  
  252. 	return true;
  253. }
  254.  
  255. bool W25X_Flash_Write_Page(uint8_t *pBuf, uint32_t address, uint32_t len)
  256. {
  257. 	int iChipSelect;
  258. 	int iLength;
  259. 	uint8_t ioBuffer[8192];
  260.  
  261. 	if (!Flash_Write_Enable())
  262. 		return false;
  263.  
  264. 	iChipSelect = 0x80;
  265. 	iLength = len + 4;
  266. 	ioBuffer[0] = CMD_FLASH_BYTE_PROG;
  267. 	ioBuffer[1] = (uint8_t)(address >> 16);
  268. 	ioBuffer[2] = (uint8_t)(address >> 8);
  269. 	ioBuffer[3] = (uint8_t)address;
  270. 	memcpy(&ioBuffer[4], pBuf, len);
  271.  
  272. 	if (CH347SPI_Write(ch347device.fd, false, iChipSelect, iLength, SPI_FLASH_PerWritePageSize + 4, ioBuffer) ==
  273. 	    false)
  274. 		return false;
  275.  
  276. 	memset(ioBuffer, 0, sizeof(uint8_t) * len);
  277.  
  278. 	if (!Flash_Wait())
  279. 		return false;
  280.  
  281. 	return true;
  282. }
  283.  
  284. bool Flash_Block_Write()
  285. {
  286. 	int ret;
  287. 	int i = 0;
  288. 	uint32_t DataLen, FlashAddr, BeginAddr, NumOfPage, NumOfSingle;
  289. 	uint8_t ioBuffer[0x500] = { 0 };
  290. 	uint8_t *pbuf = ioBuffer;
  291. 	double UseT;
  292.  
  293. 	static struct timeval t1, t2;
  294. 	int delta_sec, delta_usec;
  295.  
  296. 	/* write flash from addr 0 */
  297. 	FlashAddr = 0x00;
  298. 	BeginAddr = FlashAddr;
  299. 	DataLen = 0x500;
  300.  
  301. 	for (i = 0; i < DataLen; i++)
  302. 		ioBuffer[i] = i;
  303.  
  304. 	NumOfPage = DataLen / SPI_FLASH_PerWritePageSize;
  305. 	NumOfSingle = DataLen % SPI_FLASH_PerWritePageSize;
  306.  
  307. 	/* caculate flash write time */
  308. 	gettimeofday(&t1, NULL);
  309. 	while (NumOfPage--) {
  310. 		ret = W25X_Flash_Write_Page(pbuf, FlashAddr, SPI_FLASH_PerWritePageSize);
  311. 		if (ret == false)
  312. 			goto exit;
  313. 		pbuf += SPI_FLASH_PerWritePageSize;
  314. 		FlashAddr += SPI_FLASH_PerWritePageSize;
  315. 	}
  316. 	if (NumOfSingle) {
  317. 		ret = W25X_Flash_Write_Page(pbuf, FlashAddr, NumOfSingle);
  318. 		if (ret == false)
  319. 			goto exit;
  320. 	}
  321. 	gettimeofday(&t2, NULL);
  322.  
  323. 	delta_sec = t2.tv_sec - t1.tv_sec;
  324. 	delta_usec = t2.tv_usec - t1.tv_usec;
  325. 	UseT = ((float)delta_sec + (float)delta_usec / 1000000);
  326.  
  327. 	printf("\tFlash Write: Addr[0x%x] write %d bytes in %.3f seconds.\n", BeginAddr, DataLen, UseT / 1000);
  328.  
  329. 	return true;
  330.  
  331. exit:
  332. 	printf("\tFlash Write: Addr [0x%x] write %d bytes failed.\n", BeginAddr, DataLen);
  333. 	return false;
  334. }
  335.  
  336. bool EEPROM_Read()
  337. {
  338. 	bool ret = false;
  339. 	EEPROM_TYPE eeprom;
  340. 	int iAddr;
  341. 	int iLength;
  342. 	int i;
  343. 	uint8_t oBuffer[256] = { 0 };
  344.  
  345. 	eeprom = ID_24C02;
  346. 	iAddr = 0;
  347. 	iLength = 256;
  348.  
  349. 	ret = CH347ReadEEPROM(ch347device.fd, eeprom, 0, iLength, oBuffer);
  350. 	if (ret == false)
  351. 		goto exit;
  352.  
  353. 	printf("\nRead EEPROM data:\n");
  354. 	for (i = 0; i < iLength; i++) {
  355. 		printf("%02x ", oBuffer[i]);
  356. 		if (((i + 1) % 10) == 0)
  357. 			putchar(10);
  358. 	}
  359. 	putchar(10);
  360.  
  361. exit:
  362. 	return ret;
  363. }
  364.  
  365. bool EEPROM_Write()
  366. {
  367. 	bool ret = false;
  368. 	EEPROM_TYPE eeprom;
  369. 	int iAddr;
  370. 	int iLength;
  371. 	int i;
  372. 	uint8_t iBuffer[256] = { 0 };
  373.  
  374. 	eeprom = ID_24C02;
  375. 	iAddr = 0;
  376. 	iLength = 256;
  377. 	for (i = 0; i < 256; i++)
  378. 		iBuffer[i] = i;
  379.  
  380. 	printf("\nWrite EEPROM data:\n");
  381. 	ret = CH347WriteEEPROM(ch347device.fd, eeprom, iAddr, iLength, iBuffer);
  382. 	if (ret == false)
  383. 		goto exit;
  384.  
  385. 	for (i = 0; i < iLength; i++) {
  386. 		printf("%02x ", iBuffer[i]);
  387. 		if (((i + 1) % 10) == 0)
  388. 			putchar(10);
  389. 	}
  390. 	putchar(10);
  391.  
  392. exit:
  393. 	return ret;
  394. }
  395.  
  396. void ch34x_demo_flash_operate()
  397. {
  398. 	bool ret = false;
  399.  
  400. 	ret = CH347_SPI_Init();
  401. 	if (ret == false) {
  402. 		printf("Failed to init CH347 SPI interface.\n");
  403. 		return;
  404. 	}
  405. 	printf("CH347 SPI interface init succeed.\n");
  406.  
  407. 	/* read flash ID */
  408. 	ret = Flash_ID_Read();
  409. 	if (!ret) {
  410. 		printf("Failed to read flash ID.\n");
  411. 		return;
  412. 	}
  413.  
  414. 	/* read flash block data */
  415. 	ret = Flash_Block_Read_Test();
  416. 	if (!ret) {
  417. 		printf("Failed to read flash.\n");
  418. 		return;
  419. 	}
  420.  
  421. 	/* erase flash sector data */
  422. 	ret = Flash_Sector_Erase(0x00);
  423. 	if (!ret) {
  424. 		printf("Failed to erase flash.\n");
  425. 		return;
  426. 	}
  427. 	printf("Erase one sector from Addr[0x%x] of flash succeed.\n", 0x00);
  428.  
  429. 	/* write flash block data */
  430. 	ret = Flash_Block_Write();
  431. 	if (!ret) {
  432. 		printf("Failed to write flash.\n");
  433. 		return;
  434. 	}
  435.  
  436. 	/* read flash block data */
  437. 	ret = Flash_Block_Read_Test();
  438. 	if (!ret) {
  439. 		printf("Failed to read flash.\n");
  440. 		return;
  441. 	}
  442. }
  443.  
  444. void ch34x_demo_eeprom_operate()
  445. {
  446. 	bool ret = false;
  447.  
  448. 	ret = CH347_I2C_Init();
  449. 	if (!ret) {
  450. 		printf("Failed to init CH347 I2C.\n");
  451. 		return;
  452. 	}
  453. 	printf("CH347 I2C interface init succeed.\n");
  454.  
  455. 	ret = EEPROM_Read();
  456. 	if (!ret) {
  457. 		printf("Failed to read eeprom.\n");
  458. 		return;
  459. 	}
  460.  
  461. 	ret = EEPROM_Write();
  462. 	if (!ret) {
  463. 		printf("Failed to write eeprom.\n");
  464. 		return;
  465. 	}
  466.  
  467. 	ret = EEPROM_Read();
  468. 	if (!ret) {
  469. 		printf("Failed to read eeprom.\n");
  470. 		return;
  471. 	}
  472. }
  473.  
  474. void ch34x_demo_jtag_operate()
  475. {
  476. 	int i;
  477. 	int oReadLength;
  478. 	uint8_t retue[32] = { 0 };
  479. 	uint8_t IDCODE[4096] = { 0 };
  480.  
  481. 	oReadLength = 32;
  482. 	/* init jtag tck clock */
  483. 	CH347Jtag_INIT(ch347device.fd, 4);
  484. 	/* reset target jtag device */
  485. 	CH347Jtag_SwitchTapState(ch347device.fd, 0);
  486. 	/* SHIFT-DR Read the Target IDCODE */
  487. 	CH347Jtag_ByteReadDR(ch347device.fd, &oReadLength, &retue);
  488.  
  489. 	printf("Target IDCODE: \n");
  490. 	for (i = 0; i < 4; i++) {
  491. 		printf("0x%2x", retue[3 - i]);
  492. 	}
  493. 	puts("");
  494.  
  495. 	return;
  496. }
  497.  
  498. bool CH347_SPI_Slave_Init()
  499. {
  500. 	bool ret;
  501. 	mSpiCfgS SpiCfg = { 0 };
  502.  
  503. 	/* set spi interface in spi slave mode, [mode3] & [MSB] & output [0xFF] by default */
  504. 	SpiCfg.iByteOrder = 1;
  505. 	SpiCfg.iSpiOutDefaultData = 0xFF;
  506. 	SpiCfg.iMode = 0x83;
  507.  
  508. 	/* init spi interface */
  509. 	ret = CH347SPI_Init(ch347device.fd, &SpiCfg);
  510. 	if (!ret) {
  511. 		printf("Failed to init SPI interface.\n");
  512. 		return false;
  513. 	} else {
  514. 		printf("SPI init slave ok.\n");
  515. 	}
  516.  
  517. 	return true;
  518. }
  519.  
  520. void ch34x_demo_spi_slave_operate(bool enable)
  521. {
  522. 	bool ret = false;
  523. 	uint8_t oBuffer[SPI_SLAVE_MAX_LENGTH];
  524. 	uint32_t oLength;
  525. 	int i;
  526.  
  527. 	if (enable) {
  528. 		ret = CH347_SPI_Slave_Init();
  529. 		if (ret == false) {
  530. 			printf("Failed to init CH347 SPI interface.\n");
  531. 			return;
  532. 		}
  533. 		printf("CH347 SPI interface init succeed.\n");
  534. 		ret = CH347SPI_Slave_Control(ch347device.fd, true);
  535. 		if (!ret)
  536. 			return;
  537. 		printf("Begin read data in slave mode.\n");
  538. 		while (1) {
  539. 			ret = CH347SPI_Slave_QweryData(ch347device.fd, &oLength);
  540. 			if (!ret) {
  541. 				printf("CH347SPI_Slave_QweryData failed.\n");
  542. 				goto exit;
  543. 			}
  544. 			if (oLength == 0) {
  545. 				usleep(10 * 1000);
  546. 				continue;
  547. 			}
  548. 			ret = CH347SPI_Slave_ReadData(ch347device.fd, oBuffer, &oLength);
  549. 			if (!ret) {
  550. 				printf("CH347SPI_Slave_ReadData failed.\n");
  551. 				goto exit;
  552. 			}
  553. 			printf("\nRead Slave data, len: %d, contents:\n", oLength);
  554. 			for (i = 0; i < oLength; i++) {
  555. 				printf("%02x ", oBuffer[i]);
  556. 				if (((i + 1) % 20) == 0)
  557. 					putchar(20);
  558. 			}
  559. 			putchar(20);
  560. 		}
  561. 	} else
  562. 		ret = CH347SPI_Slave_Control(ch347device.fd, false);
  563.  
  564. 	return;
  565.  
  566. exit:
  567. 	CH347SPI_Slave_Control(ch347device.fd, false);
  568. }
  569.  
  570. static void ch34x_demo_gpio_input_operate()
  571. {
  572. 	bool ret;
  573. 	int i, j;
  574. 	int gpiocount = 8;
  575. 	uint8_t iDir = 0xff;
  576. 	uint8_t iData = 0x00;
  577.  
  578. 	ret = CH347GPIO_Get(ch347device.fd, &iDir, &iData);
  579. 	if (ret == false) {
  580. 		printf("CH347GPIO_Set error.\n");
  581. 		return;
  582. 	}
  583.  
  584. 	printf("\n********** GPIO Input Start **********\n\n");
  585. 	for (i = 0; i < gpiocount; i++) {
  586. 		if ((iData & (1 << i)))
  587. 			printf("H");
  588. 		else
  589. 			printf("L");
  590. 	}
  591. 	printf("\n");
  592. 	printf("\n********** GPIO Input End **********\n\n");
  593. }
  594.  
  595. static void ch34x_demo_gpio_output_operate()
  596. {
  597. 	bool ret;
  598. 	int i, j;
  599. 	int gpiocount = 8;
  600. 	uint8_t iEnable = 0xff;
  601. 	uint8_t iSetDirOut = 0xff;
  602. 	uint8_t iSetDataOut = 0x00;
  603.  
  604. 	/* analog leds here */
  605. 	CH347GPIO_Set(ch347device.fd, iEnable, iSetDirOut, iSetDataOut);
  606.  
  607. 	printf("\n********** GPIO Output Start **********\n");
  608. 	for (i = 0; i < gpiocount; i++) {
  609. 		iSetDataOut = 1 << i;
  610. 		ret = CH347GPIO_Set(ch347device.fd, iEnable, iSetDirOut, iSetDataOut);
  611. 		if (ret == false) {
  612. 			printf("CH347GPIO_Set error.\n");
  613. 			return;
  614. 		}
  615. 		printf("\n");
  616. 		for (j = 0; j < gpiocount; j++) {
  617. 			if (j == i)
  618. 				printf("H");
  619. 			else
  620. 				printf("L");
  621. 		}
  622. 		printf("\n");
  623. 		usleep(200 * 1000);
  624. 	}
  625. 	iSetDataOut = 0x00;
  626. 	CH347GPIO_Set(ch347device.fd, iEnable, iSetDirOut, iSetDataOut);
  627. 	printf("\n********** GPIO Output End **********\n\n");
  628. }
  629.  
  630. static void ch34x_demo_isr_handler(int signo)
  631. {
  632. 	static int int_times = 0;
  633.  
  634. 	printf("ch34x interrupt times: %d\n", int_times++);
  635. }
  636.  
  637. static void ch34x_demo_irq_operate(bool enable)
  638. {
  639. 	bool ret;
  640. 	int gpioindex = 6;
  641.  
  642. 	ret = CH347GPIO_IRQ_Set(ch347device.fd, gpioindex, enable, IRQ_TYPE_EDGE_BOTH, ch34x_demo_isr_handler);
  643. 	if (!ret) {
  644. 		printf("Failed to set CH347 irq function.");
  645. 		return;
  646. 	}
  647. }
  648.  
  649. void ch34x_demo_uart_operate()
  650. {
  651. 	bool ret = false;
  652. 	uint8_t iBuffer[256];
  653. 	uint8_t oBuffer[256];
  654. 	uint32_t ioLength;
  655. 	int i;
  656.  
  657. 	ioLength = 256;
  658. 	for (i = 0; i < 256; i++)
  659. 		iBuffer[i] = i;
  660.  
  661. 	ret = CH347Uart_Init(ch347device.fd, 115200, 3, 0, 0, 1);
  662. 	if (!ret) {
  663. 		printf("Failed to init CH347 UART interface.\n");
  664. 		return;
  665. 	}
  666. 	printf("CH347 UART interface init succeed.\n");
  667.  
  668. 	ret = CH347Uart_Write(ch347device.fd, iBuffer, &ioLength);
  669. 	if (ret == false) {
  670. 		printf("CH347Uart_Write failed.\n");
  671. 		return;
  672. 	}
  673. 	printf("Uart wrote %d bytes already.\n", ioLength);
  674.  
  675. 	ret = CH347Uart_Read(ch347device.fd, oBuffer, &ioLength);
  676. 	if (ret == false) {
  677. 		printf("CH347Uart_Read failed.\n");
  678. 		return;
  679. 	}
  680.  
  681. 	printf("\nRead Uart data:\n");
  682. 	for (i = 0; i < ioLength; i++) {
  683. 		printf("%02x ", oBuffer[i]);
  684. 		if (((i + 1) % 10) == 0)
  685. 			putchar(10);
  686. 	}
  687. 	putchar(10);
  688. }
  689.  
  690. bool Show_DevMsg(char *pathname)
  691. {
  692. 	unsigned char buf[256];
  693. 	int ret;
  694. 	int i;
  695. 	struct hidraw_devinfo info;
  696. 	uint16_t vendor, product;
  697. 	CHIP_TYPE chiptype;
  698.  
  699. 	if (strstr(pathname, "tty")) {
  700. 		printf("Device operating has function [UART].\n");
  701. 		ch347device.functype = FUNC_UART;
  702. 	} else if (strstr(pathname, "hidraw")) {
  703. 		/* Get Raw Name */
  704. 		ret = ioctl(ch347device.fd, HIDIOCGRAWNAME(256), buf);
  705. 		if (ret < 0) {
  706. 			perror("HIDIOCGRAWNAME");
  707. 			goto exit;
  708. 		} else
  709. 			printf("Raw Name: %s\n", buf);
  710.  
  711. 		/* Get Raw Info */
  712. 		ret = ioctl(ch347device.fd, HIDIOCGRAWINFO, &info);
  713. 		if (ret < 0) {
  714. 			perror("HIDIOCGRAWINFO");
  715. 			goto exit;
  716. 		} else {
  717. 			printf("Raw Info:\n");
  718. 			printf("\tvendor: 0x%04hx\n", info.vendor);
  719. 			printf("\tproduct: 0x%04hx\n", info.product);
  720. 		}
  721.  
  722. 		if (info.vendor == 0x1a86) {
  723. 			if (info.product == 0x55dc)
  724. 				ch347device.chiptype = CHIP_CH347T;
  725. 			else if (info.product == 0x55e5)
  726. 				ch347device.chiptype = CHIP_CH347F;
  727. 			else {
  728. 				printf("Current HID device PID is not CH347.\n");
  729. 				return -1;
  730. 			}
  731. 		} else {
  732. 			printf("Current HID device VID is not CH347.\n");
  733. 			return -1;
  734. 		}
  735.  
  736. 		/* Get Physical Location */
  737. 		ret = ioctl(ch347device.fd, HIDIOCGRAWPHYS(256), buf);
  738. 		if (ret < 0) {
  739. 			perror("HIDIOCGRAWPHYS");
  740. 			goto exit;
  741. 		} else
  742. 			printf("Raw Phys: %s\n", buf);
  743.  
  744. 		if (ch347device.chiptype == CHIP_CH347T) {
  745. 			if (strstr(buf, "input0")) {
  746. 				ch347device.functype = FUNC_UART;
  747. 				printf("Device operating has function [UART].\n");
  748. 			} else {
  749. 				ch347device.functype = FUNC_SPI_I2C_GPIO;
  750. 				printf("Device operating has function [SPI+I2C+GPIO].\n");
  751. 			}
  752. 		} else {
  753. 			if (strstr(buf, "input0")) {
  754. 				ch347device.functype = FUNC_UART;
  755. 				printf("Device operating has function [UART].\n");
  756. 			} else if (strstr(buf, "input2")) {
  757. 				ch347device.functype = FUNC_UART;
  758. 				printf("Device operating has function [UART].\n");
  759. 			} else {
  760. 				ch347device.functype = FUNC_SPI_I2C_GPIO;
  761. 				printf("Device operating has function [SPI+I2C+JTAG+GPIO].\n");
  762. 			}
  763. 		}
  764. 	} else if (strstr(pathname, "ch34x_pis")) {
  765. 		/* Get Driver Version */
  766. 		ret = CH34x_GetDriverVersion(ch347device.fd, ch347device.version);
  767. 		if (ret == false) {
  768. 			printf("CH34x_GetDriverVersion error.\n");
  769. 			goto exit;
  770. 		}
  771. 		printf("Driver version: %s\n", ch347device.version);
  772.  
  773. 		/* Get Chip Type */
  774. 		ret = CH34x_GetChipType(ch347device.fd, &ch347device.chiptype);
  775. 		if (ret == false) {
  776. 			printf("CH34x_GetChipType error.\n");
  777. 			goto exit;
  778. 		}
  779. 		if (ch347device.chiptype == CHIP_CH341) {
  780. 			printf("Current chip operating is CH341, please use ch341_demo.\n");
  781. 			goto exit;
  782. 		}
  783.  
  784. 		/* Get Device ID */
  785. 		ret = CH34X_GetDeviceID(ch347device.fd, &ch347device.dev_id);
  786. 		if (ret == false) {
  787. 			printf("CH34X_GetDeviceID error.\n");
  788. 			goto exit;
  789. 		}
  790. 		vendor = ch347device.dev_id;
  791. 		product = ch347device.dev_id >> 16;
  792. 		printf("Vendor ID: 0x%4x, Product ID: 0x%4x\n", vendor, product);
  793. 		if (product == 0x55db) {
  794. 			ch347device.functype = FUNC_SPI_I2C_GPIO;
  795. 			printf("Device operating has function [SPI+I2C+GPIO].\n");
  796. 		} else if (product == 0x55dd) {
  797. 			ch347device.functype = FUNC_JTAG_GPIO;
  798. 			printf("Device operating has function [JTAG+GPIO].\n");
  799. 		} else if (product == 0x55de) {
  800. 			ch347device.functype = FUNC_SPI_I2C_JTAG_GPIO;
  801. 			printf("Device operating has function [SPI+I2C+JTAG+GPIO].\n");
  802. 		}
  803. 	}
  804. 	return true;
  805.  
  806. exit:
  807. 	return false;
  808. }
  809.  
  810. int main(int argc, char *argv[])
  811. {
  812. 	bool ret;
  813. 	char choice, ch;
  814.  
  815. 	if (argc != 2) {
  816. 		printf("Usage: sudo %s [device]\n", argv[0]);
  817. 		return -1;
  818. 	}
  819.  
  820. 	/* open device */
  821. 	ch347device.fd = CH347OpenDevice(argv[1]);
  822. 	if (ch347device.fd < 0) {
  823. 		printf("CH347OpenDevice false.\n");
  824. 		return -1;
  825. 	}
  826. 	printf("Open device %s succeed, fd: %d\n", argv[1], ch347device.fd);
  827.  
  828. 	ret = Show_DevMsg(argv[1]);
  829. 	if (ret == false)
  830. 		return -1;
  831. 	sleep(1);
  832.  
  833. 	if (strstr(argv[1], "ch34x_pis")) {
  834. 		ret = CH34xSetTimeout(ch347device.fd, 2000, 2000);
  835. 		if (ret == false) {
  836. 			printf("CH34xSetTimeout false.\n");
  837. 			return -1;
  838. 		}
  839. 	}
  840.  
  841. 	switch (ch347device.functype) {
  842. 	case FUNC_UART:
  843. 		while (1) {
  844. 			printf("\npress u to operate uart, q to quit.\n");
  845. 			scanf("%c", &choice);
  846. 			while ((ch = getchar()) != EOF && ch != '\n')
  847. 				;
  848. 			if (choice == 'q')
  849. 				break;
  850. 			switch (choice) {
  851. 			case 'u':
  852. 				ch34x_demo_uart_operate();
  853. 				break;
  854. 			default:
  855. 				break;
  856. 			}
  857. 		}
  858. 		break;
  859. 	case FUNC_SPI_I2C_GPIO:
  860. 	case FUNC_SPI_I2C_JTAG_GPIO:
  861. 		while (1) {
  862. 			printf("\npress f to operate spi flash, e to operate eeprom,\n"
  863. 			       "a to get gpio status, g to gpio output test, j to operate jtag interface,\n"
  864. 			       "s to enable spi slave mode, o to disable spi slave mode,\n"
  865. 			       "i to enable interrupt, d to disable interrupt, q to quit.\n");
  866.  
  867. 			scanf("%c", &choice);
  868. 			while ((ch = getchar()) != EOF && ch != '\n')
  869. 				;
  870. 			if (choice == 'q')
  871. 				break;
  872.  
  873. 			switch (choice) {
  874. 			case 'f':
  875. 				printf("FLASH Test begin.\n");
  876. 				ch34x_demo_flash_operate();
  877. 				break;
  878. 			case 'e':
  879. 				printf("EEPROM Test begin.\n");
  880. 				ch34x_demo_eeprom_operate();
  881. 				break;
  882. 			case 'a':
  883. 				printf("GPIO Input Test Begin.\n");
  884. 				ch34x_demo_gpio_input_operate();
  885. 				break;
  886. 			case 'g':
  887. 				printf("GPIO Output Test Begin.\n");
  888. 				ch34x_demo_gpio_output_operate();
  889. 				break;
  890. 			case 'i':
  891. 				printf("IRQ Test Begin.");
  892. 				ch34x_demo_irq_operate(true);
  893. 				break;
  894. 			case 'd':
  895. 				printf("IRQ Test Over.\n");
  896. 				ch34x_demo_irq_operate(false);
  897. 				break;
  898. 			case 'j':
  899. 				if (ch347device.functype == FUNC_SPI_I2C_JTAG_GPIO) {
  900. 					printf("JTAG Test begin.\n");
  901. 					ch34x_demo_jtag_operate();
  902. 				} else {
  903. 					printf("Chip is not CH347F.\n");
  904. 				}
  905. 				break;
  906. 			case 's':
  907. 				if (ch347device.chiptype == CHIP_CH347F) {
  908. 					printf("SPI Slave Test Begin.\n");
  909. 					ch34x_demo_spi_slave_operate(true);
  910. 				} else {
  911. 					printf("Chip is not CH347F.\n");
  912. 				}
  913. 				break;
  914. 			case 'o':
  915. 				if (ch347device.chiptype == CHIP_CH347F) {
  916. 					printf("SPI Slave Test Over.\n");
  917. 					ch34x_demo_spi_slave_operate(false);
  918. 				} else {
  919. 					printf("Chip is not CH347F.\n");
  920. 				}
  921. 				break;
  922. 			default:
  923. 				printf("Bad choice, please input again.\n");
  924. 				break;
  925. 			}
  926. 		}
  927. 		break;
  928. 	case FUNC_JTAG_GPIO:
  929. 		while (1) {
  930. 			printf("\npress j to operate jtag interface, a to get gpio status,\n"
  931. 			       "g to gpio output test q to quit.\n");
  932.  
  933. 			scanf("%c", &choice);
  934. 			while ((ch = getchar()) != EOF && ch != '\n')
  935. 				;
  936. 			if (choice == 'q')
  937. 				break;
  938.  
  939. 			switch (choice) {
  940. 			case 'j':
  941. 				printf("JTAG Test begin.\n");
  942. 				ch34x_demo_jtag_operate();
  943. 				break;
  944. 			case 'a':
  945. 				printf("GPIO Input Test Begin.\n");
  946. 				ch34x_demo_gpio_input_operate();
  947. 				break;
  948. 			case 'g':
  949. 				printf("GPIO Test begin.\n");
  950. 				ch34x_demo_gpio_output_operate();
  951. 			default:
  952. 				printf("Bad choice, please input again.\n");
  953. 				break;
  954. 			}
  955. 		}
  956. 		break;
  957. 	default:
  958. 		break;
  959. 	}
  960.  
  961. 	/* close the device */
  962. 	if (CH347CloseDevice(ch347device.fd)) {
  963. 		printf("Close device succeed.\n");
  964. 	}
  965.  
  966. 	return 0;
  967. }

执行截图：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/81668
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号