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

update

Browse Source
This commit is contained in:
woody
2026-07-02 20:51:17 +09:00
parent c65995c589
commit fdc26f8b45
7 changed files with 622 additions and 598 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Src/0_Tool/PMIC_Tool/PMIC_Cmd_Tool/PMIC_Cmd_Tool.vcxproj
View File

@@ -165,10 +165,13 @@ xcopy /y /e "$(OutDir)*.*" "%TARGET_PATH%\"</Command>
<ItemGroup>
<ClInclude Include="external\FT4222\include\ftd2xx.h" />
<ClInclude Include="external\FT4222\include\LibFT4222.h" />
<ClInclude Include="include\PMIC_Common_Include.h" />
<ClInclude Include="include\PMIC_Function.h" />
<ClInclude Include="include\PMIC_Reg_Map.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\PMIC_Cmd_Tool.cpp" />
<ClCompile Include="src\PMIC_Function.cpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">

9
Src/0_Tool/PMIC_Tool/PMIC_Cmd_Tool/PMIC_Cmd_Tool.vcxproj.filters
View File

@@ -24,10 +24,19 @@
<ClInclude Include="external\FT4222\include\ftd2xx.h">
<Filter>헤더 파일</Filter>
</ClInclude>
<ClInclude Include="include\PMIC_Function.h">
<Filter>헤더 파일</Filter>
</ClInclude>
<ClInclude Include="include\PMIC_Common_Include.h">
<Filter>헤더 파일</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\PMIC_Cmd_Tool.cpp">
<Filter>소스 파일</Filter>
</ClCompile>
<ClCompile Include="src\PMIC_Function.cpp">
<Filter>소스 파일</Filter>
</ClCompile>
</ItemGroup>
</Project>

23
Src/0_Tool/PMIC_Tool/PMIC_Cmd_Tool/include/PMIC_Common_Include.h Normal file
View File

@@ -0,0 +1,23 @@
#ifndef PMIC_COMMON_INCLUDE_H // Header Guard: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ߺ<EFBFBD> include <20>Ǵ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
#define PMIC_COMMON_INCLUDE_H
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Լ<EFBFBD> <20>̿<EFBFBD><CCBF><EFBFBD> <20><><EFBFBD><EFBFBD>
#include <windows.h>
//Sleep(1); // 1ms <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//Sleep(10); // 10ms <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//Sleep(100); // 100ms <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//Sleep(1000); // 1s <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//Sleep(10000); // 10s <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// FT4222 <20><><EFBFBD><EFBFBD>
#include "ftd2xx.h"
#include "LibFT4222.h"
#endif // PMIC_COMMON_INCLUDE_H

32
Src/0_Tool/PMIC_Tool/PMIC_Cmd_Tool/include/PMIC_Function.h Normal file
View File

@@ -0,0 +1,32 @@
#ifndef PMIC_FUNCTION_H // Header Guard: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ߺ<EFBFBD> include <20>Ǵ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
#define PMIC_FUNCTION_H
// PMIC Common Include
#include "PMIC_Common_Include.h"
void toBinaryString(uint8_t val, char* outBuf); // 8<><38>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> "0000_0000" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ڿ<EFBFBD><DABF><EFBFBD> <20><>ȯ
uint8_t calcCRC8(uint8_t addrWithRw, uint8_t* data, int len); // CRC8 <20><><EFBFBD><EFBFBD> (<28><><EFBFBD>׽<EFBFBD> 0x07, <20>ʱⰪ 0x00)
void currentPreciseTime(char* buf, size_t len); // <20><>(00)<29><> <20>и<EFBFBD><D0B8><EFBFBD>(000) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (<28><>: 45.123)
void currentTime(char* buf, size_t len); // <20><><EFBFBD><EFBFBD> <20>ð<EFBFBD><C3B0><EFBFBD> "HH:MM:SS" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> buf<75><66> <20><><EFBFBD><EFBFBD>
void logPacket(const char* dir, uint8_t* data, int size, int hasCrc); // <20>α<EFBFBD> <20><><EFBFBD><EFBFBD> (Ŀ<><C4BF><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
int parseCommand(const char* dir); // <20><><EFBFBD>ɾ<EFBFBD> <20>Ǻ<EFBFBD> (I2C_WRITE/w, I2C_READ/r)
void PMIC_I2C_Write(FT_HANDLE ftHandle, uint8_t slaveAddr, uint8_t regAddr, uint8_t value); // Address<73><73> 1<><31><EFBFBD><EFBFBD>Ʈ Write with CRC, <20>׸<EFBFBD><D7B8><EFBFBD> Address<73><73> Read<61>ؼ<EFBFBD> Write<74><65> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
uint8_t PMIC_I2C_Read(FT_HANDLE ftHandle, uint8_t slaveAddr, uint8_t regAddr); // Address<73><73><EFBFBD><EFBFBD> 1<><31><EFBFBD><EFBFBD>Ʈ Read (CRC <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
bool Run_DebugMode_On(FT_HANDLE ftHandle); // Enter Debug Mode On
bool Run_DebugMode_Off(FT_HANDLE ftHandle); // Enter Debug Mode Off
void Run_CheckFaults(FT_HANDLE ftHandle); // Check All Fault Registers
void Run_ReadChipInfo(FT_HANDLE ftHandle); // Read Chip Information (OTP/Version)
void Irq_Clear(FT_HANDLE ftHandle); // PMIC Irq Clear
void Set_Reset(FT_HANDLE ftHandle); // PMIC Set Reset
void Set_Error(FT_HANDLE ftHandle); // PMIC Set Error
void Set_CRC_On(FT_HANDLE ftHandle); // PMIC Set CRC ON
void Set_CRC_Off(FT_HANDLE ftHandle); // PMIC Set CRC OFF
void Set_FLT_MASK_B(FT_HANDLE ftHandle); // PMIC Set FLT_MASK_B
void Handle_ManualCommand(FT_HANDLE ftHandle, char* line); // Manual Command
#endif // PMIC_FUNCTION_H

