woody/Tool
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add

Browse Source
This commit is contained in:
woody
2025-12-19 19:32:55 +09:00
parent f419607236
commit a96323de19
8 changed files with 4332 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

541
PMIC_Tool/PMIC_Cmd_Tool/PMIC_Cmd_Tool.cpp
View File

@@ -1,20 +1,531 @@
// PMIC_Cmd_Tool.cpp : 이 파일에는 'main' 함수가 포함됩니다. 거기서 프로그램 실행이 시작되고 종료됩니다.
//
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
#include <iostream>
// 딜레이 함수 이용을 위해
#include <windows.h>
//Sleep(1); // 1ms 딜레이
//Sleep(10); // 10ms 딜레이
//Sleep(100); // 100ms 딜레이
// FT4222 헤더
#include "ftd2xx.h"
#include "LibFT4222.h"
uint8_t PMIC_I2C_SLAVE_ADDR = 0x55;
// 현재 시간을 "HH:MM:SS" 형식으로 buf에 저장
void currentTime(char* buf, size_t len)
{
if (buf == nullptr || len == 0)
return;
time_t now = time(nullptr);
struct tm tm_buf;
#ifdef _WIN32
localtime_s(&tm_buf, &now); // Windows 안전 버전
#else
localtime_r(&now, &tm_buf); // Linux/Unix 안전 버전
#endif
strftime(buf, len, "%H:%M:%S", &tm_buf);
}
// 로그 출력 (커스텀 포맷)
void logPacket(const char* dir, uint8_t* data, int size, int hasCrc)
{
if (dir == nullptr || data == nullptr || size <= 0)
return;
char timeBuf[32];
currentTime(timeBuf, sizeof(timeBuf));
// PMIC I2C WRITE
if (strcmp(dir, "PMIC I2C WRITE") == 0 && size >= 3) {
printf("[%s] [%s] len=%d [Address: 0x%02X] [Value: 0x%02X] [CRC: 0x%02X]\n",
timeBuf, dir, size, data[0], data[1], data[2]);
return;
}
// PMIC I2C READ
if (strcmp(dir, "PMIC I2C READ") == 0 && size >= 2) {
printf("[%s] [%s] len=%d [Value: 0x%02X] [CRC: 0x%02X]\n",
timeBuf, dir, size, data[0], data[1]);
return;
}
// 기본 출력 (기타 상황)
printf("[%s] [%s] len=%d ", timeBuf, dir, size);
for (int i = 0; i < size; i++) {
if (hasCrc && i == size - 1)
printf("[CRC: %02X] ", data[i]);
else
printf("%02X ", data[i]);
}
printf("\n");
}
// CRC8 계산 (다항식 0x07, 초기값 0x00)
uint8_t calcCRC8(uint8_t addrWithRw, uint8_t* data, int len)
{
uint8_t crc = 0x00;
for (int j = -1; j < len; j++) {
uint8_t b = (j == -1) ? addrWithRw : data[j];
crc ^= b;
for (int i = 0; i < 8; i++) {
if (crc & 0x80)
crc = (crc << 1) ^ 0x07;
else
crc <<= 1;
}
}
return crc;
}
// 명령어 판별 (I2C_WRITE/w, I2C_READ/r)
int parseCommand(const char* dir)
{
if (strcmp(dir, "I2C_WRITE") == 0 || strcmp(dir, "W") == 0)
return 1;
if (strcmp(dir, "I2C_READ") == 0 || strcmp(dir, "R") == 0)
return 2;
return 0;
}
// Address에 1바이트 Write with CRC, 그리고 Address를 Read해서 Write한 값과 비교
void PMIC_I2C_Write(FT_HANDLE ftHandle, uint8_t slaveAddr, uint8_t regAddr, uint8_t value)
{
uint8_t bytes[3];
int len = 0;
// Write 패킷: [RegAddr] [Value] [CRC]
bytes[len++] = regAddr;
bytes[len++] = value;
uint8_t addrWithRw = (slaveAddr << 1) | 0x00; // Write 주소
uint8_t crc = calcCRC8(addrWithRw, bytes, len);
bytes[len++] = crc;
uint16 transferred = 0;
FT4222_STATUS st = FT4222_I2CMaster_Write(ftHandle,
slaveAddr,
bytes,
(uint16)len,
&transferred);
if (st != FT4222_OK) {
printf("I2C Write 실패\n");
return;
}
else {
logPacket("PMIC I2C WRITE", bytes, len, 1);
}
// Register Address 다시 Write (Read 시작 위치 지정)
uint8_t regOnly[1] = { regAddr };
st = FT4222_I2CMaster_Write(ftHandle,
slaveAddr,
regOnly,
1,
&transferred);
if (st != FT4222_OK) {
printf("Read용 Address Write 실패\n");
return;
}
// Register Address에서 2바이트 Read
uint8_t rx[2] = { 0 };
st = FT4222_I2CMaster_Read(ftHandle,
slaveAddr,
rx,
2,
&transferred);
if (st != FT4222_OK) {
printf("I2C Read 실패\n");
return;
}
else {
logPacket("PMIC I2C READ ", rx, transferred, 0);
// 첫 번째 바이트와 Write 값 비교
if (rx[0] == value) {
printf("확인 성공: [Write Value = 0x%02X], [Read Value = 0x%02X]\n",
value, rx[0]);
}
else {
printf("불일치: [Write Value = 0x%02X], [Read Value = 0x%02X]\n",
value, rx[0]);
}
}
}
// Address에서 1바이트 Read (CRC 계산 없음)
void PMIC_I2C_Read(FT_HANDLE ftHandle, uint8_t slaveAddr, uint8_t regAddr)
{
uint16 transferred = 0;
FT4222_STATUS st;
// 🔹 Register Address를 먼저 Write (Read 시작 위치 지정)
uint8_t regOnly[1] = { regAddr };
st = FT4222_I2CMaster_Write(ftHandle,
slaveAddr,
regOnly,
1,
&transferred);
if (st != FT4222_OK) {
printf("Read용 Address Write 실패\n");
return;
}
// 🔹 Register Address에서 2바이트 Read (Value + CRC)
uint8_t rx[2] = { 0 };
st = FT4222_I2CMaster_Read(ftHandle,
slaveAddr,
rx,
2,
&transferred);
if (st != FT4222_OK) {
printf("I2C Read 실패\n");
return;
}
else {
printf("Read 결과: [Address = 0x%02X], [Value = 0x%02X], [CRC = 0x%02X]\n",
regAddr, rx[0], rx[1]);
}
}
int main()
{
std::cout << "Hello World!\n";
printf("PMIC I2C Packet Logger with FT4222\n \n");
char addrInput[16];
unsigned int tempAddr = 0;
uint8_t I2C_SLAVE_ADDR = 0;
unsigned long log_counter = 0;
char timeStr[16]; // 시간을 저장할 버퍼 (HH:MM:SS면 9바이트면 충분)
currentTime(timeStr, sizeof(timeStr));
//printf("현재 시간: %s\n", timeStr);
#if 0
printf("I2C Address\n Regulation Register is 0x54\n Protection Register is 0x55\n \nEnter 7-bit I2C Slave Address (hex): ");
if (scanf_s("%15s", addrInput, (unsigned)_countof(addrInput)) != 1) {
printf("입력 오류\n");
return -1;
}
if (sscanf_s(addrInput, "%x", &tempAddr) != 1) {
printf("잘못된 주소 입력\n");
return -1;
}
I2C_SLAVE_ADDR = (uint8_t)tempAddr;
printf("슬레이브 주소 설정됨: 0x%02X\n", I2C_SLAVE_ADDR);
getchar(); // 버퍼 클리어
printf("사용법: I2C_WRITE <data...> 또는 w <data...>\n");
printf(" I2C_READ (항상 2바이트 읽음) 또는 r\n");
printf("exit 또틑 e 입력 시 종료\n");
#endif
printf("Read Regulation 0x54, Page 0x02, Address 0x23 : 0x66 이면 OK\n ");
FT_HANDLE ftHandle = NULL;
FT_STATUS ftStatus;
DWORD numDevs = 0;
ftStatus = FT_CreateDeviceInfoList(&numDevs);
if (ftStatus != FT_OK || numDevs == 0) {
printf("FT4222 장치를 찾을 수 없습니다.\n");
return -1;
}
ftStatus = FT_Open(0, &ftHandle);
if (ftStatus != FT_OK) {
printf("FT4222 장치 열기 실패\n");
return -1;
}
FT4222_STATUS ft4222Status = FT4222_I2CMaster_Init(ftHandle, 400); // 400kHz
if (ft4222Status != FT4222_OK) {
printf("I2C Master 초기화 실패\n");
FT_Close(ftHandle);
return -1;
}
//Fault register data: 0x010 ~0x014, 0x019 ~0x021
//0x010 - FUSA_STATUS_1
//0x011 - FUSA_STATUS_2
//0x012 - FUSA_STATUS_2A
//0x013 - FUSA_STATUS_3
//0x014 - FUSA_STATUS_4
//0x019 - FLT_RECORD_A
//0x01A - FLT_RECORD_B
//0x01B - FLT_RECORD_GND_AVIN
//0x01C - FLT_RECORD_BG_Temp
//0x01D - FLT_RECORD_IntLDOs
//0x01E - FLT_RECORD_ExtLDOs
//0x01F - FLT_RECORD_BUCKS_B
//0x020 - FLT_RECORD_BUCKS_A
//0x021 - FLT_RECORD_ExtINPs_7_0
//printf("=================================================================================\n");
/********************************************************************************************
I2C Write
PMIC_I2C_Write(FT_HANDLE ftHandle, uint8_t slaveAddr, uint8_t regAddr, uint8_t value)
PMIC_I2C_Write(ftHandle, PMIC_I2C_SLAVE_ADDR, 0xAA, 0xBB);
********************************************************************************************/
//printf("=================================================================================\n");
/********************************************************************************************
I2C Read
PMIC_I2C_Read(FT_HANDLE ftHandle, uint8_t slaveAddr, uint8_t regAddr)
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0xAA);
********************************************************************************************/
//for (int i = 0; i < 10000000; i++) {
//while (1) {
//}
//for (int i = 0; i < 10000000; i++) {
//while (log_counter < 10 ){
// 예: 10번 while에 한 번만 실행
//if (log_counter % 10 == 0) {
// 30ms 딜레이
//Sleep(30);
printf("실행하려면 Enter 키를 누르세요...\n");
getchar();
//Regulation Register
// Page00
PMIC_I2C_Write(ftHandle, 0x54, 0x00, 0x00);
PMIC_I2C_Write(ftHandle, 0x54, 0x00, 0x00);
PMIC_I2C_Read(ftHandle, 0x54, 0x00); //0x000 - IO_PAGE_REGU
PMIC_I2C_Read(ftHandle, 0x54, 0x01); //0x001 - IO_CHIPNAME_REGU
PMIC_I2C_Read(ftHandle, 0x54, 0x02); //0x002 - IO_CHIPVERSION_REGU
PMIC_I2C_Read(ftHandle, 0x54, 0x03); //0x003 - IO_DIEID3_REGU
//PMIC_I2C_Read(ftHandle, 0x54, 0x04); //0x004
//PMIC_I2C_Read(ftHandle, 0x54, 0x05); //0x005
//PMIC_I2C_Write(ftHandle, 0x54, 0x00, 0x02);
//PMIC_I2C_Write(ftHandle, 0x54, 0x00, 0x02);
//PMIC_I2C_Read(ftHandle, 0x54, 0x23);
// 30ms 딜레이
//Sleep(30);
// Page02
PMIC_I2C_Write(ftHandle, 0x54, 0x00, 0x02);
PMIC_I2C_Write(ftHandle, 0x54, 0x00, 0x02);
//PMIC_I2C_Read(ftHandle, 0x54, 0x20);
//PMIC_I2C_Read(ftHandle, 0x54, 0x21);
PMIC_I2C_Read(ftHandle, 0x54, 0x22); //0x222 - I_OTP_VERSION
PMIC_I2C_Read(ftHandle, 0x54, 0x23); //0x223 - I_OTP_INTERNALVERSION
//PMIC_I2C_Read(ftHandle, 0x54, 0x24);
//PMIC_I2C_Read(ftHandle, 0x54, 0x25);
// 30ms 딜레이
//Sleep(30);
//Protection Register
// Page01
PMIC_I2C_Write(ftHandle, 0x55, 0x00, 0x01);
PMIC_I2C_Write(ftHandle, 0x55, 0x00, 0x01);
PMIC_I2C_Read(ftHandle, 0x55, 0x02); //0x102 - IO_MODECTRL Read시 디폴트 0x65
PMIC_I2C_Write(ftHandle, 0x55, 0x02, 0x25); //0x102 - IO_MODECTRL
// 10s 딜레이
Sleep(10000);
PMIC_I2C_Write(ftHandle, 0x55, 0x02, 0x65); //0x102 - IO_MODECTRL
//}
//log_counter++;
//}
#if 0
//Protection Register
//Regulation Register
printf("[Page-0]=================================================================================\n");
PMIC_I2C_Write(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x00, 0x00);
PMIC_I2C_Write(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x00, 0x00);
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x00); //0x000 - IO_PAGE_REGU
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x01); //0x001 - IO_CHIPNAME_REGU
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x02); //0x002 - IO_CHIPVERSION_REGU
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x03); //0x003 - IO_DIEID3_REGU
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x04); //0x004 - IO_DIEID2_REGU
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x05); //0x005 - IO_DIEID1_REGU
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x06); //0x006 - IO_DIEID0_REGU
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x0A); //0x00A - OTP_VERSION_REGU
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x10); //0x010 - FUSA_STATUS_1
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x11); //0x011 - FUSA_STATUS_2
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x12); //0x012 - FUSA_STATUS_2A
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x13); //0x013 - FUSA_STATUS_3
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x14); //0x014 - FUSA_STATUS_4
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x19); //0x019 - FLT_RECORD_A
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x1A); //0x01A - FLT_RECORD_B
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x1B); //0x01B - FLT_RECORD_GND_AVIN
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x1C); //0x01C - FLT_RECORD_BG_Temp
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x1D); //0x01D - FLT_RECORD_IntLDOs
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x1E); //0x01E - FLT_RECORD_ExtLDOs
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x1F); //0x01F - FLT_RECORD_BUCKS_B
printf("[Page-1]=================================================================================\n");
PMIC_I2C_Write(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x00, 0x01);
PMIC_I2C_Write(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x00, 0x01);
printf("[Page-2]=================================================================================\n");
PMIC_I2C_Write(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x00, 0x02);
PMIC_I2C_Write(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x00, 0x02);
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x20); //0x020 - FLT_RECORD_BUCKS_A
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x21); //0x021 - FLT_RECORD_ExtINPs_7_0
printf("[PMIC_RAA271005_INIT]====================================================================\n");
PMIC_I2C_Write(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x00, 0x01);
PMIC_I2C_Write(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x00, 0x01);
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x07); //0x107 - WDT_CFG0 (OTP)
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x08); //0x108 - WDT_CFG1 (OTP) //WDT_ULCNT, WDT_LLCNT
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x09); //0x109 - WDT_CFG2 (OTP)
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x16); //0x116 - FUSA_TIMER_1 (OTP)
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x17); //0x117 - FUSA_TIMER_2 (OTP)
PMIC_I2C_Read(ftHandle, PMIC_I2C_SLAVE_ADDR, 0x2C); //0x12C - FLT_MASK_B (OTP)
#endif
char line[256];
while (1) {
printf("> ");
if (!fgets(line, sizeof(line), stdin)) break;
line[strcspn(line, "\r\n")] = 0; // 개행 제거
if (strcmp(line, "exit") == 0) break;
if (strcmp(line, "e") == 0) break;
if (strlen(line) == 0) continue;
char* context = NULL;
char* token = strtok_s(line, " ", &context);
if (!token) continue;
for (char* p = token; *p; p++) *p = toupper(*p);
int command = parseCommand(token);
if (command == 1) { // I2C_WRITE
uint8_t bytes[256];
int len = 0;
while ((token = strtok_s(NULL, " ", &context)) != NULL) {
unsigned int val;
if (sscanf_s(token, "%x", &val) == 1) {
bytes[len++] = (uint8_t)val;
}
else {
printf("잘못된 HEX 값: %s\n", token);
}
}
if (len == 0) {
printf("전송할 데이터가 없습니다.\n");
continue;
}
uint8_t addrWithRw = (I2C_SLAVE_ADDR << 1) | 0x00;
uint8_t crc = calcCRC8(addrWithRw, bytes, len);
bytes[len++] = crc;
uint16 transferred = 0;
ft4222Status = FT4222_I2CMaster_Write(ftHandle,
I2C_SLAVE_ADDR,
bytes,
(uint16)len,
&transferred);
if (ft4222Status != FT4222_OK) {
printf("I2C Write 실패\n");
}
else {
logPacket("I2C_WRITE", bytes, len, 1);
}
}
else if (command == 2) { // I2C_READ
uint8_t bytes[256];
uint16 transferred = 0;
FT4222_STATUS st;
int len = 0;
while ((token = strtok_s(NULL, " ", &context)) != NULL) {
unsigned int val;
if (sscanf_s(token, "%x", &val) == 1) {
bytes[len++] = (uint8_t)val;
}
else {
printf("잘못된 HEX 값: %s\n", token);
}
}
if (len == 0) {
printf("전송할 데이터가 없습니다.\n");
continue;
}
uint8_t addrWithRw = (I2C_SLAVE_ADDR << 1) | 0x00;
uint8_t crc = calcCRC8(addrWithRw, bytes, len);
bytes[len++] = crc;
st = FT4222_I2CMaster_Write(ftHandle,
I2C_SLAVE_ADDR,
bytes,
(uint16)len,
&transferred);
if (st != FT4222_OK) {
printf("Read용 Address Write 실패\n");
return 0;
}
// 🔹 Register Address에서 2바이트 Read (Value + CRC)
uint8_t rx[2] = { 0 };
st = FT4222_I2CMaster_Read(ftHandle,
I2C_SLAVE_ADDR,
rx,
2,
&transferred);
if (st != FT4222_OK) {
printf("I2C Read 실패\n");
return 0;
}
else {
printf("Read 결과: [Address = 0x%02X], [Value = 0x%02X], [CRC = 0x%02X]\n",
bytes[0], rx[0], rx[1]);
}
}
else {
printf("첫 단어는 I2C_WRITE(w) 또는 I2C_READ(r) 여야 합니다.\n");
}
}
FT_Close(ftHandle);
return 0;
}
// 프로그램 실행: <Ctrl+F5> 또는 [디버그] > [디버깅하지 않고 시작] 메뉴
// 프로그램 디버그: <F5> 키 또는 [디버그] > [디버깅 시작] 메뉴
// 시작을 위한 팁:
// 1. [솔루션 탐색기] 창을 사용하여 파일을 추가/관리합니다.
// 2. [팀 탐색기] 창을 사용하여 소스 제어에 연결합니다.
// 3. [출력] 창을 사용하여 빌드 출력 및 기타 메시지를 확인합니다.
// 4. [오류 목록] 창을 사용하여 오류를 봅니다.
// 5. [프로젝트] > [새 항목 추가]로 이동하여 새 코드 파일을 만들거나, [프로젝트] > [기존 항목 추가]로 이동하여 기존 코드 파일을 프로젝트에 추가합니다.
// 6. 나중에 이 프로젝트를 다시 열려면 [파일] > [열기] > [프로젝트]로 이동하고 .sln 파일을 선택합니다.