4
Src/0_Tool/PMIC_Tool/PMIC_Cmd_Tool/include/PMIC_Reg_Map.h
View File

@@ -1,8 +1,8 @@
#pragma once
//#pragma once
#ifndef PMIC_REG_MAP_H // Header Guard: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ߺ<EFBFBD> include <20>Ǵ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
#define PMIC_REG_MAP_H
#include <stdint.h>
//#include <stdint.h>
/* ============================================================================
PMIC I2C Slave Addresses

599
Src/0_Tool/PMIC_Tool/PMIC_Cmd_Tool/src/PMIC_Cmd_Tool.cpp
View File

@@ -1,61 +1,10 @@
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
// 딜레이 함수 이용을 위해
#include <windows.h>
//Sleep(1); // 1ms 딜레이
//Sleep(10); // 10ms 딜레이
//Sleep(100); // 100ms 딜레이
//Sleep(1000); // 1s 딜레이
//Sleep(10000); // 10s 딜레이
// FT4222 헤더
#include "ftd2xx.h"
#include "LibFT4222.h"
// PMIC Register Map
#include "PMIC_Reg_Map.h"
typedef enum {
MENU_EXIT = 0,
MENU_DEBUG_MODE = 1,
MENU_CHECK_FAULTS = 2,
MENU_READ_INFO = 3,
// Add more features here...
} PMIC_MENU;

#include "PMIC_Common_Include.h"
#include "PMIC_Function.h"
// Function Prototypes
FT_HANDLE InitializeFT4222();
void currentPreciseTime(char* buf, size_t len); // 초(00)와 밀리초(000) 포맷으로 저장 (예: 45.123)
void currentTime(char* buf, size_t len); // 현재 시간을 "HH:MM:SS" 형식으로 buf에 저장
void logPacket(const char* dir, uint8_t* data, int size, int hasCrc); // 로그 출력 (커스텀 포맷)
uint8_t calcCRC8(uint8_t addrWithRw, uint8_t* data, int len); // CRC8 계산 (다항식 0x07, 초기값 0x00)
int parseCommand(const char* dir); // 명령어 판별 (I2C_WRITE/w, I2C_READ/r)
void PMIC_I2C_Write(FT_HANDLE ftHandle, uint8_t slaveAddr, uint8_t regAddr, uint8_t value); // Address에 1바이트 Write with CRC, 그리고 Address를 Read해서 Write한 값과 비교
uint8_t PMIC_I2C_Read(FT_HANDLE ftHandle, uint8_t slaveAddr, uint8_t regAddr); // Address에서 1바이트 Read (CRC 계산 없음)
void toBinaryString(uint8_t val, char* outBuf); // 8비트 데이터를 "0000_0000" 형식의 문자열로 변환
bool Run_DebugMode_On(FT_HANDLE ftHandle); // Enter Debug Mode On
bool Run_DebugMode_Off(FT_HANDLE ftHandle); // Enter Debug Mode Off
void Run_CheckFaults(FT_HANDLE ftHandle); // Check All Fault Registers
void Run_ReadChipInfo(FT_HANDLE ftHandle); // Read Chip Information (OTP/Version)
void Irq_Clear(FT_HANDLE ftHandle); // PMIC Irq Clear
void Set_Reset(FT_HANDLE ftHandle); // PMIC Set Reset
void Set_Error(FT_HANDLE ftHandle); // PMIC Set Error
void Set_CRC_On(FT_HANDLE ftHandle); // PMIC Set CRC ON
void Set_CRC_Off(FT_HANDLE ftHandle); // PMIC Set CRC OFF
void Set_FLT_MASK_B(FT_HANDLE ftHandle); // PMIC Set FLT_MASK_B
void Handle_ManualCommand(FT_HANDLE ftHandle, char* line); // Manual Command
int main()
{
char line[256];
@@ -262,545 +211,3 @@ FT_HANDLE InitializeFT4222() {
return handle;
#endif
}
// 초(00)와 밀리초(000) 포맷으로 저장 (예: 45.123)
void currentPreciseTime(char* buf, size_t len)
{
SYSTEMTIME st;
GetLocalTime(&st); // 시스템의 현재 지역 시간(밀리초 포함)을 가져옴
sprintf_s(buf, len, "%02d.%03d", st.wSecond, st.wMilliseconds);
}
// 현재 시간을 "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[16]; // ss.fff 형식이므로 16바이트면 충분합니다.
currentPreciseTime(timeBuf, sizeof(timeBuf)); // 수정된 시간 함수 호출
//currentTime(timeBuf, sizeof(timeBuf));
// 1. PMIC I2C WRITE (보통 RegAddr + Value + CRC 순서)
if (strcmp(dir, "PMIC I2C WRITE") == 0 && size >= 3) {
printf("[%s] [%s] [RegAddr: 0x%02X] [Value: 0x%02X] [CRC: 0x%02X]\n",
timeBuf, dir, data[0], data[1], data[2]);
return;
}
// 2. PMIC I2C READ (보통 Value + CRC 순서)
if (strcmp(dir, "PMIC I2C READ") == 0 && size >= 2) {
printf("[%s] [%s] [Value: 0x%02X] [CRC: 0x%02X]\n",
timeBuf, dir, data[0], data[1]);
return;
}
// 3. 기본 출력 (위의 조건에 해당하지 않는 기타 패킷)
printf("[%s] [%s] ", timeBuf, dir);
for (int i = 0; i < size; i++) {
if (hasCrc && i == size - 1)
printf("[CRC: 0x%02X] ", data[i]);
else if (i == 0 && size > 1) // 첫 바이트를 Value로 가정할 경우
printf("[Value: 0x%02X] ", data[i]);
else
printf("0x%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 Fail\n");
return;
}
else {
//logPacket("PMIC I2C WRITE", bytes, len, 1);
}
// Read 해서 값 비교하기 OFF
#if 0
// 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 Fail\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 Fail\n");
return;
}
else {
logPacket("PMIC I2C READ ", rx, transferred, 0);
// 첫 번째 바이트와 Write 값 비교
if (rx[0] == value) {
printf("OK Pass: [Write Value = 0x%02X], [Read Value = 0x%02X]\n", value, rx[0]);
}
else {
printf("NG: [Write Value = 0x%02X], [Read Value = 0x%02X]\n", value, rx[0]);
}
}
#endif
}
// Address에서 1바이트 Read (CRC 계산 없음)
uint8_t PMIC_I2C_Read(FT_HANDLE ftHandle, uint8_t slaveAddr, uint8_t regAddr)
{
uint16 transferred = 0;
FT4222_STATUS st;
uint8_t rx[2] = { 0xFF, 0xFF }; // 초기값 에러 설정
// 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 Fail\n");
return 0xFF;
}
// 2.Register Address에서 2바이트 Read (Value + CRC)
st = FT4222_I2CMaster_Read(ftHandle, slaveAddr, rx, 2, &transferred);
if (st != FT4222_OK) {
printf("I2C Read Fail\n");
return 0xFF;
}
else {
// 2진수 변환 로직 적용
char binStr[10]; // "0000_0000" + null
toBinaryString(rx[0], binStr);
printf("Read [Addr: 0x%02X] [Value Hex: 0x%02X -> Bin: %s] [CRC: 0x%02X]\n", regAddr, rx[0], binStr, rx[1]);
return rx[0];
}
}
// 8비트 데이터를 "0000_0000" 형식의 문자열로 변환
void toBinaryString(uint8_t val, char* outBuf)
{
for (int i = 0; i < 8; i++) {
// 상위 비트부터 검사하여 '1' 또는 '0' 채우기
outBuf[i + (i >= 4 ? 1 : 0)] = (val & (1 << (7 - i))) ? '1' : '0';
}
outBuf[4] = '_'; // 가독성을 위한 언더바 삽입
outBuf[9] = '\0'; // 문자열 끝 지정
}
// Set Debug Mode On
bool Run_DebugMode_On(FT_HANDLE ftHandle) {
uint8_t readVal = 0;
int retryCount = 0;
const int maxRetries = 300; // 과도한 반복 방지 (50회면 충분합니다)
printf("\n[PROCESS] Checking PMIC Communication...");
// 사전 통신 검사: 정상적인 리드 값이 올 때까지 무한 대기 (또는 특정 횟수)
while (1) {
readVal = PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x02); //0x102 - IO_MODECTRL Read시 디폴트 0x65
if (readVal != 0xFF) {
printf("\n[SUCCESS] Device detected! (Current Reg 0x02: 0x%02X)\n", readVal);
break; // 통신 성공 시 검사 루프 탈출
}
printf("."); // 대기 중임을 알리는 점 표시
Sleep(1000); // 1초 간격으로 확인
// 만약 무한 대기가 싫다면 별도의 카운터를 써서 break
}
// 실제 디버그 모드 진입 시퀀스 시작
printf("[PROCESS] Attempting to Enter Debug Mode On\n");
do {
retryCount++;
// Page01 선택
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01);
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01);
// 디버그 모드 진입 명령 (0x25)
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x02, 0x25); //0x102 - IO_MODECTRL
// 딜레이 및 확인 (Verification)
Sleep(50);
// 직접 읽어서 확인
readVal = PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x02);
if (readVal == 0x25) {;
printf(" >>> Success! Debug Mode On[0x%02X] at cycle %d. <<<\n", readVal, retryCount);
return true;
}
printf("[Retry %d]...\n", retryCount);
} while (retryCount < maxRetries);
printf("\n[ERRPR] Failed to enter Debug Mode On\n");
return false;
}
// Set Debug Mode Off
bool Run_DebugMode_Off(FT_HANDLE ftHandle) {
uint8_t readVal = 0;
int retryCount = 0;
const int maxRetries = 100; // 과도한 반복 방지 (50회면 충분합니다)
printf("\n[PROCESS] Checking PMIC Communication...");
// 사전 통신 검사: 정상적인 리드 값이 올 때까지 무한 대기 (또는 특정 횟수)
while (1) {
readVal = PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x02); //0x102 - IO_MODECTRL Read시 Debug On으로 0x25
if (readVal != 0xFF) {
printf("\n[SUCCESS] Device detected! (Current Reg 0x02: 0x%02X)\n", readVal);
break; // 통신 성공 시 검사 루프 탈출
}
printf("."); // 대기 중임을 알리는 점 표시
Sleep(1000); // 1초 간격으로 확인
// 만약 무한 대기가 싫다면 별도의 카운터를 써서 break
}
// 실제 디버그 모드 진입 시퀀스 시작
printf("[PROCESS] Attempting to Enter Debug Mode Off...\n");
do {
retryCount++;
// Page01 선택
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01);
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01);
// 디버그 모드 해제 명령 (0x65)
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x02, 0x65); //0x102 - IO_MODECTRL
// 딜레이 및 확인 (Verification)
Sleep(50);
// 직접 읽어서 확인
readVal = PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x02);
if (readVal == 0x65) {
printf(" >>> Success! Debug Mode Off[0x%02X] at cycle %d. <<<\n", readVal, retryCount);
return true;
}
printf("[Retry %d]...\n", retryCount);
} while (retryCount < maxRetries);
printf("\n[ERRPR] Failed Debug Mode Off\n");
return false;
}
// Check All Fault Registers
void Run_CheckFaults(FT_HANDLE ftHandle)
{
printf("\n[PROCESS] Scanning all Fault Registers...\n");
///////////////////////
//Regulation Register//
///////////////////////
printf("[OTP Version]\n");
//OTP Version
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x02); //0x00 - Page0x02
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x02); //0x00 - Page0x02
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x22); //0x222 - OTP_VERSION_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x23); //0x223 - OTP_VERSION_REGU
//Fault register data: Regulation Register, Address 0x040 ~ 0x049
printf("[Regulation FLT Register]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x40); //0x040 - FLT_RECORD_OTP
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x41); //0x041 - FLT_RECORD_TEMP
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x42); //0x042 - FLT_RECORD_BUCK1
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x43); //0x043 - FLT_RECORD_BUCK2
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x44); //0x044 - FLT_RECORD_BUCK3
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x45); //0x045 - FLT_RECORD_BUCK4
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x46); //0x046 - FLT_RECORD_BUCK5
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x47); //0x047 - FLT_RECORD_LDO
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x48); //0x048 - FLT_RECORD_IF
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x49); //0x049 - FLT_RECORD_LDO_DISC_DET
///////////////////////
//Protection Register//
///////////////////////
//Fault register data: Protection Register, Address 0x010 ~0x014, 0x019 ~0x021
printf("[Protection FLT Register]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x10); //0x010 - FUSA_STATUS_1
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x11); //0x011 - FUSA_STATUS_2
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x12); //0x012 - FUSA_STATUS_2A
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x13); //0x013 - FUSA_STATUS_3
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x14); //0x014 - FUSA_STATUS_4
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x19); //0x019 - FLT_RECORD_A
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1A); //0x01A - FLT_RECORD_B
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1B); //0x01B - FLT_RECORD_GND_AVIN
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1C); //0x01C - FLT_RECORD_BG_Temp
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1D); //0x01D - FLT_RECORD_IntLDOs
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1E); //0x01E - FLT_RECORD_ExtLDOs
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1F); //0x01F - FLT_RECORD_BUCKS_B
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x20); //0x020 - FLT_RECORD_BUCKS_A
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x21); //0x021 - FLT_RECORD_ExtINPs_7_0
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x28); //0x028 - OTP_RWADDR
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x2A); //0x02A - OTP_FLT_RECORD
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x02); //0x102 - IO_MODECTRL
///////////////////////
// Debug Register //
///////////////////////
//Debug Regulation Chip Name etc
printf("[Regulation Chip ID]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x00); //0x000 - IO_PAGE_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x01); //0x001 - IO_CHIPNAME_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x02); //0x002 - IO_CHIPVERSION_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x03); //0x003 - IO_DIEID3_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x04); //0x004 - IO_DIEID2_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x05); //0x005 - IO_DIEID1_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x06); //0x006 - IO_DIEID0_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x0A); //0x00A - OTP_VERSION_REGU
//Debug Protection Chip Name etc
printf("[Protection Chip ID]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x00); //0x000 - IO_PAGE_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x01); //0x001 - IO_CHIPNAME_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x02); //0x002 - IO_CHIPVERSION_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x03); //0x003 - IO_DIEID3_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x04); //0x004 - IO_DIEID2_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x05); //0x005 - IO_DIEID1_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x06); //0x006 - IO_DIEID0_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x0A); //0x00A - OTP_VERSION_REGU
}
// Read Chip Information (OTP/Version)
void Run_ReadChipInfo(FT_HANDLE ftHandle)
{
//Regulation Register
printf("[OTP Version]\n");
//OTP Version
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x02); //0x00 - Page0x02
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x02); //0x00 - Page0x02
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x22); //0x222 - OTP_VERSION_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x23); //0x223 - OTP_VERSION_REGU
//Debug Regulation Chip Name etc
printf("[Regulation Chip ID]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x00); //0x000 - IO_PAGE_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x01); //0x001 - IO_CHIPNAME_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x02); //0x002 - IO_CHIPVERSION_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x03); //0x003 - IO_DIEID3_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x04); //0x004 - IO_DIEID2_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x05); //0x005 - IO_DIEID1_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x06); //0x006 - IO_DIEID0_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x0A); //0x00A - OTP_VERSION_REGU
//Debug Protection Chip Name etc
printf("[Protection Chip ID]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x00); //0x000 - IO_PAGE_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x01); //0x001 - IO_CHIPNAME_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x02); //0x002 - IO_CHIPVERSION_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x03); //0x003 - IO_DIEID3_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x04); //0x004 - IO_DIEID2_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x05); //0x005 - IO_DIEID1_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x06); //0x006 - IO_DIEID0_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x0A); //0x00A - OTP_VERSION_REGU
}
// PMIC Irq Clear
void Irq_Clear(FT_HANDLE ftHandle)
{
//Regulation Fault Register Clear : Regulation Register, Address 0x040 ~ 0x049
printf("[Regulation FLT Register Clear]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x40, 0x00); //0x040 - FLT_RECORD_OTP
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x41, 0x00); //0x041 - FLT_RECORD_TEMP
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x42, 0x00); //0x042 - FLT_RECORD_BUCK1
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x43, 0x00); //0x043 - FLT_RECORD_BUCK2
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x44, 0x00); //0x044 - FLT_RECORD_BUCK3
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x45, 0x00); //0x045 - FLT_RECORD_BUCK4
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x46, 0x00); //0x046 - FLT_RECORD_BUCK5
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x47, 0x00); //0x047 - FLT_RECORD_LDO
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x48, 0x00); //0x048 - FLT_RECORD_IF
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x49, 0x00); //0x049 - FLT_RECORD_LDO_DISC_DET
//Fault register data: Protection Register, Address 0x010 ~0x014, 0x019 ~0x021
printf("[Protection FLT Register Clear]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x14); //0x014 - FUSA_STATUS_4
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x19); //0x019 - FLT_RECORD_A
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1A); //0x01A - FLT_RECORD_B
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1B); //0x01B - FLT_RECORD_GND_AVIN
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1C); //0x01C - FLT_RECORD_BG_Temp
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1D); //0x01D - FLT_RECORD_IntLDOs
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1E); //0x01E - FLT_RECORD_ExtLDOs
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1F); //0x01F - FLT_RECORD_BUCKS_B
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x20); //0x020 - FLT_RECORD_BUCKS_A
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x21); //0x021 - FLT_RECORD_ExtINPs_7_0
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x2A); //0x02A - OTP_FLT_RECORD
}
// PMIC Set Reset
void Set_Reset(FT_HANDLE ftHandle)
{
printf("PMIC Set Reset\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x0C, 0x00); //0x0C - FUSA_CTRL_5
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x0C, 0x05); //0x0C - FUSA_CTRL_5
}
// PMIC Set Error
void Set_Error(FT_HANDLE ftHandle)
{
printf("PMIC Set Error\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x0C, 0x00); //0x0C - FUSA_CTRL_5
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x0C, 0x06); //0x0C - FUSA_CTRL_5
}
// PMIC Set FLT_MASK_B
void Set_FLT_MASK_B(FT_HANDLE ftHandle)
{
printf("PMIC Set FLT_MASK_B\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x2C, 0x3F); //0x2C - FLT_MASK_B
}
// PMIC Set CRC On
void Set_CRC_On(FT_HANDLE ftHandle)
{
printf("PMIC Set CRC ON\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x05, 0x01); //0x05 - IO_FUNC_CFG
}
// PMIC Set CRC Off
void Set_CRC_Off(FT_HANDLE ftHandle)
{
printf("PMIC Set CRC OFF\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x05, 0x00); //0x05 - IO_FUNC_CFG
}
// Manual Command
void Handle_ManualCommand(FT_HANDLE ftHandle, char* line)
{
char* context = NULL;
char* token = strtok_s(line, " ", &context);
if (!token) return;
int command = parseCommand(token); // 1: WRITE, 2: READ
if (command == 1 || command == 2) {
printf("\n[MANUAL] Executing I2C %s...\n", (command == 1) ? "WRITE" : "READ");
// 여기에 기존에 작성하셨던 w/r 파싱 및 실행 로직을 넣으시면 됩니다.
// 예: 토큰을 계속 잘라서 주소와 데이터를 추출 후 FT4222_I2CMaster_... 호출
}
else {
printf("\n[ERROR] Invalid command or menu number. Please try again.\n");
}
}

550
Src/0_Tool/PMIC_Tool/PMIC_Cmd_Tool/src/PMIC_Function.cpp Normal file
View File

@@ -0,0 +1,550 @@
#include "PMIC_Common_Include.h"
#include "PMIC_Reg_Map.h"
#include "PMIC_Function.h"
// 8<><38>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> "0000_0000" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ڿ<EFBFBD><DABF><EFBFBD> <20><>ȯ
void toBinaryString(uint8_t val, char* outBuf)
{
for (int i = 0; i < 8; i++) {
// <20><><EFBFBD><EFBFBD> <20><>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20>˻<EFBFBD><CBBB>Ͽ<EFBFBD> '1' <20>Ǵ<EFBFBD> '0' ä<><C3A4><EFBFBD><EFBFBD>
outBuf[i + (i >= 4 ? 1 : 0)] = (val & (1 << (7 - i))) ? '1' : '0';
}
outBuf[4] = '_'; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
outBuf[9] = '\0'; // <20><><EFBFBD>ڿ<EFBFBD> <20><> <20><><EFBFBD><EFBFBD>
}
// CRC8 <20><><EFBFBD><EFBFBD> (<28><><EFBFBD>׽<EFBFBD> 0x07, <20>ʱⰪ 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;
}
// <20><>(00)<29><> <20>и<EFBFBD><D0B8><EFBFBD>(000) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (<28><>: 45.123)
void currentPreciseTime(char* buf, size_t len)
{
SYSTEMTIME st;
GetLocalTime(&st); // <20>ý<EFBFBD><C3BD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ð<EFBFBD>(<28>и<EFBFBD><D0B8><EFBFBD> <20><><EFBFBD><EFBFBD>)<29><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
sprintf_s(buf, len, "%02d.%03d", st.wSecond, st.wMilliseconds);
}
// <20><><EFBFBD><EFBFBD> <20>ð<EFBFBD><C3B0><EFBFBD> "HH:MM:SS" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> buf<75><66> <20><><EFBFBD><EFBFBD>
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 <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
#else
localtime_r(&now, &tm_buf); // Linux/Unix <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
#endif
strftime(buf, len, "%H:%M:%S", &tm_buf);
}
// <20>α<EFBFBD> <20><><EFBFBD><EFBFBD> (Ŀ<><C4BF><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
void logPacket(const char* dir, uint8_t* data, int size, int hasCrc)
{
if (dir == nullptr || data == nullptr || size <= 0)
return;
char timeBuf[16]; // ss.fff <20><><EFBFBD><EFBFBD><EFBFBD>̹Ƿ<CCB9> 16<31><36><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.
currentPreciseTime(timeBuf, sizeof(timeBuf)); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ð<EFBFBD> <20>Լ<EFBFBD> ȣ<><C8A3>
//currentTime(timeBuf, sizeof(timeBuf));
// 1. PMIC I2C WRITE (<28><><EFBFBD><EFBFBD> RegAddr + Value + CRC <20><><EFBFBD><EFBFBD>)
if (strcmp(dir, "PMIC I2C WRITE") == 0 && size >= 3) {
printf("[%s] [%s] [RegAddr: 0x%02X] [Value: 0x%02X] [CRC: 0x%02X]\n",
timeBuf, dir, data[0], data[1], data[2]);
return;
}
// 2. PMIC I2C READ (<28><><EFBFBD><EFBFBD> Value + CRC <20><><EFBFBD><EFBFBD>)
if (strcmp(dir, "PMIC I2C READ") == 0 && size >= 2) {
printf("[%s] [%s] [Value: 0x%02X] [CRC: 0x%02X]\n",
timeBuf, dir, data[0], data[1]);
return;
}
// 3. <20>⺻ <20><><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD> <20><><EFBFBD>ǿ<EFBFBD> <20>ش<EFBFBD><D8B4><EFBFBD><EFBFBD><EFBFBD> <20>ʴ<EFBFBD> <20><>Ÿ <20><>Ŷ)
printf("[%s] [%s] ", timeBuf, dir);
for (int i = 0; i < size; i++) {
if (hasCrc && i == size - 1)
printf("[CRC: 0x%02X] ", data[i]);
else if (i == 0 && size > 1) // ù <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> Value<75><65> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
printf("[Value: 0x%02X] ", data[i]);
else
printf("0x%02X ", data[i]);
}
printf("\n");
}
// <20><><EFBFBD>ɾ<EFBFBD> <20>Ǻ<EFBFBD> (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<73><73> 1<><31><EFBFBD><EFBFBD>Ʈ Write with CRC, <20>׸<EFBFBD><D7B8><EFBFBD> Address<73><73> Read<61>ؼ<EFBFBD> Write<74><65> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
void PMIC_I2C_Write(FT_HANDLE ftHandle, uint8_t slaveAddr, uint8_t regAddr, uint8_t value)
{
uint8_t bytes[3];
int len = 0;
// Write <20><>Ŷ: [RegAddr] [Value] [CRC]
bytes[len++] = regAddr;
bytes[len++] = value;
uint8_t addrWithRw = (slaveAddr << 1) | 0x00; // Write <20>ּ<EFBFBD>
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 Fail\n");
return;
}
else {
//logPacket("PMIC I2C WRITE", bytes, len, 1);
}
// Read <20>ؼ<EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϱ<EFBFBD> OFF
#if 0
// Register Address <20>ٽ<EFBFBD> Write (Read <20><><EFBFBD><EFBFBD> <20><>ġ <20><><EFBFBD><EFBFBD>)
uint8_t regOnly[1] = { regAddr };
st = FT4222_I2CMaster_Write(ftHandle, slaveAddr, regOnly, 1, &transferred);
if (st != FT4222_OK) {
printf("Read<61><64> Address Write Fail\n");
return;
}
// Register Address<73><73><EFBFBD><EFBFBD> 2<><32><EFBFBD><EFBFBD>Ʈ Read
uint8_t rx[2] = { 0 };
st = FT4222_I2CMaster_Read(ftHandle, slaveAddr, rx, 2, &transferred);
if (st != FT4222_OK) {
printf("I2C Read Fail\n");
return;
}
else {
logPacket("PMIC I2C READ ", rx, transferred, 0);
// ù <20><>° <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> Write <20><> <20><><EFBFBD><EFBFBD>
if (rx[0] == value) {
printf("OK Pass: [Write Value = 0x%02X], [Read Value = 0x%02X]\n", value, rx[0]);
}
else {
printf("NG: [Write Value = 0x%02X], [Read Value = 0x%02X]\n", value, rx[0]);
}
}
#endif
}
// Address<73><73><EFBFBD><EFBFBD> 1<><31><EFBFBD><EFBFBD>Ʈ Read (CRC <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
uint8_t PMIC_I2C_Read(FT_HANDLE ftHandle, uint8_t slaveAddr, uint8_t regAddr)
{
uint16 transferred = 0;
FT4222_STATUS st;
uint8_t rx[2] = { 0xFF, 0xFF }; // <20>ʱⰪ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
// 1.Register Address<73><73> <20><><EFBFBD><EFBFBD> Write (Read <20><><EFBFBD><EFBFBD> <20><>ġ <20><><EFBFBD><EFBFBD>)
uint8_t regOnly[1] = { regAddr };
st = FT4222_I2CMaster_Write(ftHandle, slaveAddr, regOnly, 1, &transferred);
if (st != FT4222_OK) {
printf("Read Address Write Fail\n");
return 0xFF;
}
// 2.Register Address<73><73><EFBFBD><EFBFBD> 2<><32><EFBFBD><EFBFBD>Ʈ Read (Value + CRC)
st = FT4222_I2CMaster_Read(ftHandle, slaveAddr, rx, 2, &transferred);
if (st != FT4222_OK) {
printf("I2C Read Fail\n");
return 0xFF;
}
else {
// 2<><32><EFBFBD><EFBFBD> <20><>ȯ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
char binStr[10]; // "0000_0000" + null
toBinaryString(rx[0], binStr);
printf("Read [Addr: 0x%02X] [Value Hex: 0x%02X -> Bin: %s] [CRC: 0x%02X]\n", regAddr, rx[0], binStr, rx[1]);
return rx[0];
}
}
// Set Debug Mode On
bool Run_DebugMode_On(FT_HANDLE ftHandle) {
uint8_t readVal = 0;
int retryCount = 0;
const int maxRetries = 300; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ݺ<EFBFBD> <20><><EFBFBD><EFBFBD> (50ȸ<30><C8B8> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>)
printf("\n[PROCESS] Checking PMIC Communication...");
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>˻<EFBFBD>: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (<28>Ǵ<EFBFBD> Ư<><C6AF> Ƚ<><C8BD>)
while (1) {
readVal = PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x02); //0x102 - IO_MODECTRL Read<61><64> <20><><EFBFBD><EFBFBD>Ʈ 0x65
if (readVal != 0xFF) {
printf("\n[SUCCESS] Device detected! (Current Reg 0x02: 0x%02X)\n", readVal);
break; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20>˻<EFBFBD> <20><><EFBFBD><EFBFBD> Ż<><C5BB>
}
printf("."); // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>˸<EFBFBD><CBB8><EFBFBD> <20><> ǥ<><C7A5>
Sleep(1000); // 1<><31> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ȯ<><C8AE>
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>Ⱑ <20>ȴٸ<C8B4> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ī<><C4AB><EFBFBD>͸<EFBFBD> <20>Ἥ break
}
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
printf("[PROCESS] Attempting to Enter Debug Mode On\n");
do {
retryCount++;
// Page01 <20><><EFBFBD><EFBFBD>
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01);
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01);
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (0x25)
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x02, 0x25); //0x102 - IO_MODECTRL
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> Ȯ<><C8AE> (Verification)
Sleep(50);
// <20><><EFBFBD><EFBFBD> <20>о Ȯ<><C8AE>
readVal = PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x02);
if (readVal == 0x25) {
;
printf(" >>> Success! Debug Mode On[0x%02X] at cycle %d. <<<\n", readVal, retryCount);
return true;
}
printf("[Retry %d]...\n", retryCount);
} while (retryCount < maxRetries);
printf("\n[ERRPR] Failed to enter Debug Mode On\n");
return false;
}
// Set Debug Mode Off
bool Run_DebugMode_Off(FT_HANDLE ftHandle) {
uint8_t readVal = 0;
int retryCount = 0;
const int maxRetries = 100; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ݺ<EFBFBD> <20><><EFBFBD><EFBFBD> (50ȸ<30><C8B8> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>)
printf("\n[PROCESS] Checking PMIC Communication...");
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>˻<EFBFBD>: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (<28>Ǵ<EFBFBD> Ư<><C6AF> Ƚ<><C8BD>)
while (1) {
readVal = PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x02); //0x102 - IO_MODECTRL Read<61><64> Debug On<4F><6E><EFBFBD><EFBFBD> 0x25
if (readVal != 0xFF) {
printf("\n[SUCCESS] Device detected! (Current Reg 0x02: 0x%02X)\n", readVal);
break; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20>˻<EFBFBD> <20><><EFBFBD><EFBFBD> Ż<><C5BB>
}
printf("."); // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>˸<EFBFBD><CBB8><EFBFBD> <20><> ǥ<><C7A5>
Sleep(1000); // 1<><31> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ȯ<><C8AE>
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>Ⱑ <20>ȴٸ<C8B4> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ī<><C4AB><EFBFBD>͸<EFBFBD> <20>Ἥ break
}
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
printf("[PROCESS] Attempting to Enter Debug Mode Off...\n");
do {
retryCount++;
// Page01 <20><><EFBFBD><EFBFBD>
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01);
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01);
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (0x65)
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x02, 0x65); //0x102 - IO_MODECTRL
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> Ȯ<><C8AE> (Verification)
Sleep(50);
// <20><><EFBFBD><EFBFBD> <20>о Ȯ<><C8AE>
readVal = PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x02);
if (readVal == 0x65) {
printf(" >>> Success! Debug Mode Off[0x%02X] at cycle %d. <<<\n", readVal, retryCount);
return true;
}
printf("[Retry %d]...\n", retryCount);
} while (retryCount < maxRetries);
printf("\n[ERRPR] Failed Debug Mode Off\n");
return false;
}
// Check All Fault Registers
void Run_CheckFaults(FT_HANDLE ftHandle)
{
printf("\n[PROCESS] Scanning all Fault Registers...\n");
///////////////////////
//Regulation Register//
///////////////////////
printf("[OTP Version]\n");
//OTP Version
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x02); //0x00 - Page0x02
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x02); //0x00 - Page0x02
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x22); //0x222 - OTP_VERSION_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x23); //0x223 - OTP_VERSION_REGU
//Fault register data: Regulation Register, Address 0x040 ~ 0x049
printf("[Regulation FLT Register]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x40); //0x040 - FLT_RECORD_OTP
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x41); //0x041 - FLT_RECORD_TEMP
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x42); //0x042 - FLT_RECORD_BUCK1
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x43); //0x043 - FLT_RECORD_BUCK2
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x44); //0x044 - FLT_RECORD_BUCK3
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x45); //0x045 - FLT_RECORD_BUCK4
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x46); //0x046 - FLT_RECORD_BUCK5
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x47); //0x047 - FLT_RECORD_LDO
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x48); //0x048 - FLT_RECORD_IF
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x49); //0x049 - FLT_RECORD_LDO_DISC_DET
///////////////////////
//Protection Register//
///////////////////////
//Fault register data: Protection Register, Address 0x010 ~0x014, 0x019 ~0x021
printf("[Protection FLT Register]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x10); //0x010 - FUSA_STATUS_1
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x11); //0x011 - FUSA_STATUS_2
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x12); //0x012 - FUSA_STATUS_2A
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x13); //0x013 - FUSA_STATUS_3
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x14); //0x014 - FUSA_STATUS_4
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x19); //0x019 - FLT_RECORD_A
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1A); //0x01A - FLT_RECORD_B
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1B); //0x01B - FLT_RECORD_GND_AVIN
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1C); //0x01C - FLT_RECORD_BG_Temp
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1D); //0x01D - FLT_RECORD_IntLDOs
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1E); //0x01E - FLT_RECORD_ExtLDOs
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1F); //0x01F - FLT_RECORD_BUCKS_B
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x20); //0x020 - FLT_RECORD_BUCKS_A
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x21); //0x021 - FLT_RECORD_ExtINPs_7_0
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x28); //0x028 - OTP_RWADDR
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x2A); //0x02A - OTP_FLT_RECORD
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x02); //0x102 - IO_MODECTRL
///////////////////////
// Debug Register //
///////////////////////
//Debug Regulation Chip Name etc
printf("[Regulation Chip ID]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x00); //0x000 - IO_PAGE_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x01); //0x001 - IO_CHIPNAME_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x02); //0x002 - IO_CHIPVERSION_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x03); //0x003 - IO_DIEID3_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x04); //0x004 - IO_DIEID2_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x05); //0x005 - IO_DIEID1_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x06); //0x006 - IO_DIEID0_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x0A); //0x00A - OTP_VERSION_REGU
//Debug Protection Chip Name etc
printf("[Protection Chip ID]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x00); //0x000 - IO_PAGE_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x01); //0x001 - IO_CHIPNAME_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x02); //0x002 - IO_CHIPVERSION_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x03); //0x003 - IO_DIEID3_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x04); //0x004 - IO_DIEID2_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x05); //0x005 - IO_DIEID1_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x06); //0x006 - IO_DIEID0_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x0A); //0x00A - OTP_VERSION_REGU
}
// Read Chip Information (OTP/Version)
void Run_ReadChipInfo(FT_HANDLE ftHandle)
{
//Regulation Register
printf("[OTP Version]\n");
//OTP Version
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x02); //0x00 - Page0x02
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x02); //0x00 - Page0x02
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x22); //0x222 - OTP_VERSION_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x23); //0x223 - OTP_VERSION_REGU
//Debug Regulation Chip Name etc
printf("[Regulation Chip ID]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x00); //0x000 - IO_PAGE_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x01); //0x001 - IO_CHIPNAME_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x02); //0x002 - IO_CHIPVERSION_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x03); //0x003 - IO_DIEID3_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x04); //0x004 - IO_DIEID2_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x05); //0x005 - IO_DIEID1_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x06); //0x006 - IO_DIEID0_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_REGULATION, 0x0A); //0x00A - OTP_VERSION_REGU
//Debug Protection Chip Name etc
printf("[Protection Chip ID]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x00); //0x000 - IO_PAGE_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x01); //0x001 - IO_CHIPNAME_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x02); //0x002 - IO_CHIPVERSION_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x03); //0x003 - IO_DIEID3_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x04); //0x004 - IO_DIEID2_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x05); //0x005 - IO_DIEID1_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x06); //0x006 - IO_DIEID0_REGU
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x0A); //0x00A - OTP_VERSION_REGU
}
// PMIC Irq Clear
void Irq_Clear(FT_HANDLE ftHandle)
{
//Regulation Fault Register Clear : Regulation Register, Address 0x040 ~ 0x049
printf("[Regulation FLT Register Clear]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x40, 0x00); //0x040 - FLT_RECORD_OTP
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x41, 0x00); //0x041 - FLT_RECORD_TEMP
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x42, 0x00); //0x042 - FLT_RECORD_BUCK1
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x43, 0x00); //0x043 - FLT_RECORD_BUCK2
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x44, 0x00); //0x044 - FLT_RECORD_BUCK3
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x45, 0x00); //0x045 - FLT_RECORD_BUCK4
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x46, 0x00); //0x046 - FLT_RECORD_BUCK5
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x47, 0x00); //0x047 - FLT_RECORD_LDO
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x48, 0x00); //0x048 - FLT_RECORD_IF
PMIC_I2C_Write(ftHandle, PMIC_ADDR_REGULATION, 0x49, 0x00); //0x049 - FLT_RECORD_LDO_DISC_DET
//Fault register data: Protection Register, Address 0x010 ~0x014, 0x019 ~0x021
printf("[Protection FLT Register Clear]\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x14); //0x014 - FUSA_STATUS_4
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x19); //0x019 - FLT_RECORD_A
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1A); //0x01A - FLT_RECORD_B
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1B); //0x01B - FLT_RECORD_GND_AVIN
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1C); //0x01C - FLT_RECORD_BG_Temp
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1D); //0x01D - FLT_RECORD_IntLDOs
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1E); //0x01E - FLT_RECORD_ExtLDOs
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x1F); //0x01F - FLT_RECORD_BUCKS_B
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x20); //0x020 - FLT_RECORD_BUCKS_A
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x21); //0x021 - FLT_RECORD_ExtINPs_7_0
PMIC_I2C_Read(ftHandle, PMIC_ADDR_PROTECTION, 0x2A); //0x02A - OTP_FLT_RECORD
}
// PMIC Set Reset
void Set_Reset(FT_HANDLE ftHandle)
{
printf("PMIC Set Reset\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x0C, 0x00); //0x0C - FUSA_CTRL_5
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x0C, 0x05); //0x0C - FUSA_CTRL_5
}
// PMIC Set Error
void Set_Error(FT_HANDLE ftHandle)
{
printf("PMIC Set Error\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x00); //0x00 - Page0x00
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x0C, 0x00); //0x0C - FUSA_CTRL_5
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x0C, 0x06); //0x0C - FUSA_CTRL_5
}
// PMIC Set FLT_MASK_B
void Set_FLT_MASK_B(FT_HANDLE ftHandle)
{
printf("PMIC Set FLT_MASK_B\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x2C, 0x3F); //0x2C - FLT_MASK_B
}
// PMIC Set CRC On
void Set_CRC_On(FT_HANDLE ftHandle)
{
printf("PMIC Set CRC ON\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x05, 0x01); //0x05 - IO_FUNC_CFG
}
// PMIC Set CRC Off
void Set_CRC_Off(FT_HANDLE ftHandle)
{
printf("PMIC Set CRC OFF\n");
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x00, 0x01); //0x00 - Page0x01
PMIC_I2C_Write(ftHandle, PMIC_ADDR_PROTECTION, 0x05, 0x00); //0x05 - IO_FUNC_CFG
}
// Manual Command
void Handle_ManualCommand(FT_HANDLE ftHandle, char* line)
{
char* context = NULL;
char* token = strtok_s(line, " ", &context);
if (!token) return;
int command = parseCommand(token); // 1: WRITE, 2: READ
if (command == 1 || command == 2) {
printf("\n[MANUAL] Executing I2C %s...\n", (command == 1) ? "WRITE" : "READ");
// <20><><EFBFBD>⿡ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ۼ<EFBFBD><DBBC>ϼ̴<CFBC> w/r <20>Ľ<EFBFBD> <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ø<EFBFBD> <20>˴ϴ<CBB4>.
// <20><>: <20><>ū<EFBFBD><C5AB> <20><><EFBFBD><EFBFBD> <20>߶<EFBFBD><DFB6><EFBFBD> <20>ּҿ<D6BC> <20><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> <20><><EFBFBD><EFBFBD> <20><> FT4222_I2CMaster_... ȣ<><C8A3>
}
else {
printf("\n[ERROR] Invalid command or menu number. Please try again.\n");
}
}