7
PMIC_Tool/PMIC_Cmd_Tool/PMIC_Cmd_Tool.vcxproj
View File

@@ -116,11 +116,18 @@
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalLibraryDirectories>.\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>$(CoreLibraryDependencies);%(AdditionalDependencies);ftd2xx.lib;LibFT4222-64.lib</AdditionalDependencies>
</Link>
<PostBuildEvent>
<Command>copy "$(ProjectDir)dll\ftd2xx.dll" "$(OutDir)"
copy "$(ProjectDir)dll\LibFT4222-64.dll" "$(OutDir)"</Command>
</PostBuildEvent>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="PMIC_Cmd_Tool.cpp" />

BIN
PMIC_Tool/PMIC_Cmd_Tool/dll/LibFT4222-64.dll Normal file
View File

Binary file not shown.

BIN
PMIC_Tool/PMIC_Cmd_Tool/dll/ftd2xx.dll Normal file
View File

Binary file not shown.

406
PMIC_Tool/PMIC_Cmd_Tool/include/LibFT4222.h Normal file
View File

@@ -0,0 +1,406 @@
#ifndef _FTDI_LIB_FT4222_H_
#define _FTDI_LIB_FT4222_H_
//------------------------------------------------------------------------------
/**
* Copyright (c) 2001-2015 Future Technology Devices International Limited
*
* THIS SOFTWARE IS PROVIDED BY FUTURE TECHNOLOGY DEVICES INTERNATIONAL LIMITED "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* FUTURE TECHNOLOGY DEVICES INTERNATIONAL LIMITED BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES LOSS OF USE, DATA, OR PROFITS OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* FTDI DRIVERS MAY BE USED ONLY IN CONJUNCTION WITH PRODUCTS BASED ON FTDI PARTS.
*
* FTDI DRIVERS MAY BE DISTRIBUTED IN ANY FORM AS LONG AS LICENSE INFORMATION IS NOT MODIFIED.
*
* @file LibFT4222.h
*
* @author FTDI
* @date 2015-08-10
*
*
* Revision History:
* 1.0 - initial version
* 1.2 - allow use on non-Windows platforms;
* add I2CMaster ReadEx/WriteEx/GetStatus
* 1.3 - add FT4222_I2CSlave_SetClockStretch
* add FT4222_I2CSlave_SetRespWord
* 1.4 - add FT4222_I2CMaster_ResetBus
* add FT4222_SPIMaster_SetCS
* remove FT4222_SPISlave_RxQuickResponse
* add static library, need to define FT4222_STATIC
*/
#ifdef _WIN32
// Compiling on Windows
#include <windows.h>
typedef UINT8 uint8;
typedef UINT16 uint16;
typedef UINT32 uint32;
typedef UINT64 uint64;
typedef INT8 int8;
typedef INT16 int16;
typedef INT32 int32;
typedef INT64 int64;
#ifdef LIBFT4222_EXPORTS
#define LIBFT4222_API __declspec(dllexport)
#elif defined(FT4222_STATIC)
#define LIBFT4222_API
#pragma comment(lib, "setupapi.lib")
#pragma comment(lib, "advapi32.lib")
#pragma comment(lib, "user32.lib")
#else
#define LIBFT4222_API __declspec(dllimport)
#endif
#else // _WIN32
// Compiling on non-Windows platform.
#include <stdint.h>
typedef uint8_t uint8;
typedef uint16_t uint16;
typedef uint32_t uint32;
typedef uint64_t uint64;
typedef int8_t int8;
typedef int16_t int16;
typedef int32_t int32;
typedef int64_t int64;
// No function-name decorations needed.
#define LIBFT4222_API
#define WINAPI
#endif // _WIN32
#ifdef _MSC_VER
// Prevent MS compiler warning about bad character
#pragma warning(disable: 4819)
#endif // _MSC_VER
#include "ftd2xx.h"
#define FT4222_EVENT_RXCHAR 8
// spi slave sync word
#define FT4222_SPI_SLAVE_SYNC_WORD 0x5A
// spi slave cmd
#define SPI_MASTER_TRANSFER 0x80
#define SPI_SLAVE_TRANSFER 0x81
#define SPI_SHORT_MASTER_TRANSFER 0x82
#define SPI_SHORT_SLAVE_TRANSFER 0x83
// Backwards compatibility for typo in earlier version
#define SPI_SHART_SLAVE_TRANSFER 0x83
#define SPI_ACK 0x84
/* I2C Master Controller Status
* bit 0 = controller busy: all other status bits invalid
* bit 1 = error condition
* bit 2 = slave address was not acknowledged during last operation
* bit 3 = data not acknowledged during last operation
* bit 4 = arbitration lost during last operation
* bit 5 = controller idle
* bit 6 = bus busy
*/
#define I2CM_CONTROLLER_BUSY(status) (((status) & 0x01) != 0)
#define I2CM_DATA_NACK(status) (((status) & 0x0A) != 0)
#define I2CM_ADDRESS_NACK(status) (((status) & 0x06) != 0)
#define I2CM_ARB_LOST(status) (((status) & 0x12) != 0)
#define I2CM_IDLE(status) (((status) & 0x20) != 0)
#define I2CM_BUS_BUSY(status) (((status) & 0x40) != 0)
//
// FT4222 Device status
//
typedef enum FT4222_STATUS
{
FT4222_OK,
FT4222_INVALID_HANDLE,
FT4222_DEVICE_NOT_FOUND,
FT4222_DEVICE_NOT_OPENED,
FT4222_IO_ERROR,
FT4222_INSUFFICIENT_RESOURCES,
FT4222_INVALID_PARAMETER,
FT4222_INVALID_BAUD_RATE,
FT4222_DEVICE_NOT_OPENED_FOR_ERASE,
FT4222_DEVICE_NOT_OPENED_FOR_WRITE,
FT4222_FAILED_TO_WRITE_DEVICE,
FT4222_EEPROM_READ_FAILED,
FT4222_EEPROM_WRITE_FAILED,
FT4222_EEPROM_ERASE_FAILED,
FT4222_EEPROM_NOT_PRESENT,
FT4222_EEPROM_NOT_PROGRAMMED,
FT4222_INVALID_ARGS,
FT4222_NOT_SUPPORTED,
FT4222_OTHER_ERROR,
FT4222_DEVICE_LIST_NOT_READY,
FT4222_DEVICE_NOT_SUPPORTED = 1000, // FT_STATUS extending message
FT4222_CLK_NOT_SUPPORTED,
FT4222_VENDER_CMD_NOT_SUPPORTED,
FT4222_IS_NOT_SPI_MODE,
FT4222_IS_NOT_I2C_MODE,
FT4222_IS_NOT_SPI_SINGLE_MODE,
FT4222_IS_NOT_SPI_MULTI_MODE,
FT4222_WRONG_I2C_ADDR,
FT4222_INVAILD_FUNCTION,
FT4222_INVALID_POINTER,
FT4222_EXCEEDED_MAX_TRANSFER_SIZE,
FT4222_FAILED_TO_READ_DEVICE,
FT4222_I2C_NOT_SUPPORTED_IN_THIS_MODE,
FT4222_GPIO_NOT_SUPPORTED_IN_THIS_MODE,
FT4222_GPIO_EXCEEDED_MAX_PORTNUM,
FT4222_GPIO_WRITE_NOT_SUPPORTED,
FT4222_GPIO_PULLUP_INVALID_IN_INPUTMODE,
FT4222_GPIO_PULLDOWN_INVALID_IN_INPUTMODE,
FT4222_GPIO_OPENDRAIN_INVALID_IN_OUTPUTMODE,
FT4222_INTERRUPT_NOT_SUPPORTED,
FT4222_GPIO_INPUT_NOT_SUPPORTED,
FT4222_EVENT_NOT_SUPPORTED,
FT4222_FUN_NOT_SUPPORT,
}
FT4222_STATUS;
typedef enum FT4222_ClockRate
{
SYS_CLK_60 = 0,
SYS_CLK_24,
SYS_CLK_48,
SYS_CLK_80,
}
FT4222_ClockRate;
typedef enum FT4222_FUNCTION
{
FT4222_I2C_MASTER = 1,
FT4222_I2C_SLAVE,
FT4222_SPI_MASTER,
FT4222_SPI_SLAVE,
}
FT4222_FUNCTION;
typedef enum FT4222_SPIMode
{
SPI_IO_NONE = 0,
SPI_IO_SINGLE = 1,
SPI_IO_DUAL = 2,
SPI_IO_QUAD = 4,
}
FT4222_SPIMode;
typedef enum FT4222_SPIClock
{
CLK_NONE = 0,
CLK_DIV_2, // 1/2 System Clock
CLK_DIV_4, // 1/4 System Clock
CLK_DIV_8, // 1/8 System Clock
CLK_DIV_16, // 1/16 System Clock
CLK_DIV_32, // 1/32 System Clock
CLK_DIV_64, // 1/64 System Clock
CLK_DIV_128, // 1/128 System Clock
CLK_DIV_256, // 1/256 System Clock
CLK_DIV_512, // 1/512 System Clock
}
FT4222_SPIClock;
typedef enum FT4222_SPICPOL
{
CLK_IDLE_LOW =0,
CLK_IDLE_HIGH =1,
}
FT4222_SPICPOL;
typedef enum FT4222_SPICPHA
{
CLK_LEADING =0,
CLK_TRAILING =1,
}
FT4222_SPICPHA;
typedef enum SPI_DrivingStrength
{
DS_4MA =0,
DS_8MA,
DS_12MA,
DS_16MA,
}
SPI_DrivingStrength;
typedef enum SPI_ChipSelect
{
CS_ACTIVE_LOW = 0,
CS_ACTIVE_HIGH,
}
SPI_ChipSelect;
typedef enum GPIO_Port
{
GPIO_PORT0 =0,
GPIO_PORT1,
GPIO_PORT2,
GPIO_PORT3
}
GPIO_Port;
typedef enum GPIO_Dir
{
GPIO_OUTPUT =0,
GPIO_INPUT,
}
GPIO_Dir;
// Backwards compatibility for typo in earlier version
#define GPIO_Tigger GPIO_Trigger
typedef enum GPIO_Trigger
{
GPIO_TRIGGER_RISING = 0x01,
GPIO_TRIGGER_FALLING = 0x02,
GPIO_TRIGGER_LEVEL_HIGH = 0x04,
GPIO_TRIGGER_LEVEL_LOW = 0X08
}
GPIO_Trigger;
typedef enum GPIO_Output
{
GPIO_OUTPUT_LOW,
GPIO_OUTPUT_HIGH
}
GPIO_Output;
typedef enum I2C_MasterFlag
{
NONE = 0x80,
START = 0x02,
Repeated_START = 0x03, // Repeated_START will not send master code in HS mode
STOP = 0x04,
START_AND_STOP = 0x06, // START condition followed by SEND and STOP condition
}
I2C_MasterFlag;
typedef enum SPI_SlaveProtocol
{
SPI_SLAVE_WITH_PROTOCOL = 0,
SPI_SLAVE_NO_PROTOCOL,
SPI_SLAVE_NO_ACK,
}
SPI_SlaveProtocol;
typedef struct FT4222_Version
{
DWORD chipVersion;
DWORD dllVersion;
}
FT4222_Version;
#pragma pack(push, 1)
struct SPI_Slave_Header
{
uint8 syncWord;
uint8 cmd;
uint8 sn;
uint16 size;
};
#pragma pack(pop)
#ifdef __cplusplus
extern "C" {
#endif
// FT4222 General Functions
LIBFT4222_API FT4222_STATUS WINAPI FT4222_UnInitialize(FT_HANDLE ftHandle);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SetClock(FT_HANDLE ftHandle, FT4222_ClockRate clk);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_GetClock(FT_HANDLE ftHandle, FT4222_ClockRate* clk);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SetWakeUpInterrupt(FT_HANDLE ftHandle, BOOL enable);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SetInterruptTrigger(FT_HANDLE ftHandle, GPIO_Trigger trigger);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SetSuspendOut(FT_HANDLE ftHandle, BOOL enable);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_GetMaxTransferSize(FT_HANDLE ftHandle, uint16* pMaxSize);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SetEventNotification(FT_HANDLE ftHandle, DWORD mask, PVOID param);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_GetVersion(FT_HANDLE ftHandle, FT4222_Version* pVersion);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_GetChipMode(FT_HANDLE ftHandle, uint8 *pChipMode);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_ChipReset(FT_HANDLE ftHandle);
// FT4222 SPI Functions
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPIMaster_Init(FT_HANDLE ftHandle, FT4222_SPIMode ioLine, FT4222_SPIClock clock, FT4222_SPICPOL cpol, FT4222_SPICPHA cpha, uint8 ssoMap);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPIMaster_SetMode(FT_HANDLE ftHandle, FT4222_SPICPOL cpol, FT4222_SPICPHA cpha);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPIMaster_SetCS(FT_HANDLE ftHandle, SPI_ChipSelect cs);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPIMaster_SetLines(FT_HANDLE ftHandle, FT4222_SPIMode spiMode);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPIMaster_SingleRead(FT_HANDLE ftHandle, uint8* buffer, uint16 bufferSize, uint16* sizeOfRead, BOOL isEndTransaction);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPIMaster_SingleWrite(FT_HANDLE ftHandle, uint8* buffer, uint16 bufferSize, uint16* sizeTransferred, BOOL isEndTransaction);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPIMaster_SingleReadWrite(FT_HANDLE ftHandle, uint8* readBuffer, uint8* writeBuffer, uint16 bufferSize, uint16* sizeTransferred, BOOL isEndTransaction);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPIMaster_MultiReadWrite(FT_HANDLE ftHandle, uint8* readBuffer, uint8* writeBuffer, uint8 singleWriteBytes, uint16 multiWriteBytes, uint16 multiReadBytes, uint32* sizeOfRead);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPISlave_Init(FT_HANDLE ftHandle);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPISlave_InitEx(FT_HANDLE ftHandle, SPI_SlaveProtocol protocolOpt);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPISlave_SetMode(FT_HANDLE ftHandle, FT4222_SPICPOL cpol, FT4222_SPICPHA cpha);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPISlave_GetRxStatus(FT_HANDLE ftHandle, uint16* pRxSize);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPISlave_Read(FT_HANDLE ftHandle, uint8* buffer, uint16 bufferSize, uint16* sizeOfRead);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPISlave_Write(FT_HANDLE ftHandle, uint8* buffer, uint16 bufferSize, uint16* sizeTransferred);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPI_Reset(FT_HANDLE ftHandle);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPI_ResetTransaction(FT_HANDLE ftHandle, uint8 spiIdx);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_SPI_SetDrivingStrength(FT_HANDLE ftHandle, SPI_DrivingStrength clkStrength, SPI_DrivingStrength ioStrength, SPI_DrivingStrength ssoStrength);
// FT4222 I2C Functions
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CMaster_Init(FT_HANDLE ftHandle, uint32 kbps);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CMaster_Read(FT_HANDLE ftHandle, uint16 deviceAddress, uint8* buffer, uint16 bufferSize, uint16* sizeTransferred);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CMaster_Write(FT_HANDLE ftHandle, uint16 deviceAddress, uint8* buffer, uint16 bufferSize, uint16* sizeTransferred);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CMaster_ReadEx(FT_HANDLE ftHandle, uint16 deviceAddress, uint8 flag, uint8* buffer, uint16 bufferSize, uint16* sizeTransferred);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CMaster_WriteEx(FT_HANDLE ftHandle, uint16 deviceAddress, uint8 flag, uint8* buffer, uint16 bufferSize, uint16* sizeTransferred);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CMaster_Reset(FT_HANDLE ftHandle);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CMaster_GetStatus(FT_HANDLE ftHandle, uint8 *controllerStatus);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CMaster_ResetBus(FT_HANDLE ftHandle);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CSlave_Init(FT_HANDLE ftHandle);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CSlave_Reset(FT_HANDLE ftHandle);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CSlave_GetAddress(FT_HANDLE ftHandle, uint8* addr);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CSlave_SetAddress(FT_HANDLE ftHandle, uint8 addr);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CSlave_GetRxStatus(FT_HANDLE ftHandle, uint16* pRxSize);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CSlave_Read(FT_HANDLE ftHandle, uint8* buffer, uint16 bufferSize, uint16* sizeTransferred);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CSlave_Write(FT_HANDLE ftHandle, uint8* buffer, uint16 bufferSize, uint16* sizeTransferred);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CSlave_SetClockStretch(FT_HANDLE ftHandle, BOOL enable);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_I2CSlave_SetRespWord(FT_HANDLE ftHandle, uint8 responseWord);
// FT4222 GPIO Functions
LIBFT4222_API FT4222_STATUS WINAPI FT4222_GPIO_Init(FT_HANDLE ftHandle, GPIO_Dir gpioDir[4]);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_GPIO_Read(FT_HANDLE ftHandle, GPIO_Port portNum, BOOL* value);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_GPIO_Write(FT_HANDLE ftHandle, GPIO_Port portNum, BOOL bValue);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_GPIO_SetInputTrigger(FT_HANDLE ftHandle, GPIO_Port portNum, GPIO_Trigger trigger);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_GPIO_GetTriggerStatus(FT_HANDLE ftHandle, GPIO_Port portNum, uint16* queueSize);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_GPIO_ReadTriggerQueue(FT_HANDLE ftHandle, GPIO_Port portNum, GPIO_Trigger* events, uint16 readSize, uint16* sizeofRead);
LIBFT4222_API FT4222_STATUS WINAPI FT4222_GPIO_SetWaveFormMode(FT_HANDLE ftHandle, BOOL enable);
#ifdef __cplusplus
}
#endif
//------------------------------------------------------------------------------
#endif //_FTDI_LIB_FT4222_H_

3393
PMIC_Tool/PMIC_Cmd_Tool/include/ftd2xx.h Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
PMIC_Tool/PMIC_Cmd_Tool/lib/LibFT4222-64.lib Normal file
View File

Binary file not shown.

BIN
PMIC_Tool/PMIC_Cmd_Tool/lib/ftd2xx.lib Normal file
View File

Binary file not shown.