61 changed files with 10073 additions and 553 deletions
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
File diff suppressed because it is too large
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -0,0 +1,298 @@ |
|||
QualityReport |
|||
2026년 1월 14일 수요일 오전 10:30:44 |
|||
|
|||
------ Start build(multical, DefaultBuild) ------ |
|||
C:\Program Files (x86)\Renesas Electronics\CS+\CC\CC-RL\V1.15.00\Bin\ccrl.exe r_main.c -cpu=S3 -o DefaultBuild\r_main.obj "-dev=C:\Program Files (x86)\Renesas Electronics\CS+\CC\Device\RL78\Devicefile\DR5F10PPJ.DVF" -g -g_line -I "..\..\Documents\카카오톡 받은 파일\IDH1.1\IDH1.1" -I ..\IDH1.1 -I . -c -msg_lang=english |
|||
C:\Program Files (x86)\Renesas Electronics\CS+\CC\CC-RL\V1.15.00\Bin\ccrl.exe dipSwitch.c -cpu=S3 -o DefaultBuild\dipSwitch.obj "-dev=C:\Program Files (x86)\Renesas Electronics\CS+\CC\Device\RL78\Devicefile\DR5F10PPJ.DVF" -g -g_line -I "..\..\Documents\카카오톡 받은 파일\IDH1.1\IDH1.1" -I ..\IDH1.1 -I . -c -msg_lang=english |
|||
W0511106:The folder "..\..\Documents\카카오톡 받은 파일\IDH1.1\IDH1.1" specified by the "-I" option is not found. |
|||
W0511106:The folder "..\..\Documents\카카오톡 받은 파일\IDH1.1\IDH1.1" specified by the "-I" option is not found. |
|||
W0511106:The folder "..\IDH1.1" specified by the "-I" option is not found. |
|||
W0511106:The folder "..\IDH1.1" specified by the "-I" option is not found. |
|||
W0511186:The evaluation period for the option "-Odefault" of CC-RL V1 is valid for the remaining 60 days. After that, it will be implicitly changed to "-Olite". Please consider purchasing the product to continue using "-Odefault". |
|||
W0511186:The evaluation period for the option "-Odefault" of CC-RL V1 is valid for the remaining 60 days. After that, it will be implicitly changed to "-Olite". Please consider purchasing the product to continue using "-Odefault". |
|||
owi.h(47):W0523076:Function declarations should have prototype |
|||
i2c.h(8):W0520047:Incompatible redefinition of macro "RAM_BYTES" (declared at line 11 of "uart.h") |
|||
C:\Program Files (x86)\Renesas Electronics\CS+\CC\CC-RL\V1.15.00\inc\stdint.h(18):W0520301:Typedef name has already been declared (with same type) |
|||
C:\Program Files (x86)\Renesas Electronics\CS+\CC\CC-RL\V1.15.00\inc\stdint.h(19):W0520301:Typedef name has already been declared (with same type) |
|||
C:\Program Files (x86)\Renesas Electronics\CS+\CC\CC-RL\V1.15.00\inc\stdint.h(20):W0520301:Typedef name has already been declared (with same type) |
|||
C:\Program Files (x86)\Renesas Electronics\CS+\CC\CC-RL\V1.15.00\inc\stdint.h(25):W0520301:Typedef name has already been declared (with same type) |
|||
C:\Program Files (x86)\Renesas Electronics\CS+\CC\CC-RL\V1.15.00\inc\stdint.h(26):W0520301:Typedef name has already been declared (with same type) |
|||
C:\Program Files (x86)\Renesas Electronics\CS+\CC\CC-RL\V1.15.00\inc\stdint.h(27):W0520301:Typedef name has already been declared (with same type) |
|||
r_main.c(115):W0520172:External/internal linkage conflict with previous declaration |
|||
r_main.c(133):W0523077:Called function should have prototype |
|||
C:\Program Files (x86)\Renesas Electronics\CS+\CC\CC-RL\V1.15.00\Bin\rlink.exe -subcommand=DefaultBuild\multical.clnk |
|||
W0561018:The evaluation period of CC-RL V1 is valid for the remaining 60 days. After that, functional limit will be applied. Please consider purchasing the product. |
|||
W0561018:The evaluation period of CC-RL V1 is valid for the remaining 60 days. After that, functional limit will be applied. Please consider purchasing the product. |
|||
Renesas Optimizing Linker Completed |
|||
------ Build ended(Error:0, Warning:18)(multical, DefaultBuild) ------ |
|||
|
|||
--- CommandFile 1 --- |
|||
DefaultBuild\multical.clnk : |
|||
-Input=DefaultBuild\cstart.obj |
|||
-Input=DefaultBuild\stkinit.obj |
|||
-Input=DefaultBuild\r_main.obj |
|||
-Input=DefaultBuild\r_systeminit.obj |
|||
-Input=DefaultBuild\r_cg_cgc.obj |
|||
-Input=DefaultBuild\r_cg_cgc_user.obj |
|||
-Input=DefaultBuild\r_cg_serial.obj |
|||
-Input=DefaultBuild\r_cg_serial_user.obj |
|||
-Input=DefaultBuild\r_cg_wdt.obj |
|||
-Input=DefaultBuild\r_cg_wdt_user.obj |
|||
-Input=DefaultBuild\r_cg_adc.obj |
|||
-Input=DefaultBuild\r_cg_adc_user.obj |
|||
-Input=DefaultBuild\r_cg_port.obj |
|||
-Input=DefaultBuild\r_cg_port_user.obj |
|||
-Input=DefaultBuild\anaout.obj |
|||
-Input=DefaultBuild\owi.obj |
|||
-Input=DefaultBuild\i2c.obj |
|||
-Input=DefaultBuild\uart.obj |
|||
-Input=DefaultBuild\delay.obj |
|||
-Input=DefaultBuild\dipSwitch.obj |
|||
-SECURITY_ID=00000000000000000000 |
|||
-DEVICE=C:\Program Files (x86)\Renesas Electronics\CS+\CC\Device\RL78\Devicefile\DR5F10PPJ.DVF |
|||
-DEBug |
|||
-NOCOmpress |
|||
-NOOPtimize |
|||
-OUtput=DefaultBuild\multical.abs |
|||
-OCDBG=04 |
|||
-USER_OPT_BYTE=FFFFF8 |
|||
-LISt=DefaultBuild\multical.map |
|||
-SHow=SYmbol,Total_size |
|||
-AUTO_SECTION_LAYOUT |
|||
-ROm=.data=.dataR |
|||
-ROm=.sdata=.sdataR |
|||
-NOMessage |
|||
-MEMory=High |
|||
-NOLOgo |
|||
-LIBrary=DefaultBuild\multical.lib |
|||
-end |
|||
-Input=DefaultBuild\multical.abs |
|||
-DEVICE=C:\Program Files (x86)\Renesas Electronics\CS+\CC\Device\RL78\Devicefile\DR5F10PPJ.DVF |
|||
-OUtput=DefaultBuild\multical.mot |
|||
-FOrm=Stype |
|||
-NOMessage |
|||
-exit |
|||
|
|||
|
|||
--- SHA1 hash value of output files --- |
|||
C:\Users\COMPUTER1\OneDrive\문서\카카오톡 받은 파일\Amosense_Firmware\Amosense_Firmware\DefaultBuild\multical.abs: 02573826f641eca7df73ff054c8e823c4d5b11c4 |
|||
C:\Users\COMPUTER1\OneDrive\문서\카카오톡 받은 파일\Amosense_Firmware\Amosense_Firmware\DefaultBuild\multical.mot: c95d0bc8130fb9e402da42eee0be70f0ce6eca3e |
|||
|
|||
|
|||
--- System Information --- |
|||
*OS Version |
|||
Microsoft Windows 11 Pro (-, 10.0.26200, WOW64) |
|||
*Language |
|||
한국어(대한민국) |
|||
*.NET Framework Version |
|||
Microsoft .NET Framework 4 [.NET 4.8 or later] (533509) |
|||
*WebView2 Version |
|||
143.0.3650.139 |
|||
|
|||
--- Application Information --- |
|||
*Product Name |
|||
CS+ for CC |
|||
*Package Version |
|||
V8.13.00 [05 Dec 2024] |
|||
*Version |
|||
V9.13.00.05 [12 Nov 2024] |
|||
*Assembly Version |
|||
3.12.10.1 |
|||
*Product License |
|||
|
|||
*Execution Place |
|||
C:\Program Files (x86)\Renesas Electronics\CS+\CC |
|||
*Memory Usage |
|||
*Private Working Set |
|||
295 MB |
|||
*Number of GDI Objects |
|||
2228 |
|||
*Number of USER Objects |
|||
1638 |
|||
*Opened Files |
|||
3 editors, 3 files, 16 KB |
|||
|
|||
--- Build Tool Plug-in Information --- |
|||
RH850 Build tool CC-RH Plug-in |
|||
*Version |
|||
V8.09.00.00 [07 Oct 2022] |
|||
*Assembly Version |
|||
1.1.10.12 |
|||
*DLL File Name |
|||
BuildToolCCRH.dll |
|||
RL78 Build tool CC-RL Plug-in |
|||
*Version |
|||
V8.11.00.00 [29 Sep 2023] |
|||
*Assembly Version |
|||
1.0.0.0 |
|||
*DLL File Name |
|||
BuildToolCCRL.dll |
|||
RX Build tool CC-RX Plug-in |
|||
*Version |
|||
V8.09.00.00 [07 Oct 2022] |
|||
*Assembly Version |
|||
3.12.10.1 |
|||
*DLL File Name |
|||
BuildToolCCRX.dll |
|||
RH850 Build tool GHS CCRH850 Plug-in |
|||
*Version |
|||
V1.10.00.01 [25 Sep 2024] |
|||
*Assembly Version |
|||
1.0.0.0 |
|||
*DLL File Name |
|||
BuildToolGHSCCRH850.dll |
|||
|
|||
--- Debug Tool Plug-in Information --- |
|||
Debugger Collection Plug-in |
|||
*Version |
|||
V8.13.00.04 [26 Nov 2024] |
|||
*Assembly Version |
|||
2.12.10.1 |
|||
*DLL File Name |
|||
DebugToolCollection.dll |
|||
|
|||
--- Other Plug-in Information --- |
|||
Code Generator Plug-in for RH850 |
|||
*Version |
|||
V1.02.02.05 [25 May 2018] |
|||
*Assembly Version |
|||
1.0.0.0 |
|||
*DLL File Name |
|||
CodeGeneratorRH850.dll |
|||
Code Generator Plug-in |
|||
*Version |
|||
V4.08.06.01 [28 Oct 2022] |
|||
*Assembly Version |
|||
3.0.0.0 |
|||
*DLL File Name |
|||
CodePart.dll |
|||
Code Generator/PinView Plug-in |
|||
*Version |
|||
V2.10.07.02 [08 Nov 2021] |
|||
*Assembly Version |
|||
1.0.0.0 |
|||
*DLL File Name |
|||
CodePart2.dll |
|||
Debug Console Plug-in |
|||
*Version |
|||
V8.09.00.03 [24 Nov 2022] |
|||
*Assembly Version |
|||
8.9.0.0 |
|||
*DLL File Name |
|||
DebugConsole.dll |
|||
Quick and Effective tool solution - QE |
|||
*Version |
|||
V9.12.00.01 [08 Apr 2024] |
|||
*Assembly Version |
|||
1.15.10.16 |
|||
*DLL File Name |
|||
InCarTools.dll |
|||
Pin Configurator Plug-in |
|||
*Version |
|||
V1.54.01.01 [31 Jul 2014] |
|||
*Assembly Version |
|||
1.6.10.23 |
|||
*DLL File Name |
|||
PinConfig.dll |
|||
Program Analyzer Plug-in |
|||
*Version |
|||
V4.13.00.03 [24 May 2023] |
|||
*Assembly Version |
|||
3.12.11.9 |
|||
*DLL File Name |
|||
ProgramAnalyzer.dll |
|||
IronPython Console Plug-in |
|||
*Version |
|||
V1.49.00.02 [08 Nov 2024] |
|||
*Assembly Version |
|||
1.6.10.23 |
|||
*DLL File Name |
|||
PythonConsole.dll |
|||
Editor plug-in DLL |
|||
*Version |
|||
V1.20.00.03 [20 May 2024] |
|||
*Assembly Version |
|||
1.1.0.0 |
|||
*DLL File Name |
|||
SEditor.dll |
|||
Stack Usage Tracer |
|||
*Version |
|||
V1.05.00.02 [30 Jul 2014] |
|||
*Assembly Version |
|||
1.30.11.15 |
|||
*DLL File Name |
|||
Stk.dll |
|||
Update Manager Plug-in |
|||
*Version |
|||
V2.03.00.02 [29 Oct 2018] |
|||
*Assembly Version |
|||
1.13.6.20 |
|||
*DLL File Name |
|||
Update.dll |
|||
|
|||
Debug Tool Common Interface |
|||
*Version |
|||
V8.13.00.04 [26 Nov 2024] |
|||
*Assembly Version |
|||
3.12.10.1 |
|||
*DLL File Name |
|||
CommonDebuggerInterface.dll |
|||
Device Information Common Interface |
|||
*Version |
|||
V9.13.00.02 [03 Oct 2024] |
|||
*Assembly Version |
|||
3.0.0.0 |
|||
*DLL File Name |
|||
DeviceInformation.dll |
|||
|
|||
--- Main Project Information --- |
|||
C:\Users\COMPUTER1\OneDrive\문서\카카오톡 받은 파일\Amosense_Firmware\Amosense_Firmware\multical.mtpj |
|||
Microcontroller Information |
|||
*R5F10PPJ |
|||
*File Name: Version |
|||
RL78_Productlist.xml: V8.130000 |
|||
R5F10PPJ_common.xml: V1.13.00.XX.02 |
|||
DR5F10PPJ.DVF: V1.11 |
|||
f14_ppx.ti: V1.02 |
|||
-: - |
|||
|
|||
|
|||
Build Tool Information |
|||
*CC-RL |
|||
* Version of plug-in(*.dll) |
|||
V8.13.00.02 [09 Oct 2024] |
|||
* The Version of the Compiler Package |
|||
V1.15.00 |
|||
|
|||
* The version of SMS Assembler |
|||
V1.00.00.01 [29 May 2020] |
|||
* The version of GREEN_DSP Structured Assembler |
|||
V1.05.00 |
|||
|
|||
|
|||
Debug Tool Information |
|||
*RL78 Simulator |
|||
Debugger Library V8.13.00.04 [26 Nov 2024] |
|||
|
|||
|
|||
Other Tool Information |
|||
*None |
|||
|
|||
*None |
|||
|
|||
*None |
|||
|
|||
*Pin Configurator |
|||
*Program Analyzer |
|||
*Version |
|||
V4.13.00.03 [24 May 2023] |
|||
|
|||
*Code Generator |
|||
Other Information |
|||
*RL78/F14 Code Library |
|||
*Version |
|||
V2.03.07.02 [08 Nov 2021] |
|||
*Description |
|||
Code library for RL78/F14 code generation plugin. |
|||
|
|||
|
|||
@ -0,0 +1,110 @@ |
|||
#include "anaout.h" |
|||
|
|||
// -------------------------------------------------------
|
|||
// Helper macros
|
|||
// -------------------------------------------------------
|
|||
#define BIT(n) (1u << (n)) |
|||
|
|||
// -------------------------------------------------------
|
|||
// ANAOUT mapping (사용자 제공 기준)
|
|||
// ANAOUT_1 : P64 -> P6.4
|
|||
// ANAOUT_2 : P65 -> P6.5
|
|||
// ANAOUT_3 : P66 -> P6.6
|
|||
// ANAOUT_4 : P67 -> P6.7
|
|||
//
|
|||
// ANAOUT_5 : P44 -> P4.4
|
|||
// ANAOUT_6 : P43 -> P4.3
|
|||
// ANAOUT_7 : P42 -> P4.2
|
|||
// ANAOUT_8 : P41 -> P4.1
|
|||
//
|
|||
// ANAOUT_9 : P50 -> P5.0
|
|||
// ANAOUT_10 : P51 -> P5.1
|
|||
// ANAOUT_11 : P52 -> P5.2
|
|||
//
|
|||
// ANAOUT_12 : P60 -> P6.0
|
|||
// ANAOUT_13 : P61 -> P6.1
|
|||
//
|
|||
// ANAOUT_14 : P72 -> P7.2
|
|||
// ANAOUT_15 : P73 -> P7.3
|
|||
// ANAOUT_16 : P75 -> P7.5
|
|||
// ANAOUT_17 : P74 -> P7.4
|
|||
// ANAOUT_18 : P76 -> P7.6
|
|||
// ANAOUT_19 : P77 -> P7.7
|
|||
//
|
|||
// ANAOUT_20 : P130 -> P13.0
|
|||
// -------------------------------------------------------
|
|||
|
|||
// 그룹별 마스크(빠른 AllLow/Init용)
|
|||
#define P4_ANA_MASK (BIT(4) | BIT(3) | BIT(2) | BIT(1)) // P4.4~P4.1
|
|||
#define P5_ANA_MASK (BIT(0) | BIT(1) | BIT(2)) // P5.0~P5.2
|
|||
#define P6_ANA_MASK (BIT(7) | BIT(6) | BIT(5) | BIT(4) | BIT(1) | BIT(0)) // P6.7~P6.4 + P6.1~P6.0
|
|||
#define P7_ANA_MASK (BIT(7) | BIT(6) | BIT(5) | BIT(4) | BIT(3) | BIT(2)) // P7.7~P7.2
|
|||
#define P13_ANA_MASK (BIT(0)) // P13.0
|
|||
|
|||
void ANAOUT_AllLow(void) |
|||
{ |
|||
// 해당 비트만 LOW로 내림
|
|||
P4 &= (uint8_t)~(uint8_t)P4_ANA_MASK; |
|||
P5 &= (uint8_t)~(uint8_t)P5_ANA_MASK; |
|||
P6 &= (uint8_t)~(uint8_t)P6_ANA_MASK; |
|||
P7 &= (uint8_t)~(uint8_t)P7_ANA_MASK; |
|||
P13 &= (uint8_t)~(uint8_t)P13_ANA_MASK; |
|||
} |
|||
|
|||
void ANAOUT_Init(void) |
|||
{ |
|||
// 출력 설정: PM bit = 0 이 출력
|
|||
PM4 &= (uint8_t)~(uint8_t)P4_ANA_MASK; |
|||
PM5 &= (uint8_t)~(uint8_t)P5_ANA_MASK; |
|||
PM6 &= (uint8_t)~(uint8_t)P6_ANA_MASK; |
|||
PM7 &= (uint8_t)~(uint8_t)P7_ANA_MASK; |
|||
|
|||
// 초기 상태: 전부 LOW
|
|||
ANAOUT_AllLow(); |
|||
} |
|||
|
|||
void ANAOUT_Select(uint8_t ch) |
|||
{ |
|||
if (ch < ANAOUT_CH_MIN || ch > ANAOUT_CH_MAX) { |
|||
ANAOUT_AllLow(); |
|||
return; |
|||
} |
|||
|
|||
ANAOUT_AllLow(); |
|||
__nop(); __nop(); __nop(); __nop(); // break-before-make
|
|||
|
|||
// 2) 선택된 채널만 HIGH
|
|||
switch (ch) |
|||
{ |
|||
case 1: P6 |= (uint8_t)BIT(4); break; // P64
|
|||
case 2: P6 |= (uint8_t)BIT(5); break; // P65
|
|||
case 3: P6 |= (uint8_t)BIT(6); break; // P66
|
|||
case 4: P6 |= (uint8_t)BIT(7); break; // P67
|
|||
|
|||
case 5: P4 |= (uint8_t)BIT(4); break; // P44
|
|||
case 6: P4 |= (uint8_t)BIT(3); break; // P43
|
|||
case 7: P4 |= (uint8_t)BIT(2); break; // P42
|
|||
case 8: P4 |= (uint8_t)BIT(1); break; // P41
|
|||
|
|||
case 9: P5 |= (uint8_t)BIT(0); break; // P50
|
|||
case 10: P5 |= (uint8_t)BIT(1); break; // P51
|
|||
case 11: P5 |= (uint8_t)BIT(2); break; // P52
|
|||
|
|||
case 12: P6 |= (uint8_t)BIT(0); break; // P60
|
|||
case 13: P6 |= (uint8_t)BIT(1); break; // P61
|
|||
|
|||
case 14: P7 |= (uint8_t)BIT(2); break; // P72
|
|||
case 15: P7 |= (uint8_t)BIT(3); break; // P73
|
|||
case 16: P7 |= (uint8_t)BIT(5); break; // P75
|
|||
case 17: P7 |= (uint8_t)BIT(4); break; // P74
|
|||
case 18: P7 |= (uint8_t)BIT(6); break; // P76
|
|||
case 19: P7 |= (uint8_t)BIT(7); break; // P77
|
|||
|
|||
case 20: P13 |= (uint8_t)BIT(0); break; // P130
|
|||
|
|||
default: |
|||
// 범위 밖이면 전체 LOW 유지
|
|||
break; |
|||
} |
|||
} |
|||
|
|||
@ -0,0 +1,15 @@ |
|||
#ifndef ANAOUT_H |
|||
#define ANAOUT_H |
|||
|
|||
#include "r_cg_macrodriver.h" |
|||
#include "r_cg_port.h" |
|||
#include <stdint.h> |
|||
|
|||
#define ANAOUT_CH_MIN (1u) |
|||
#define ANAOUT_CH_MAX (20u) |
|||
|
|||
void ANAOUT_Init(void); |
|||
void ANAOUT_AllLow(void); |
|||
void ANAOUT_Select(uint8_t ch); // 1~20, 범위 밖이면 AllLow 처리
|
|||
|
|||
#endif |
|||
@ -0,0 +1,4 @@ |
|||
#include "delay.h" |
|||
#include "uart.h" |
|||
#include "owi.h" |
|||
#include "i2c.h" |
|||
@ -0,0 +1,86 @@ |
|||
#include "delay.h" |
|||
|
|||
|
|||
/**
|
|||
* 함수명: delay |
|||
* 목적: 단순 루프를 이용한 지연(delay) 함수 |
|||
* |
|||
* 매개변수: |
|||
* - d : 지연 카운트 값. 값이 클수록 지연 시간이 길어짐 |
|||
* |
|||
* 동작 방식: |
|||
* - while(d--) 루프를 반복하면서 CPU를 바쁘게 사용 |
|||
* - 외부 타이머나 정확한 시간 기준은 없음 |
|||
* - 단순히 CPU 사이클을 소비하여 지연 발생 |
|||
* |
|||
* 주의사항: |
|||
* - CPU 클럭에 따라 지연 시간이 달라짐 |
|||
* - 정밀한 시간 지연이 필요하면 하드웨어 타이머 사용 권장 |
|||
*/ |
|||
void delay(long d){ |
|||
while(d--); |
|||
} |
|||
|
|||
|
|||
/**
|
|||
* 함수명: delay_us |
|||
* 목적: 마이크로초(us) 단위의 지연(delay) 함수 |
|||
* |
|||
* 매개변수: |
|||
* - us : 지연 시간 (마이크로초 단위) |
|||
* |
|||
* 동작 방식: |
|||
* 1. 입력된 us 값에 따라 반복 횟수 count 계산 |
|||
* - us <= 150 : count = (us * 100 + 50) / 100 |
|||
* - us > 150 : count = (us * 106 + 50) / 100 |
|||
* - 소수점 올림 효과를 위해 +50 추가 |
|||
* 2. for 루프를 count만큼 반복하면서 __nop() 수행 |
|||
* - __nop()는 "No Operation" 명령어로, CPU 사이클만 소비 |
|||
* 3. 루프 종료 후 지정된 시간만큼 지연 |
|||
* |
|||
* 주의사항: |
|||
* - CPU 클럭 속도에 따라 실제 지연 시간은 달라질 수 있음 |
|||
* - 매우 정밀한 시간 지연이 필요하면 타이머 기반 지연 권장 |
|||
*/ |
|||
void delay_us(volatile uint32_t us) |
|||
{ |
|||
volatile uint32_t i; |
|||
volatile uint32_t count; |
|||
|
|||
if (us <= 150) { |
|||
count = (us * 100 + 50) / 100; // 소수점 올림 효과를 위해 +50 추가
|
|||
} else { |
|||
count = (us * 106 + 50) / 100; |
|||
} |
|||
|
|||
for (i = 0; i < count; i++) { |
|||
__nop(); |
|||
} |
|||
} |
|||
|
|||
|
|||
/**
|
|||
* 함수명: delay_ms |
|||
* 목적: 밀리초(ms) 단위의 지연(delay) 함수 |
|||
* |
|||
* 매개변수: |
|||
* - ms : 지연 시간 (밀리초 단위) |
|||
* |
|||
* 동작 방식: |
|||
* 1. 외부 for 루프(i)는 ms만큼 반복 |
|||
* 2. 내부 for 루프(j)는 0~799까지 반복 |
|||
* - 내부 루프 반복 횟수 800은 CPU 클럭 속도에 따라 조정 필요 |
|||
* - 반복 동안 아무 작업도 하지 않고 CPU 사이클 소모 |
|||
* 3. 두 루프가 모두 끝나면 지정된 시간만큼 대략 지연 완료 |
|||
* |
|||
* 주의사항: |
|||
* - 정확한 시간 지연은 보장되지 않음 (CPU 클럭, 최적화 레벨 등 영향) |
|||
* - 매우 정밀한 지연이 필요하면 타이머 기반 지연 권장 |
|||
* - delay_ms와 delay_us를 혼합해 사용할 수 있음 |
|||
*/ |
|||
void delay_ms(unsigned int ms) |
|||
{ |
|||
volatile unsigned int i, j; |
|||
for (i = 0; i < ms; i++) |
|||
for (j = 0; j < 800; j++); // 내부 루프 조정 필요 (클럭에 따라 조정)
|
|||
} |
|||
@ -0,0 +1,5 @@ |
|||
#include "r_cg_macrodriver.h" |
|||
|
|||
void delay(long d); |
|||
void delay_ms(unsigned int ms); |
|||
void delay_us(volatile uint32_t us); |
|||
@ -0,0 +1,35 @@ |
|||
#include "dipSwitch.h" |
|||
|
|||
/*
|
|||
* 회로도 기준: |
|||
* ADD_1..ADD_5 = P8.1..P8.5 |
|||
* Pull-up to VCC5, DIP ON -> GND(LOW) => Active-Low |
|||
*/ |
|||
#define DIP_PORT P8 |
|||
#define DIP_PM PM8 |
|||
#define DIP_MASK (0x3Eu) // b0011_1110 = P8.1~P8.5
|
|||
#define DIP_SHIFT (1u) // P8.1이 bit0로 오도록
|
|||
|
|||
void DipSwitch_Init(void) |
|||
{ |
|||
// 입력 설정: PM bit=1 => input
|
|||
DIP_PM |= DIP_MASK; |
|||
} |
|||
|
|||
uint8_t DipSwitch_ReadValue_0to31(void) |
|||
{ |
|||
uint8_t raw = (uint8_t)(DIP_PORT & DIP_MASK); |
|||
|
|||
// Active-Low이므로 반전 후, 마스크 적용
|
|||
uint8_t v = (uint8_t)((~raw) & DIP_MASK); |
|||
|
|||
// P8.1~P8.5 -> bit0~bit4
|
|||
v = (uint8_t)(v >> DIP_SHIFT); |
|||
|
|||
return (uint8_t)(v & 0x1Fu); // 0~31
|
|||
} |
|||
|
|||
uint8_t DipSwitch_ReadAddr_1to32(void) |
|||
{ |
|||
return (uint8_t)(DipSwitch_ReadValue_0to31() + 1u); // 1~32
|
|||
} |
|||
@ -0,0 +1,33 @@ |
|||
#ifndef DIPSWITCH_H |
|||
#define DIPSWITCH_H |
|||
|
|||
#include "r_cg_macrodriver.h" |
|||
#include "r_cg_port.h" // P8, PM8 사용 |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/**
|
|||
* DIP Switch 초기화 (입력 설정) |
|||
*/ |
|||
void DipSwitch_Init(void); |
|||
|
|||
/**
|
|||
* DIP Switch(5bit)를 읽어 주소(1~32)로 변환해 반환 |
|||
* - 회로: Pull-up, DIP ON -> GND (Active-Low) |
|||
* - 핀: P8.1~P8.5 (ADD_1~ADD_5) |
|||
*/ |
|||
uint8_t DipSwitch_ReadAddr_1to32(void); |
|||
|
|||
/**
|
|||
* (옵션) 디버그용: DIP 5bit(0~31) 그대로 반환 |
|||
* - ADD_1이 LSB |
|||
*/ |
|||
uint8_t DipSwitch_ReadValue_0to31(void); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif /* DIPSWITCH_H */ |
|||
@ -0,0 +1,487 @@ |
|||
#include "i2c.h" |
|||
#include "delay.h" |
|||
#include "uart.h" |
|||
#include <string.h> |
|||
|
|||
uint8_t g_i2c_last_command[3] = {0}; |
|||
uint8_t g_i2c_command_valid = 0; |
|||
|
|||
|
|||
/**
|
|||
* 함수명: disable |
|||
* 목적: I2C 장치에 비활성화(disable) 명령을 전송 |
|||
* |
|||
* 매개변수: 없음 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) 전송할 데이터 준비 |
|||
* - dis 배열에 {0x01, 0x02} 값 저장 |
|||
* |
|||
* 2) I2C 송신 |
|||
* - R_IICA0_Master_Send() 호출하여 슬레이브 주소로 데이터 전송 |
|||
* - 전송 성공 시 다음 단계로 진행 |
|||
* - 전송 실패 시 UART로 "I2C Send Failed" 메시지 출력 후 함수 종료 |
|||
* |
|||
* 참고: |
|||
* - SLAVE_ADDR는 전송 대상 I2C 장치 주소 |
|||
* - sizeof(dis)를 통해 전송할 데이터 길이 자동 계산 |
|||
* - 전송 타임아웃은 100ms |
|||
*/ |
|||
void disable(void){ |
|||
static uint8_t dis[] = {0x01, 0x02}; |
|||
//static uint8_t tx[] = {0xT0, 0x00, 0x00};
|
|||
|
|||
// I2C 마스터 송신
|
|||
if (R_IICA0_Master_Send(SLAVE_ADDR << 1, dis, sizeof(dis), 100) != MD_OK) |
|||
{ |
|||
uart_send_string("I2C Send Failed\r\n"); |
|||
return; |
|||
} |
|||
} |
|||
|
|||
|
|||
/**
|
|||
* 함수명: I2C_EnablePower |
|||
* 목적: I2C 장치 전원을 켠다. |
|||
* |
|||
* 매개변수: 없음 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) P7 레지스터의 특정 비트를 설정하여 전원 출력 HIGH 상태로 변경 |
|||
* - _02_Pn1_OUTPUT_1 : P7 포트의 1번 핀을 출력 모드로 HIGH 설정 |
|||
* |
|||
* 참고: |
|||
* - I2C 장치 전원 공급용 핀을 제어 |
|||
* - 출력 HIGH 상태로 전원이 켜짐 |
|||
*/ |
|||
void I2C_EnablePower(void) { |
|||
P7 = _02_Pn1_OUTPUT_1; |
|||
} |
|||
|
|||
|
|||
/**
|
|||
* 함수명: I2C_DisablePower |
|||
* 목적: I2C 장치 전원을 끈다. |
|||
* |
|||
* 매개변수: 없음 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) P7 레지스터의 특정 비트를 클리어하여 전원 출력 LOW 상태로 변경 |
|||
* - _00_Pn1_OUTPUT_0 : P7 포트의 1번 핀을 출력 모드로 LOW 설정 |
|||
* |
|||
* 참고: |
|||
* - I2C 장치 전원 공급용 핀을 제어 |
|||
* - 출력 LOW 상태로 전원이 꺼짐 |
|||
*/ |
|||
void I2C_DisablePower(void) { |
|||
P7 = _00_Pn1_OUTPUT_0; |
|||
} |
|||
|
|||
|
|||
/**
|
|||
* 함수명: I2C_A_Command_Mode_receiveData |
|||
* 목적: I2C 장치에서 ADC 데이터와 명령 리스트를 읽고, |
|||
* 최종적으로 UART로 데이터를 전송한다. |
|||
* |
|||
* 매개변수: |
|||
* - tx_data : 사용자 명령(UserCmd) 데이터 배열 |
|||
* - tx_len : 사용자 명령 데이터 길이 |
|||
* - id : I2C 슬레이브 장치 주소 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) ADC 읽기 |
|||
* - ADC_ReadAndSend_UART() 호출로 4채널 ADC 값을 읽음 |
|||
* - 읽은 값이 4개가 아니면 오류 메시지 UART 출력 후 종료 |
|||
* - TOP, BRP, BRN, BRP-BRN, BOT 값 순서대로 UART 문자열 구성 |
|||
* |
|||
* 2) CMD_LIST 순서대로 I2C 읽기 |
|||
* - CMD_LIST는 장치 내부 명령 6개 정의 |
|||
* - R_IICA0_Master_Send()로 명령 전송 |
|||
* - R_IICA0_Master_Receive()로 응답 읽음 |
|||
* - 읽은 값(rx[1], rx[2])을 UART 문자열에 추가 |
|||
* |
|||
* 3) 사용자 CMD 처리 |
|||
* - tx_data와 tx_len이 유효하면 해당 데이터를 I2C 장치로 전송 |
|||
* - 응답을 rx 배열로 읽고 UART 문자열에 추가 |
|||
* - 없으면 "0000"으로 표시 |
|||
* |
|||
* 4) 최종 출력 |
|||
* - 완성된 문자열(line)을 UART로 전송 |
|||
* - 각 단계마다 적절한 delay로 통신 안정성 확보 |
|||
* |
|||
* 참고: |
|||
* - RAM_BYTES는 I2C 응답 버퍼 크기 |
|||
* - UART 출력은 ","로 각 값 구분 후, 마지막에 CRLF 추가 |
|||
* - ADC와 I2C 읽기 순서가 고정되어 있어 코드만 봐도 데이터 처리 흐름 이해 가능 |
|||
*/ |
|||
void I2C_A_Command_Mode_receiveData(const uint8_t *tx_data, uint8_t tx_len,uint8_t id ) |
|||
{ |
|||
uint8_t CMD_LIST[6][3] = { |
|||
{0x2E, 0x00, 0x00}, // BR
|
|||
{0x2E, 0x01, 0x00}, // BR_AZ
|
|||
{0x2E, 0x02, 0x00}, // T_RAW
|
|||
{0x2E, 0x16, 0x00}, // Y_data
|
|||
{0x2E, 0x41, 0x00}, // BR_AOUT
|
|||
{0x2E, 0x40, 0x00} |
|||
}; |
|||
|
|||
char line[128]; |
|||
size_t n = 0; |
|||
uint8_t rx[RAM_BYTES] = {0}; |
|||
int j; |
|||
|
|||
// 1) ADC 읽기 (4채널)
|
|||
ADC_ReadAndSend_UART(); |
|||
if (g_adc_len != 4) { // TOP, BRP, BRN, BOT만 읽음
|
|||
uart_send_string("Err:adc_count\r\n"); |
|||
return; |
|||
} |
|||
|
|||
// 2) UART 문자열 구성 (5개 값)
|
|||
for (j = 0; j < 5; j++) { |
|||
float v = 0.0f; |
|||
|
|||
switch (j) { |
|||
case 0: // 1번: TOP
|
|||
v = g_adc_bytes[0]; |
|||
break; |
|||
case 1: // 2번: BRP
|
|||
v = g_adc_bytes[1]; |
|||
break; |
|||
case 2: // 3번: BRN
|
|||
v = g_adc_bytes[2]; |
|||
break; |
|||
case 3: // 4번: BRP - BRN
|
|||
v = g_adc_bytes[1] - g_adc_bytes[2]; |
|||
break; |
|||
case 4: // 5번: BOT
|
|||
v = g_adc_bytes[3]; |
|||
break; |
|||
} |
|||
|
|||
n += sprintf(&line[n], "%.2f", v); |
|||
|
|||
|
|||
line[n++] = ','; |
|||
|
|||
} |
|||
|
|||
|
|||
delay(100000); |
|||
|
|||
|
|||
// 2) CMD_LIST 순서대로 I2C 읽기
|
|||
for (j = 0; j < 6; j++) { |
|||
if (R_IICA0_Master_Send((id << 1), CMD_LIST[j], 3, 100) != MD_OK) { |
|||
uart_send_string("I2C Send Failed\r\n"); |
|||
return; |
|||
} |
|||
delay(10000); |
|||
|
|||
if (R_IICA0_Master_Receive((id << 1), rx, RAM_BYTES, 100) != MD_OK) { |
|||
uart_send_string("I2C Receive Failed\r\n"); |
|||
return; |
|||
} |
|||
delay(10000); |
|||
|
|||
n += sprintf(&line[n], "%02X%02X", rx[1], rx[2]); |
|||
|
|||
// 마지막 CMD 뒤에는 쉼표 붙이지 않음
|
|||
if (j < 5) { |
|||
line[n++] = ','; |
|||
} |
|||
} |
|||
|
|||
// 3) UserCmd 처리
|
|||
line[n++] = ','; // UserCmd 앞 쉼표
|
|||
if (tx_data != NULL && tx_len > 0) { |
|||
if (R_IICA0_Master_Send((id << 1), tx_data, tx_len, 100) != MD_OK) { |
|||
uart_send_string("I2C UserCmd Send Failed\r\n"); |
|||
return; |
|||
} |
|||
delay(100000); |
|||
|
|||
if (R_IICA0_Master_Receive((id << 1), rx, RAM_BYTES, 100) != MD_OK) { |
|||
uart_send_string("I2C UserCmd Receive Failed\r\n"); |
|||
return; |
|||
} |
|||
delay(10000); |
|||
|
|||
n += sprintf(&line[n], "%02X%02X", rx[1], rx[2]); |
|||
} else { |
|||
n += sprintf(&line[n], "0000"); |
|||
} |
|||
|
|||
// 마지막에 CRLF
|
|||
line[n++] = '\r'; |
|||
line[n++] = '\n'; |
|||
line[n] = '\0'; |
|||
|
|||
uart_send_string(line); |
|||
delay(10000); |
|||
|
|||
} |
|||
|
|||
/**
|
|||
* 함수명: I2C_Diagnostic |
|||
* 목적: I2C 장치의 진단용 데이터를 읽어 UART로 출력 |
|||
* |
|||
* 매개변수: |
|||
* - id : I2C 슬레이브 장치 주소 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) CMD_LIST 정의 |
|||
* - 장치에서 읽어야 하는 10개의 진단 명령 |
|||
* - 각 명령은 3바이트: {명령 코드, 파라미터1, 파라미터2} |
|||
* |
|||
* 2) CMD_LIST 순서대로 I2C 통신 수행 |
|||
* - R_IICA0_Master_Send()로 명령 전송 |
|||
* - R_IICA0_Master_Receive()로 응답 읽기 |
|||
* - 읽은 데이터(rx[1], rx[2])를 UART 문자열(line)에 추가 |
|||
* - 마지막 CMD 뒤에는 쉼표 생략 |
|||
* - 각 전송/수신 후 delay로 통신 안정성 확보 |
|||
* |
|||
* 3) UART 출력 |
|||
* - 완성된 문자열(line)을 UART로 전송 |
|||
* - 마지막에 CRLF 추가 |
|||
* |
|||
* 참고: |
|||
* - RAM_BYTES는 I2C 응답 버퍼 크기 |
|||
* - UART 출력 문자열은 각 CMD별 2바이트씩 HEX로 표시 |
|||
* - 함수는 I2C 장치 상태 확인용 진단 루틴으로 사용 |
|||
*/ |
|||
void I2C_Diagnostic(uint8_t id ) |
|||
{ |
|||
uint8_t CMD_LIST[10][3] = { |
|||
{0x2E, 0x01, 0x00}, // BR
|
|||
{0x2E, 0x00, 0x00}, // BR_AZ
|
|||
{0x2E, 0x02, 0x00}, // T_RAW
|
|||
{0x2E, 0x03, 0x00}, // Y_data
|
|||
{0x2E, 0x21, 0x00}, // BR_AOUT
|
|||
{0x2E, 0x40, 0x00}, |
|||
{0x2E, 0x05, 0x00}, |
|||
{0x2E, 0x07, 0x00}, |
|||
{0x2E, 0x19, 0x00}, |
|||
{0x2E, 0x0B, 0x00} |
|||
}; |
|||
|
|||
char line[128]; |
|||
size_t n = 0; |
|||
uint8_t rx[RAM_BYTES] = {0}; |
|||
int j; |
|||
|
|||
|
|||
|
|||
// 2) CMD_LIST 순서대로 I2C 읽기
|
|||
for (j = 0; j < 10; j++) { |
|||
if (R_IICA0_Master_Send((id << 1), CMD_LIST[j], 3, 100) != MD_OK) { |
|||
uart_send_string("I2C Send Failed\r\n"); |
|||
return; |
|||
} |
|||
delay(10000); |
|||
|
|||
if (R_IICA0_Master_Receive((id << 1), rx, RAM_BYTES, 100) != MD_OK) { |
|||
uart_send_string("I2C Receive Failed\r\n"); |
|||
return; |
|||
} |
|||
delay(10000); |
|||
|
|||
n += sprintf(&line[n], "%02X%02X", rx[1], rx[2]); |
|||
|
|||
// 마지막 CMD 뒤에는 쉼표 붙이지 않음
|
|||
if (j < 9) { |
|||
line[n++] = ','; |
|||
} |
|||
} |
|||
|
|||
|
|||
|
|||
// 마지막에 CRLF
|
|||
line[n++] = '\r'; |
|||
line[n++] = '\n'; |
|||
line[n] = '\0'; |
|||
|
|||
uart_send_string(line); |
|||
delay(10000); |
|||
|
|||
} |
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: I2C_T_Command_Mode_receiveData |
|||
* 목적: I2C 장치에 명령(tx_data) 전송 후, 상태를 UART로 출력 |
|||
* |
|||
* 매개변수: |
|||
* - tx_data : I2C로 전송할 데이터 버퍼 |
|||
* - tx_len : 전송할 데이터 길이 (바이트) |
|||
* - id : I2C 슬레이브 장치 주소 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) I2C 하드웨어 초기화 |
|||
* - R_IICA0_Create()를 호출하여 I2C 모듈 초기화 |
|||
* - I2C 장치에 전원 공급 (I2C_EnablePower()) |
|||
* - 전원 안정화를 위해 약간의 delay(1초) |
|||
* |
|||
* 2) I2C 명령 전송 |
|||
* - R_IICA0_Master_Send()로 장치에 tx_data 전송 |
|||
* - 전송 실패 시 UART로 "I2C Send Failed" 출력하고 함수 종료 |
|||
* |
|||
* 3) UART 출력 |
|||
* - 전송 성공 여부와 상관없이 "51" 문자열을 UART로 출력 |
|||
* |
|||
* 참고: |
|||
* - 이 함수는 읽기(read) 기능 없이 명령 전송만 수행 |
|||
* - UART 출력 "51"은 전송 완료 신호/디버깅용 |
|||
*/ |
|||
void I2C_T_Command_Mode_receiveData(const uint8_t *tx_data, uint8_t tx_len,uint8_t id ) |
|||
{ |
|||
char uart_buf[16]; |
|||
int j; |
|||
uint8_t rx[3] = {0}; |
|||
|
|||
R_IICA0_Create(); |
|||
I2C_EnablePower(); |
|||
delay(1000000); |
|||
|
|||
if (R_IICA0_Master_Send((id << 1), tx_data, tx_len, 100) != MD_OK) |
|||
{ |
|||
uart_send_string("I2C Send Failed\r\n"); |
|||
return; |
|||
} |
|||
|
|||
|
|||
uart_send_string("51\r\n"); |
|||
|
|||
|
|||
|
|||
|
|||
} |
|||
|
|||
|
|||
/**
|
|||
* 함수명: I2C_Command_Mode_receiveData |
|||
* 목적: I2C 장치에 명령(tx_data)을 전송하고, 상태를 UART로 출력 |
|||
* |
|||
* 매개변수: |
|||
* - tx_data : I2C로 전송할 데이터 버퍼 |
|||
* - tx_len : 전송할 데이터 길이 (바이트) |
|||
* - id : I2C 슬레이브 장치 주소 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) I2C 명령 전송 |
|||
* - R_IICA0_Master_Send()로 지정한 슬레이브(id)에 tx_data 전송 |
|||
* - 전송 실패 시 UART로 "I2C Send Failed" 출력 후 함수 종료 |
|||
* |
|||
* 2) UART 출력 |
|||
* - 전송 성공 시 "51" 문자열을 UART로 전송 |
|||
* - 디버깅 또는 전송 완료 신호용 |
|||
* |
|||
* 참고: |
|||
* - 읽기 기능 없이 명령 전송만 수행 |
|||
* - I2C 전원 제어나 초기화는 포함되어 있지 않음 |
|||
*/ |
|||
void I2C_Command_Mode_receiveData(const uint8_t *tx_data, uint8_t tx_len,uint8_t id ) |
|||
{ |
|||
char uart_buf[16]; |
|||
int j; |
|||
uint8_t rx[3] = {0}; |
|||
|
|||
if (R_IICA0_Master_Send((id << 1), tx_data, tx_len, 100) != MD_OK) |
|||
{ |
|||
uart_send_string("I2C Send Failed\r\n"); |
|||
return; |
|||
} |
|||
|
|||
uart_send_string("51\r\n"); |
|||
} |
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: I2C_Command_Mode_Send |
|||
* 목적: I2C 슬레이브 장치로부터 데이터를 읽고, UART로 출력 |
|||
* |
|||
* 매개변수: |
|||
* - tx_len : 읽을 데이터 길이 (바이트) |
|||
* - id : I2C 슬레이브 장치 주소 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) I2C 데이터 수신 |
|||
* - R_IICA0_Master_Receive()를 사용하여 지정된 슬레이브(id)로부터 tx_len 바이트 읽기 |
|||
* - 실패 시 UART로 "I2C Receive Failed" 출력 후 함수 종료 |
|||
* |
|||
* 2) UART 출력 |
|||
* - 첫 번째 바이트는 "%02X " 형식으로 바로 출력 |
|||
* - 그 다음 바이트들은 2바이트씩 묶어서 "%02X%02X " 형식으로 출력 |
|||
* - 마지막에 남은 1바이트는 단독으로 "%02X" 출력 |
|||
* - 모든 출력 후 줄바꿈("\r\n") 추가 |
|||
* |
|||
* 3) delay |
|||
* - 각 출력 사이에 delay를 넣어 UART 전송 안정화 |
|||
* |
|||
* 참고: |
|||
* - I2C 전원 제어나 초기화는 포함되어 있지 않음 |
|||
* - 출력 포맷은 디버깅 또는 로그용 |
|||
*/ |
|||
void I2C_Command_Mode_Send(uint8_t tx_len, uint8_t id) |
|||
{ |
|||
char uart_buf[16]; |
|||
char tmp_buf[8]; |
|||
int i,j; |
|||
uint8_t rx[600]; |
|||
uint8_t va0, va1; |
|||
uint8_t status = 0x00; |
|||
int tries = 0; |
|||
|
|||
/* ★추가: 버퍼 초기화 (기존 로직/출력 형식 유지) */ |
|||
memset(uart_buf, 0, sizeof(uart_buf)); |
|||
memset(tmp_buf, 0, sizeof(tmp_buf)); |
|||
memset(rx, 0x00, sizeof(rx)); // 가드 패턴(0x00으로 해도 무방)
|
|||
|
|||
if (R_IICA0_Master_Receive((id << 1), rx, (uint8_t)(tx_len), 1000) != MD_OK) { |
|||
uart_send_string("I2C Receive Failed\r\n"); |
|||
return; |
|||
} |
|||
delay(1000000); |
|||
|
|||
sprintf(uart_buf, "%02X ", rx[0]); |
|||
strcpy(tmp_buf, uart_buf); |
|||
uart_send_string(uart_buf); |
|||
delay(10000); |
|||
|
|||
for (i = 1; i < (tx_len); i += 2) { |
|||
va0 = rx[i]; |
|||
if (i + 1 < (tx_len)) { |
|||
va1 = rx[i + 1]; |
|||
delay(10000); |
|||
sprintf(uart_buf, "%02X%02X ", va0, va1); |
|||
uart_send_string(uart_buf); |
|||
delay(10000); |
|||
} else { |
|||
delay(10000); |
|||
sprintf(uart_buf, "%02X", va0); |
|||
strcpy(tmp_buf, uart_buf); |
|||
uart_send_string(uart_buf); |
|||
delay(10000); |
|||
} |
|||
} |
|||
uart_send_string("\r\n"); |
|||
} |
|||
|
|||
@ -0,0 +1,30 @@ |
|||
#include "r_cg_macrodriver.h" |
|||
#include "r_cg_serial.h" |
|||
#include "r_cg_port.h" |
|||
#include "uart.h" |
|||
|
|||
#define SLAVE_ADDR 0x28 |
|||
|
|||
#define RAM_BYTES 12 |
|||
extern volatile uint8_t i2c_tx_done; |
|||
extern volatile uint8_t i2c_rx_done; |
|||
|
|||
void I2C_EnablePower(void); |
|||
void I2C_DisablePower(void); |
|||
void I2C_Command_Mode(void); |
|||
//void I2C_read_nvm(void);
|
|||
void I2C_T_Command_Mode_receiveData(const uint8_t *tx_data, uint8_t tx_len,uint8_t id ); |
|||
void I2C_A_Command_Mode_receiveData(const uint8_t *tx_data, uint8_t tx_len,uint8_t id ); |
|||
void I2C_Command_Mode_receiveData(const uint8_t *tx_data, uint8_t tx_len,uint8_t id ); |
|||
void I2C_Command_Mode_Send(uint8_t tx_len, uint8_t id); |
|||
void I2C_Diagnostic(uint8_t id); |
|||
|
|||
void disable(void); |
|||
|
|||
void i2c_enter_nomal_mode(void); |
|||
void i2c_read_ram_out0(void); |
|||
void i2c_read_ram_out1(void); |
|||
void i2c_read_all_ram(void); |
|||
void i2c_read_all_nvm(void); |
|||
void i2c_write_all_nvm(void); |
|||
void i2c_nvm_data(void); |
|||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because it is too large
@ -0,0 +1,886 @@ |
|||
#include "owi.h" |
|||
#include "delay.h" |
|||
#include <string.h> |
|||
#include "uart.h" |
|||
|
|||
|
|||
/**
|
|||
* 함수명: OWI_EnablePower |
|||
* 목적: 1-Wire 장치의 전원을 켠다. |
|||
* |
|||
* 매개변수: 없음 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* - MCU 포트 P7의 1번 핀(P7.1)을 출력 모드로 설정하고 논리 HIGH(_02_Pn1_OUTPUT_1)로 설정하여 |
|||
* 1-Wire 장치에 전원을 공급한다. |
|||
*/ |
|||
void OWI_EnablePower(void) { |
|||
P7 = _02_Pn1_OUTPUT_1; |
|||
} |
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: OWI_DisablePower |
|||
* 목적: 1-Wire 장치의 전원을 끈다. |
|||
* |
|||
* 매개변수: 없음 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* - MCU 포트 P7의 1번 핀(P7.1)을 출력 모드로 설정하고 논리 LOW(_00_Pn1_OUTPUT_0)로 설정하여 |
|||
* 1-Wire 장치에 공급되는 전원을 차단한다. |
|||
*/ |
|||
void OWI_DisablePower(void) { |
|||
P7 = _00_Pn1_OUTPUT_0; |
|||
} |
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: GPIO_Clear |
|||
* 목적: 1-Wire 통신에 사용하는 GPIO(P70)를 초기화하고 Low 상태로 설정한다. |
|||
* |
|||
* 매개변수: 없음 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* - OWI_PORT_P 레지스터에서 해당 핀(OWI_PIN_MASK) 비트를 0으로 설정하여 P70을 Low로 만든다. |
|||
* - OWI_PORT_PM 레지스터에서 해당 핀 비트를 0으로 설정하여 P70을 출력 모드로 설정한다. |
|||
* - 결과적으로 P70 핀은 출력 모드로 Low 상태가 된다. |
|||
*/ |
|||
void GPIO_Clear(void) { |
|||
OWI_PORT_P &= ~OWI_PIN_MASK; // P70 = 0 (Low)
|
|||
OWI_PORT_PM &= ~OWI_PIN_MASK; // P70 출력 모드
|
|||
} |
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: GPIO_Input |
|||
* 목적: 1-Wire 통신에 사용하는 GPIO(P70)를 입력 모드로 설정한다. |
|||
* |
|||
* 매개변수: 없음 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* - OWI_PORT_PM 레지스터에서 해당 핀(OWI_PIN_MASK) 비트를 1로 설정하여 P70을 입력 모드(High-Z)로 만든다. |
|||
* - 출력 신호를 끄고 외부 장치로부터 신호를 읽을 준비를 한다. |
|||
*/ |
|||
void GPIO_Input(void) { |
|||
OWI_PORT_PM |= OWI_PIN_MASK; // P70 입력 모드 (High-Z)
|
|||
} |
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: GPIO_Read |
|||
* 목적: 1-Wire 통신에 사용하는 GPIO(P70)의 현재 상태를 읽는다. |
|||
* |
|||
* 매개변수: 없음 |
|||
* |
|||
* 반환값: |
|||
* - 1 : P70 핀이 High 상태일 때 |
|||
* - 0 : P70 핀이 Low 상태일 때 |
|||
* |
|||
* 동작 방식: |
|||
* - OWI_PORT_P 레지스터에서 해당 핀(OWI_PIN_MASK) 비트를 확인한다. |
|||
* - 비트가 1이면 High, 0이면 Low로 판단하여 정수값으로 반환한다. |
|||
* - 외부 장치에서 보내는 신호를 읽거나, 현재 GPIO 상태를 확인할 때 사용된다. |
|||
*/ |
|||
int GPIO_Read(void) { |
|||
return (OWI_PORT_P & OWI_PIN_MASK) ? 1 : 0; |
|||
} |
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: OWI_Init |
|||
* 목적: 1-Wire 통신을 시작하기 위해 GPIO 및 통신 속도를 초기화한다. |
|||
* |
|||
* 매개변수: |
|||
* - bit_time_us : 1비트 전송에 걸리는 시간(마이크로초 단위) |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1. bit_period_us 전역 변수에 비트 전송 시간을 저장. |
|||
* 2. OWI_PORT_POM 레지스터에서 해당 핀(OWI_PIN_MASK)을 Open-drain(n-channel) 모드로 설정. |
|||
* 3. OWI_PORT_PU 레지스터에서 해당 핀의 내부 풀업 저항 활성화. |
|||
* 4. 초기 상태에서 GPIO를 입력 모드로 설정하여 외부 신호를 기다리는 상태로 대기. |
|||
* |
|||
*/ |
|||
void OWI_Init(uint32_t bit_time_us) { |
|||
bit_period_us = bit_time_us; |
|||
|
|||
OWI_PORT_POM |= OWI_PIN_MASK; // Open-drain (n-channel)
|
|||
OWI_PORT_PU |= OWI_PIN_MASK; // 내부 풀업 활성화
|
|||
|
|||
|
|||
GPIO_Input(); // 초기엔 입력으로 대기
|
|||
} |
|||
|
|||
|
|||
// ----------------------------------------
|
|||
// OWI Start/Stop/Secure
|
|||
// ----------------------------------------
|
|||
|
|||
/**
|
|||
* 함수명: OWI_Start |
|||
* 목적: 1-Wire 통신에서 Start 신호를 발생시켜 통신을 시작한다. |
|||
* |
|||
* 매개변수: 없음 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1. GPIO_Clear() 호출: P70 핀을 Low 상태로 설정하여 Start 신호를 준비. |
|||
* 2. delay_us(TSTART_HOLD): Start 신호를 일정 시간 유지. |
|||
* 3. GPIO_Input() 호출: 핀을 입력 모드(High-Z)로 전환하여 외부 장치가 반응하도록 대기. |
|||
* 4. delay_us(TBIT / 2): 반비트 시간만큼 대기하여 1-Wire 타이밍 맞춤. |
|||
* |
|||
*/ |
|||
void OWI_Start(void) |
|||
{ |
|||
GPIO_Clear(); |
|||
delay_us(TSTART_HOLD); |
|||
GPIO_Input(); |
|||
delay_us(TBIT / 2); |
|||
} |
|||
|
|||
|
|||
/**
|
|||
* 함수명: OWI_Stop |
|||
* 목적: 1-Wire 통신을 종료하고 통신 라인을 정리한다. |
|||
* |
|||
* 매개변수: 없음 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1. GPIO_Input() 호출: 핀을 입력 모드(High-Z)로 설정하여 초기 상태로 대기. |
|||
* 2. delay_us(TSTOP_LOW): Stop 조건을 만족시키기 위해 일정 시간 대기. |
|||
* 3. delay_us(TIDLE): 통신 라인을 안정화시키기 위해 추가 지연. |
|||
* 4. GPIO_Clear() 호출: 핀을 Low로 초기화하여 다음 통신 준비. |
|||
* |
|||
*/ |
|||
void OWI_Stop(void) |
|||
{ |
|||
GPIO_Input(); |
|||
delay_us(TSTOP_LOW); |
|||
delay_us(TIDLE); |
|||
GPIO_Clear(); |
|||
} |
|||
|
|||
|
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: OWI_SecureStop |
|||
* 목적: 1-Wire 통신 종료 시 라인을 안전하게 토글하여 슬레이브가 확실히 종료 상태를 인식하도록 한다. |
|||
* |
|||
* 매개변수: 없음 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1. GPIO_Clear() 호출 후 SECURE_HIGH 시간만큼 지연: 라인을 Low 상태로 초기화. |
|||
* 2. SECURE_TOGGLE_COUNT만큼 반복: |
|||
* - GPIO_Input()로 라인을 High-Z 상태로 설정 후 SECURE_TOGGLE_HIGH 시간 대기. |
|||
* - GPIO_Clear()로 라인을 Low 상태로 설정 후 SECURE_TOGGLE_LOW 시간 대기. |
|||
* - 이 과정을 통해 슬레이브가 안전하게 라인 종료를 감지. |
|||
* 3. GPIO_Input() → SECURE_HIGH 지연 → GPIO_Clear() → TSTART_HOLD 지연 → GPIO_Input() 호출: |
|||
* - 라인을 초기 상태로 복귀시켜 다음 통신 준비 완료. |
|||
* |
|||
*/ |
|||
void OWI_SecureStop(void) |
|||
{ |
|||
int i; |
|||
GPIO_Clear(); |
|||
delay_us(SECURE_HIGH); |
|||
|
|||
for (i = 0; i < SECURE_TOGGLE_COUNT; i++) { |
|||
GPIO_Input(); |
|||
delay_us(SECURE_TOGGLE_HIGH); |
|||
GPIO_Clear(); |
|||
delay_us(SECURE_TOGGLE_LOW); |
|||
} |
|||
|
|||
GPIO_Input(); |
|||
delay_us(SECURE_HIGH); |
|||
GPIO_Clear(); |
|||
delay_us(TSTART_HOLD); |
|||
GPIO_Input(); |
|||
} |
|||
|
|||
// ----------------------------------------
|
|||
// OWI Bit/Byte Write & Read
|
|||
// ----------------------------------------
|
|||
|
|||
/**
|
|||
* 함수명: OWI_WriteBit |
|||
* 목적: 1-Wire 통신 라인을 통해 단일 비트(bit)를 송신한다. |
|||
* |
|||
* 매개변수: |
|||
* - bit : 전송할 비트 값 (0 또는 1) |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1. 전송할 비트에 따라 Low 상태 유지 시간(t_low)을 결정: |
|||
* - bit가 1이면 TLOW_1, 0이면 TLOW_0 |
|||
* 2. t_high = TBIT - t_low 계산: 비트 프레임에서 High 유지 시간 결정. |
|||
* 3. GPIO_Input() 호출: 라인을 풀업 상태(High-Z)로 유지. |
|||
* 4. delay_us(t_high): High 상태 유지. |
|||
* 5. GPIO_Clear() 호출: 라인을 Low 상태로 드라이브. |
|||
* 6. delay_us(t_low): Low 상태 유지. |
|||
* |
|||
*/ |
|||
void OWI_WriteBit(int bit) |
|||
{ |
|||
uint32_t t_low = bit ? TLOW_1 : TLOW_0; |
|||
uint32_t t_high = TBIT - t_low; |
|||
|
|||
GPIO_Input(); // 풀업 상태 유지
|
|||
delay_us(t_high); // High 유지
|
|||
|
|||
GPIO_Clear(); // Low로 드라이브
|
|||
delay_us(t_low); // Low 시간 유지
|
|||
} |
|||
|
|||
|
|||
/**
|
|||
* 함수명: OWI_WriteByte |
|||
* 목적: 1-Wire 통신 라인을 통해 1바이트 데이터를 전송한다. |
|||
* |
|||
* 매개변수: |
|||
* - data : 전송할 1바이트 데이터(uint8_t) |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1. 최상위 비트(MSB)부터 최하위 비트(LSB)까지 반복: |
|||
* - 각 비트를 OWI_WriteBit() 함수를 통해 송신. |
|||
* - (data >> i) & 0x01 연산으로 i번째 비트 추출. |
|||
* 2. 모든 8비트를 전송한 후 GPIO_Input() 호출: |
|||
* - 라인을 High-Z 상태로 전환하여 다음 통신 준비. |
|||
* |
|||
*/ |
|||
void OWI_WriteByte(uint8_t data) |
|||
{ |
|||
int i; |
|||
for (i = 7; i >= 0; i--) { |
|||
OWI_WriteBit((data >> i) & 0x01); |
|||
} |
|||
GPIO_Input(); |
|||
} |
|||
|
|||
|
|||
/**
|
|||
* 함수명: OWI_ReadBit |
|||
* 목적: 1-Wire 통신 라인에서 단일 비트를 읽는다. |
|||
* |
|||
* 매개변수: 없음 |
|||
* |
|||
* 반환값: |
|||
* - 0 또는 1 : 읽은 비트 값 |
|||
* - 0xFF : 타임아웃 발생 시 에러 값 |
|||
* |
|||
* 동작 방식: |
|||
* 1. GPIO_Read()를 사용하여 라인이 High가 될 때까지 대기: |
|||
* - 최대 500us까지 대기(timeout). |
|||
* - 타임아웃 시 UART로 오류 메시지 전송 후 0xFF 반환. |
|||
* 2. delay_us(50) 호출하여 비트 중앙 위치로 대기. |
|||
* 3. GPIO_Read()로 비트 값 판독. |
|||
* 4. delay_us(30)으로 나머지 비트 시간 동안 대기. |
|||
* 5. 판독한 비트 값을 반환. |
|||
* |
|||
*/ |
|||
uint8_t OWI_ReadBit(void) |
|||
{ |
|||
|
|||
uint8_t bit; |
|||
int timeout = 500; |
|||
|
|||
while (!(GPIO_Read()) && timeout-- > 0) { |
|||
delay_us(1); |
|||
} |
|||
|
|||
if (timeout <= 0) { |
|||
uart_send_string("OWI Timeout\r\n"); |
|||
return 0xFF; |
|||
} |
|||
|
|||
delay_us(50); |
|||
bit = GPIO_Read(); |
|||
delay_us(30); |
|||
|
|||
return bit; |
|||
} |
|||
|
|||
|
|||
/**
|
|||
* 함수명: OWI_ReadByte |
|||
* 목적: 1-Wire 통신 라인에서 1바이트 데이터를 읽는다. |
|||
* |
|||
* 매개변수: 없음 |
|||
* |
|||
* 반환값: |
|||
* - 읽은 1바이트 데이터(uint8_t) |
|||
* |
|||
* 동작 방식: |
|||
* 1. 최상위 비트(MSB)부터 최하위 비트(LSB)까지 반복: |
|||
* - OWI_ReadBit() 함수를 호출하여 1비트씩 읽는다. |
|||
* - 읽은 비트를 적절히 시프트하여 data 변수에 저장. |
|||
* 2. 모든 8비트를 읽은 후 data 반환. |
|||
* |
|||
*/ |
|||
|
|||
uint8_t OWI_ReadByte(void) |
|||
{ |
|||
uint8_t data = 0; |
|||
int i; |
|||
|
|||
for (i = 7; i >= 0; i--) { |
|||
data |= (OWI_ReadBit() << i); |
|||
} |
|||
|
|||
return data; |
|||
} |
|||
|
|||
|
|||
/**
|
|||
* 함수명: OWI_T_ReadBytesAndPrint |
|||
* 목적: 1-Wire 통신으로 지정한 길이만큼 데이터를 읽고, UART로 형식화하여 출력한다. |
|||
* |
|||
* 매개변수: |
|||
* - length : 읽을 데이터 바이트 수 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1. buf 배열에 length만큼 OWI_ReadByte() 호출하여 1바이트씩 읽어 저장. |
|||
* 2. 첫 번째 바이트(buf[0])를 16진수 2자리 문자열로 변환하여 UART 전송. |
|||
* 3. 그 이후 바이트들은 두 개씩 묶어서 16진수 4자리 문자열로 변환 후 UART 전송: |
|||
* - delay(10000) 호출하여 출력 간 간격을 둠. |
|||
* 4. UART 출력은 sprintf → strcpy → uart_send_string 순으로 처리. |
|||
* |
|||
* 참고: |
|||
* - buf[0]는 별도로 출력하고, 이후 바이트들은 2바이트 단위로 묶어 출력. |
|||
* - delay를 통해 슬레이브와 UART 전송 간 타이밍을 확보. |
|||
* - 1-Wire 데이터를 확인하거나 디버깅용으로 사용되는 함수. |
|||
*/ |
|||
void OWI_T_ReadBytesAndPrint(int length) |
|||
{ |
|||
uint8_t buf[129]; |
|||
int i; |
|||
char uart_buf[8]; |
|||
char tmp_buf[8]; |
|||
|
|||
uint8_t va0, va1; |
|||
for (i = 0; i < length; i++) { |
|||
buf[i] = OWI_ReadByte(); |
|||
} |
|||
sprintf(uart_buf, "%02X ", buf[0]); |
|||
strcpy(tmp_buf, uart_buf); |
|||
uart_send_string(tmp_buf); |
|||
|
|||
for (i = 1; i < length; i+=2) { |
|||
|
|||
va0 = buf[i]; |
|||
va1 = buf[i+1]; |
|||
delay(10000); |
|||
sprintf(uart_buf, "%02X%02X ", va0, va1); |
|||
strcpy(tmp_buf, uart_buf); |
|||
uart_send_string(tmp_buf); |
|||
delay(10000); |
|||
} |
|||
} |
|||
|
|||
|
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: OWI_A_CommandMode |
|||
* 목적: 1-Wire 장치에서 ADC 데이터 및 명령어(CMD)를 처리하고 결과를 UART로 출력한다. |
|||
* |
|||
* 매개변수: |
|||
* - tx_data : 사용자 전송 데이터 포인터 (3바이트) |
|||
* - tx_len : 사용자 전송 데이터 길이 |
|||
* - id : 장치 ID |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) ADC 읽기 |
|||
* - ADC_ReadAndSend_UART() 호출하여 ADC 데이터를 읽음. |
|||
* - g_adc_bytes 배열을 읽고 2자리 소수점 형식으로 line 배열에 저장. |
|||
* - ADC 채널 수 불일치 시 "Err:adc_count" 출력 후 종료. |
|||
* |
|||
* 2) 1-Wire 장치 전원 켜기 |
|||
* - OWI_EnablePower() 호출. |
|||
* - 전원 안정화를 위해 7ms 지연. |
|||
* |
|||
* 3) 기본 명령(CMD) 전송 및 안전한 읽기 |
|||
* - CMD_LIST에 정의된 6개의 4바이트 명령을 순차적으로 전송. |
|||
* - 각 명령 전/후에 OWI_SecureStop() 호출하여 통신 라인을 초기화. |
|||
* - 각 명령 실행 후 read_address(0x51)로 데이터를 읽음. |
|||
* - 읽은 데이터가 모두 0xFF일 경우 최대 OWI_MAX_RETRY만큼 재시도. |
|||
* - 읽은 Rx 데이터에서 2번째, 3번째 바이트를 line 배열에 16진수로 추가. |
|||
* |
|||
* 4) 사용자 CMD 처리 (tx_data 존재 시) |
|||
* - tx_len가 3바이트인 경우 ID를 포함한 write 후 read 수행. |
|||
* - Rx 데이터 모두 0xFF일 경우 OWI_MAX_RETRY 재시도. |
|||
* - 정상 데이터 수신 시 line 배열에 2번째, 3번째 바이트 추가. |
|||
* - tx_data가 없으면 "0000"을 line 배열에 추가. |
|||
* |
|||
* 5) UART 출력 |
|||
* - 완성된 line 배열 끝에 CRLF 추가 후 uart_send_string()로 전송. |
|||
* |
|||
* 6) 마무리 |
|||
* - delay(10000) 후 OWI_DisablePower() 호출하여 장치 전원 차단. |
|||
* |
|||
* 참고: |
|||
* - OWI_SecureStop() 및 delay_us()를 통해 1-Wire 통신 타이밍과 안정성을 확보. |
|||
* - g_adc_bytes, RAM_BYTES, OWI_MAX_RETRY 등의 상수 및 전역 변수 활용. |
|||
* - UART로 출력되는 형식은 ADC값, 각 CMD 결과, 사용자 CMD 결과가 쉼표로 구분됨. |
|||
*/ |
|||
#define OWI_MAX_RETRY 2 // 재시도 2회
|
|||
#define OWI_RECOVERY_MIN_US 500 // datasheet 기준 최소 recovery 시간
|
|||
|
|||
void OWI_A_CommandMode(const uint8_t *tx_data, uint8_t tx_len, uint8_t id) |
|||
{ |
|||
|
|||
uint8_t CMD_LIST[6][4] = { |
|||
{0x50,0x2E,0x00,0x00}, // BR
|
|||
{0x50,0x2E,0x01,0x00}, // BR_AZ
|
|||
{0x50,0x2E,0x02,0x00}, // T_RAW
|
|||
{0x50,0x2E,0x16,0x00}, // Y_data
|
|||
{0x50,0x2E,0x41,0x00}, // BR_AOUT
|
|||
{0x50,0x2E,0x00,0x00} // BR_AOUT duplicate
|
|||
}; |
|||
|
|||
char line[128]; |
|||
size_t n = 0; |
|||
uint8_t rx[RAM_BYTES]; |
|||
int i, j, retry, all_ff; |
|||
float v; |
|||
uint8_t read_address = 0x51; |
|||
|
|||
// ===== 1) ADC 읽기 =====
|
|||
ADC_ReadAndSend_UART(); |
|||
if (g_adc_len != ADC_NUM_CH) { |
|||
uart_send_string("Err:adc_count\r\n"); |
|||
return; |
|||
} |
|||
for (j = 0; j < g_adc_len; j++) { |
|||
v = g_adc_bytes[j]; |
|||
n += sprintf(&line[n], "%.2f", v); |
|||
if (j + 1 < g_adc_len) line[n++] = ','; |
|||
} |
|||
line[n++] = ','; |
|||
|
|||
// ===== 2) OWI Power On =====
|
|||
OWI_EnablePower(); |
|||
delay_us(7000); // Power-on delay
|
|||
|
|||
// ===== 3) CMD 전송 및 안전한 읽기 =====
|
|||
for (j = 0; j < 6; j++) { |
|||
OWI_SecureStop(); |
|||
for (i = 0; i < 4; i++) OWI_WriteByte(CMD_LIST[j][i]); |
|||
OWI_Stop(); |
|||
|
|||
// CMD → read 회복 시간
|
|||
delay_us(OWI_RECOVERY_MIN_US); |
|||
|
|||
// Rx 초기화
|
|||
for (i = 0; i < RAM_BYTES; i++) rx[i] = 0xFF; |
|||
|
|||
for (retry = 0; retry <= OWI_MAX_RETRY; retry++) { |
|||
// read 전 충분한 recovery 확보
|
|||
delay_us(OWI_RECOVERY_MIN_US); |
|||
|
|||
OWI_SecureStop(); |
|||
OWI_WriteByte(read_address); |
|||
for (i = 0; i < RAM_BYTES; i++) rx[i] = OWI_ReadByte(); |
|||
OWI_Stop(); |
|||
|
|||
all_ff = 1; |
|||
for (i = 0; i < RAM_BYTES; i++) { |
|||
if (rx[i] != 0xFF) { all_ff = 0; break; } |
|||
} |
|||
|
|||
if (!all_ff) break; // 정상 데이터 수신
|
|||
if (retry == OWI_MAX_RETRY) { // 모든 재시도 실패
|
|||
OWI_DisablePower(); |
|||
return; |
|||
} |
|||
} |
|||
|
|||
n += sprintf(&line[n], "%02X%02X", rx[1], rx[2]); |
|||
line[n++] = ','; |
|||
} |
|||
|
|||
// ===== 4) 사용자 CMD 처리 =====
|
|||
if (tx_data != NULL && tx_len == 3) { |
|||
for (retry = 0; retry <= OWI_MAX_RETRY; retry++) { |
|||
// write CMD
|
|||
OWI_SecureStop(); |
|||
OWI_WriteByte(id << 1); |
|||
for (i = 0; i < 3; i++) OWI_WriteByte(tx_data[i]); |
|||
OWI_Stop(); |
|||
|
|||
// read 준비
|
|||
delay_us(OWI_RECOVERY_MIN_US); |
|||
|
|||
// read
|
|||
for (i = 0; i < RAM_BYTES; i++) rx[i] = 0xFF; |
|||
OWI_SecureStop(); |
|||
OWI_WriteByte((id << 1) | 1); |
|||
for (i = 0; i < RAM_BYTES; i++) rx[i] = OWI_ReadByte(); |
|||
OWI_Stop(); |
|||
|
|||
all_ff = 1; |
|||
for (i = 0; i < RAM_BYTES; i++) { |
|||
if (rx[i] != 0xFF) { all_ff = 0; break; } |
|||
} |
|||
|
|||
if (!all_ff) break; |
|||
if (retry == OWI_MAX_RETRY) { |
|||
OWI_DisablePower(); |
|||
return; |
|||
} |
|||
} |
|||
n += sprintf(&line[n], "%02X%02X", rx[1], rx[2]); |
|||
} else { |
|||
n += sprintf(&line[n], "0000"); |
|||
} |
|||
|
|||
// ===== 5) UART 출력 =====
|
|||
line[n++] = '\r'; |
|||
line[n++] = '\n'; |
|||
line[n] = '\0'; |
|||
uart_send_string(line); |
|||
|
|||
delay(10000); |
|||
OWI_DisablePower(); |
|||
} |
|||
|
|||
|
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: OWI_Diagnostic |
|||
* 목적: 1-Wire 장치에서 진단용 명령어를 전송하고 결과를 UART로 출력한다. |
|||
* |
|||
* 매개변수: |
|||
* - id : 장치 ID (사용되지 않지만 인터페이스 일관성 유지) |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) CMD_LIST에 정의된 10개의 4바이트 진단 명령어를 순차적으로 전송. |
|||
* - OWI_SecureStop() 호출로 통신 라인 초기화. |
|||
* - 각 명령 전송 후 OWI_Stop() 호출. |
|||
* - OWI_RECOVERY_MIN_US 동안 지연하여 장치 준비 시간 확보. |
|||
* |
|||
* 2) 각 명령어 수행 후 read_address(0x51)로 데이터를 읽음. |
|||
* - Rx 배열 초기화(0xFF) 후 OWI_ReadByte()로 데이터 수신. |
|||
* - 읽은 데이터가 모두 0xFF일 경우 최대 OWI_MAX_RETRY만큼 재시도. |
|||
* |
|||
* 3) 정상 데이터 수신 시 rx[1], rx[2] 바이트를 16진수로 line 배열에 추가. |
|||
* - 마지막 명령어가 아니면 콤마(,) 추가. |
|||
* |
|||
* 4) UART 출력 |
|||
* - line 배열 끝에 CRLF 추가 후 uart_send_string()으로 전송. |
|||
* |
|||
* 참고: |
|||
* - OWI_SecureStop() 및 delay_us()를 통해 1-Wire 통신 안정성을 확보. |
|||
* - 이 함수는 장치의 상태 진단 및 디버깅용으로 사용됨. |
|||
*/ |
|||
void OWI_Diagnostic(uint8_t id) |
|||
{ |
|||
uint8_t CMD_LIST[10][4] = { |
|||
{0x50,0x2E,0x01,0x00}, // BR
|
|||
{0x50,0x2E,0x00,0x00}, // BR_AZ
|
|||
{0x50,0x2E,0x02,0x00}, // T_RAW
|
|||
{0x50,0x2E,0x03,0x00}, // Y_data
|
|||
{0x50,0x2E,0x21,0x00}, // BR_AOUT
|
|||
{0x50,0x2E,0x04,0x00}, |
|||
{0x50,0x2E,0x05,0x00}, |
|||
{0x50,0x2E,0x07,0x00}, |
|||
{0x50,0x2E,0x19,0x00}, |
|||
{0x50,0x2E,0x0B,0x00} |
|||
}; |
|||
|
|||
char line[128]; |
|||
size_t n = 0; |
|||
uint8_t rx[RAM_BYTES]; |
|||
int i, j, retry, all_ff; |
|||
float v; |
|||
uint8_t read_address = 0x51; |
|||
|
|||
// ===== 3) CMD 전송 및 안전한 읽기 =====
|
|||
for (j = 0; j < 10; j++) { |
|||
OWI_SecureStop(); |
|||
for (i = 0; i < 4; i++) OWI_WriteByte(CMD_LIST[j][i]); |
|||
OWI_Stop(); |
|||
|
|||
// CMD → read 회복 시간
|
|||
delay_us(OWI_RECOVERY_MIN_US); |
|||
|
|||
// Rx 초기화
|
|||
for (i = 0; i < RAM_BYTES; i++) rx[i] = 0xFF; |
|||
|
|||
for (retry = 0; retry <= OWI_MAX_RETRY; retry++) { |
|||
// read 전 충분한 recovery 확보
|
|||
delay_us(OWI_RECOVERY_MIN_US); |
|||
|
|||
OWI_SecureStop(); |
|||
OWI_WriteByte(read_address); |
|||
for (i = 0; i < RAM_BYTES; i++) rx[i] = OWI_ReadByte(); |
|||
OWI_Stop(); |
|||
|
|||
all_ff = 1; |
|||
for (i = 0; i < RAM_BYTES; i++) { |
|||
if (rx[i] != 0xFF) { all_ff = 0; break; } |
|||
} |
|||
|
|||
if (!all_ff) break; // 정상 데이터 수신
|
|||
if (retry == OWI_MAX_RETRY) { // 모든 재시도 실패
|
|||
OWI_DisablePower(); |
|||
return; |
|||
} |
|||
} |
|||
|
|||
// 데이터 추가
|
|||
n += sprintf(&line[n], "%02X%02X", rx[1], rx[2]); |
|||
|
|||
// 마지막이 아닐 때만 콤마 추가
|
|||
if (j < 9) { |
|||
line[n++] = ','; |
|||
} |
|||
} |
|||
|
|||
// ===== 5) UART 출력 =====
|
|||
line[n++] = '\r'; |
|||
line[n++] = '\n'; |
|||
line[n] = '\0'; |
|||
uart_send_string(line); |
|||
|
|||
delay(10000); |
|||
} |
|||
|
|||
/**
|
|||
* 함수명: OWI_disable |
|||
* 목적: 1-Wire 장치 전원을 끄고, UART로 상태를 알린다. |
|||
* |
|||
* 매개변수: 없음 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) OWI_DisablePower() 호출하여 1-Wire 장치 전원 차단. |
|||
* 2) UART로 "51" 문자열과 CRLF 전송하여 장치가 종료되었음을 표시. |
|||
* |
|||
* 참고: |
|||
* - 장치 종료 후 외부 장치나 사용자에게 상태 알림용으로 UART 출력. |
|||
*/ |
|||
void OWI_disable() |
|||
|
|||
{ |
|||
OWI_DisablePower(); |
|||
uart_send_string("51\r\n"); |
|||
} |
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: OWI_T_CommandMode |
|||
* 목적: 1-Wire 장치에 명령어를 전송하고, UART로 완료 상태를 출력한다. |
|||
* |
|||
* 매개변수: |
|||
* - tx_data : 전송할 명령 데이터 배열 |
|||
* - tx_len : 전송할 명령 데이터 길이 |
|||
* - id : 1-Wire 장치 ID (슬레이브 주소) |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) 1-Wire 장치 전원 켜기 |
|||
* - OWI_EnablePower() 호출 |
|||
* - 전원 안정화를 위해 7ms 지연 |
|||
* |
|||
* 2) 1-Wire 초기화 |
|||
* - OWI_Init() 호출하여 통신 비트 주기 설정 |
|||
* |
|||
* 3) 명령 전송 (Write sequence) |
|||
* - OWI_SecureStop() 호출로 통신 라인 초기화 |
|||
* - 슬레이브 주소(id << 1)를 전송 (쓰기 모드) |
|||
* - tx_data 배열에 있는 명령 데이터를 순차적으로 전송 |
|||
* - OWI_Stop() 호출하여 쓰기 종료 |
|||
* |
|||
* 4) UART 출력 |
|||
* - "51" 문자열 전송하여 명령 전송 완료 상태 알림 |
|||
* |
|||
* 참고: |
|||
* - 이 함수는 단순히 명령어 전송만 수행하며, 데이터 읽기는 수행하지 않는다. |
|||
* - OWI_SecureStop()와 OWI_Stop()을 사용해 1-Wire 통신 안정성을 확보. |
|||
*/ |
|||
void OWI_T_CommandMode(const uint8_t *tx_data, uint8_t tx_len, uint8_t id) |
|||
{ |
|||
uint8_t rx[3] = {0}; |
|||
char uart_buf[16]; |
|||
int i; |
|||
|
|||
OWI_EnablePower(); |
|||
delay_us(7000); // Power-on delay
|
|||
OWI_Init(OWI_BIT_PERIOD_US); |
|||
|
|||
// Write sequence (슬레이브 주소와 명령 전송)
|
|||
OWI_SecureStop(); // 통신 준비
|
|||
OWI_WriteByte(id << 1); // 슬레이브 write 주소
|
|||
|
|||
for (i = 0; i < tx_len; i++) { |
|||
OWI_WriteByte(tx_data[i]); // 명령 전송
|
|||
} |
|||
OWI_Stop(); // 쓰기 종료
|
|||
uart_send_string("51\r\n"); |
|||
|
|||
|
|||
|
|||
|
|||
|
|||
} |
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: OWI_CommandMode |
|||
* 목적: 1-Wire 장치에 명령어를 전송하고, UART로 완료 상태를 출력한다. |
|||
* |
|||
* 매개변수: |
|||
* - tx_data : 전송할 명령 데이터 배열 |
|||
* - tx_len : 전송할 명령 데이터 길이 |
|||
* - id : 1-Wire 장치 ID (슬레이브 주소) |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) 명령 전송 (Write sequence) |
|||
* - OWI_SecureStop() 호출로 통신 라인 초기화 |
|||
* - 슬레이브 주소(id << 1)를 전송 (쓰기 모드) |
|||
* - tx_data 배열에 있는 명령 데이터를 순차적으로 전송 |
|||
* - OWI_Stop() 호출하여 쓰기 종료 |
|||
* |
|||
* 2) UART 출력 |
|||
* - "51" 문자열 전송하여 명령 전송 완료 상태 알림 |
|||
* |
|||
* 참고: |
|||
* - 전원 켜기/통신 초기화 단계는 포함되어 있지 않음 |
|||
* - 이 함수는 단순히 명령어 전송만 수행하며, 데이터 읽기는 수행하지 않는다 |
|||
* - OWI_SecureStop()와 OWI_Stop()을 사용해 1-Wire 통신 안정성을 확보 |
|||
*/ |
|||
void OWI_CommandMode(const uint8_t *tx_data, uint8_t tx_len, uint8_t id) |
|||
{ |
|||
uint8_t rx[3] = {0}; |
|||
char uart_buf[16]; |
|||
int i; |
|||
|
|||
// Write sequence (슬레이브 주소와 명령 전송)
|
|||
OWI_SecureStop(); // 통신 준비
|
|||
OWI_WriteByte(id << 1); // 슬레이브 write 주소
|
|||
|
|||
for (i = 0; i < tx_len; i++) { |
|||
OWI_WriteByte(tx_data[i]); // 명령 전송
|
|||
} |
|||
OWI_Stop(); // 쓰기 종료
|
|||
|
|||
uart_send_string("51\r\n"); |
|||
} |
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: OWI_ReadBytesAndPrint |
|||
* 목적: 1-Wire 장치에서 지정된 길이만큼 데이터를 읽고, UART로 출력한다. |
|||
* |
|||
* 매개변수: |
|||
* - length : 읽을 바이트 수 |
|||
* - id : 1-Wire 장치 ID (슬레이브 주소) |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) 읽기 시작 |
|||
* - OWI_SecureStop() 호출로 통신 라인 초기화 |
|||
* - (id << 1) | 1 전송하여 슬레이브 읽기 모드 설정 |
|||
* |
|||
* 2) 지정된 length만큼 OWI_ReadByte()로 데이터 읽기 |
|||
* - 읽은 데이터는 buf 배열에 저장 |
|||
* |
|||
* 3) UART 출력 |
|||
* - buf[0] 단독 출력 |
|||
* - 이후 1번부터는 두 바이트씩 페어로 묶어 출력 |
|||
* - 마지막 바이트가 홀수이면 단독 출력 |
|||
* - 각 출력 전후에 delay(10000) 호출 (UART 전송 안정성 확보) |
|||
* - 출력 포맷: 16진수 문자열 |
|||
* - 마지막에 CRLF("\r\n") 추가 |
|||
* |
|||
* 참고: |
|||
* - UART 출력 시 임시 버퍼(uart_buf, tmp_buf)를 사용 |
|||
* - delay를 통해 데이터 안정성 및 가독성 확보 |
|||
*/ |
|||
void OWI_ReadBytesAndPrint(int length, uint8_t id) |
|||
{ |
|||
uint8_t buf[600]; |
|||
int i; |
|||
char uart_buf[8]; |
|||
char tmp_buf[8]; |
|||
|
|||
uint8_t va0, va1; |
|||
|
|||
OWI_SecureStop(); |
|||
OWI_WriteByte((id << 1) | 1); |
|||
|
|||
for (i = 0; i < length; i++) { |
|||
buf[i] = OWI_ReadByte(); |
|||
} |
|||
sprintf(uart_buf, "%02X ", buf[0]); |
|||
strcpy(tmp_buf, uart_buf); |
|||
uart_send_string(tmp_buf); |
|||
|
|||
for (i = 1; i < length; i += 2) { |
|||
|
|||
va0 = buf[i]; |
|||
|
|||
if (i + 1 < length) { |
|||
// 완전한 페어
|
|||
va1 = buf[i + 1]; |
|||
delay(10000); |
|||
sprintf(uart_buf, "%02X%02X ", va0, va1); |
|||
strcpy(tmp_buf, uart_buf); |
|||
uart_send_string(tmp_buf); |
|||
delay(10000); |
|||
} else { |
|||
// 마지막 1바이트가 남은 경우 단독 출력
|
|||
delay(10000); |
|||
sprintf(uart_buf, "%02X", va0); |
|||
strcpy(tmp_buf, uart_buf); |
|||
uart_send_string(tmp_buf); |
|||
delay(10000); |
|||
} |
|||
} |
|||
uart_send_string("\r\n"); |
|||
} |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,48 @@ |
|||
#include "r_cg_macrodriver.h" |
|||
#include "r_cg_serial.h" |
|||
#include "r_cg_port.h" |
|||
|
|||
|
|||
|
|||
// OWI에 사용할 핀 정의 (P70)
|
|||
#define OWI_PORT_P P7 // 포트 출력 레지스터
|
|||
#define OWI_PORT_PM PM7 // 포트 방향 (1: 입력, 0: 출력)
|
|||
#define OWI_PORT_PU PU7 // 내부 풀업
|
|||
#define OWI_PORT_POM POM7 // Open-drain 설정
|
|||
|
|||
#define OWI_PIN_MASK (1 << 0) // P70 = bit 0
|
|||
#define OWI_BIT_PERIOD_US 100 |
|||
#define TBIT OWI_BIT_PERIOD_US |
|||
#define TLOW_0 (TBIT * 0.75) // 75us
|
|||
#define TLOW_1 (TBIT * 0.25) // 225us
|
|||
#define TSTOP_LOW (TBIT * 2) // 600us
|
|||
#define TIDLE (TBIT * 3) // 900us
|
|||
#define TSTART_HOLD 50 // ≥25us 기준으로 50us 확보
|
|||
#define SECURE_HIGH 250 |
|||
#define SECURE_TOGGLE_COUNT 3 |
|||
#define SECURE_TOGGLE_LOW 40 |
|||
#define SECURE_TOGGLE_HIGH 60 |
|||
|
|||
static uint32_t bit_period_us = 100; // 기본 OWI 비트 시간
|
|||
|
|||
void OWI_EnablePower(void); |
|||
void OWI_DisablePower(void); |
|||
void GPIO_Clear(void); |
|||
void GPIO_Input(void); |
|||
int GPIO_Read(void); |
|||
void OWI_Init(uint32_t bit_time_us); |
|||
void OWI_Start(void); |
|||
void OWI_Stop(void); |
|||
void OWI_SecureStop(void); |
|||
void OWI_WriteBit(int bit); |
|||
void OWI_WriteByte(uint8_t data); |
|||
uint8_t OWI_ReadBit(void); |
|||
uint8_t OWI_ReadByte(void); |
|||
void OWI_T_ReadBytesAndPrint(int length); |
|||
void OWI_ReadBytesAndPrint(int length, uint8_t id); |
|||
void OWI_T_CommandMode(const uint8_t *tx_data, uint8_t tx_len, uint8_t id); |
|||
void OWI_A_CommandMode(const uint8_t *tx_data, uint8_t tx_len, uint8_t id); |
|||
void owi_write_coefficients(void); |
|||
void OWI_CommandMode(const uint8_t *tx_data, uint8_t tx_len, uint8_t id); |
|||
void OWI_disable(); |
|||
void OWI_Diagnostic(uint8_t id); |
|||
@ -0,0 +1,161 @@ |
|||
/***********************************************************************************************************************
|
|||
* DISCLAIMER |
|||
* This software is supplied by Renesas Electronics Corporation and is only intended for use with Renesas products. |
|||
* No other uses are authorized. This software is owned by Renesas Electronics Corporation and is protected under all |
|||
* applicable laws, including copyright laws. |
|||
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING THIS SOFTWARE, WHETHER EXPRESS, IMPLIED |
|||
* OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
* NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY |
|||
* LAW, NEITHER RENESAS ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE FOR ANY DIRECT, |
|||
* INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR |
|||
* ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. |
|||
* Renesas reserves the right, without notice, to make changes to this software and to discontinue the availability |
|||
* of this software. By using this software, you agree to the additional terms and conditions found by accessing the |
|||
* following link: |
|||
* http://www.renesas.com/disclaimer
|
|||
* |
|||
* Copyright (C) 2012, 2021 Renesas Electronics Corporation. All rights reserved. |
|||
***********************************************************************************************************************/ |
|||
|
|||
/***********************************************************************************************************************
|
|||
* File Name : r_cg_adc.c |
|||
* Version : CodeGenerator for RL78/F14 V2.03.07.02 [08 Nov 2021] |
|||
* Device(s) : R5F10PPJ |
|||
* Tool-Chain : CCRL |
|||
* Description : This file implements device driver for ADC module. |
|||
* Creation Date: 2026-01-13 |
|||
***********************************************************************************************************************/ |
|||
|
|||
/***********************************************************************************************************************
|
|||
Includes |
|||
***********************************************************************************************************************/ |
|||
#include "r_cg_macrodriver.h" |
|||
#include "r_cg_adc.h" |
|||
/* Start user code for include. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
#include "r_cg_userdefine.h" |
|||
|
|||
/***********************************************************************************************************************
|
|||
Pragma directive |
|||
***********************************************************************************************************************/ |
|||
/* Start user code for pragma. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
|
|||
/***********************************************************************************************************************
|
|||
Global variables and functions |
|||
***********************************************************************************************************************/ |
|||
/* Start user code for global. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
|
|||
/***********************************************************************************************************************
|
|||
* Function Name: R_ADC_Create |
|||
* Description : This function initializes the AD converter. |
|||
* Arguments : None |
|||
* Return Value : None |
|||
***********************************************************************************************************************/ |
|||
void R_ADC_Create(void) |
|||
{ |
|||
ADCEN = 1U; /* supply AD clock */ |
|||
ADM0 = _00_AD_ADM0_INITIALVALUE; /* disable AD conversion and clear ADM0 register */ |
|||
ADMK = 1U; /* disable INTAD interrupt */ |
|||
ADIF = 0U; /* clear INTAD interrupt flag */ |
|||
/* Set INTAD low priority */ |
|||
ADPR1 = 1U; |
|||
ADPR0 = 1U; |
|||
/* The reset status of ADPC is analog input, so it's unnecessary to set. */ |
|||
/* Set ANI0 - ANI23 pin as analog input */ |
|||
PM10 |= 0x3FU; |
|||
PM9 |= 0xFFU; |
|||
PM8 |= 0xFFU; |
|||
PM3 |= 0x18U; |
|||
/* Set ANI24 pin */ |
|||
PMC12 |= 0x20U; |
|||
PM12 |= 0x20U; |
|||
/* Set ANI25 pin */ |
|||
PMC12 |= 0x01U; |
|||
PM12 |= 0x01U; |
|||
/* Set ANI26 pin */ |
|||
PMC7 |= 0x01U; |
|||
PM7 |= 0x01U; |
|||
/* Set ANI27 pin */ |
|||
PMC7 |= 0x02U; |
|||
PM7 |= 0x02U; |
|||
/* Set ANI28 pin */ |
|||
PMC7 |= 0x04U; |
|||
PM7 |= 0x04U; |
|||
/* Set ANI29 pin */ |
|||
PMC7 |= 0x08U; |
|||
PM7 |= 0x08U; |
|||
/* Set ANI30 pin */ |
|||
PMC7 |= 0x10U; |
|||
PM7 |= 0x10U; |
|||
ADM0 = _00_AD_CONVERSION_CLOCK_64 | _00_AD_TIME_MODE_NORMAL_1 | _00_AD_OPERMODE_SELECT; |
|||
ADM1 = _00_AD_TRIGGER_SOFTWARE | _00_AD_CONVMODE_CONSELECT; |
|||
ADM2 = _00_AD_POSITIVE_VDD | _00_AD_NEGATIVE_VSS | _00_AD_AREA_MODE_1 | _00_AD_RESOLUTION_10BIT; |
|||
ADUL = _FF_AD_ADUL_VALUE; |
|||
ADLL = _00_AD_ADLL_VALUE; |
|||
ADS = _00_AD_INPUT_CHANNEL_0; |
|||
} |
|||
|
|||
/***********************************************************************************************************************
|
|||
* Function Name: R_ADC_Start |
|||
* Description : This function starts the AD converter. |
|||
* Arguments : None |
|||
* Return Value : None |
|||
***********************************************************************************************************************/ |
|||
void R_ADC_Start(void) |
|||
{ |
|||
ADIF = 0U; /* clear INTAD interrupt flag */ |
|||
ADMK = 0U; /* enable INTAD interrupt */ |
|||
ADCS = 1U; /* enable AD conversion */ |
|||
} |
|||
|
|||
/***********************************************************************************************************************
|
|||
* Function Name: R_ADC_Stop |
|||
* Description : This function stops the AD converter. |
|||
* Arguments : None |
|||
* Return Value : None |
|||
***********************************************************************************************************************/ |
|||
void R_ADC_Stop(void) |
|||
{ |
|||
ADCS = 0U; /* disable AD conversion */ |
|||
ADMK = 1U; /* disable INTAD interrupt */ |
|||
ADIF = 0U; /* clear INTAD interrupt flag */ |
|||
} |
|||
|
|||
/***********************************************************************************************************************
|
|||
* Function Name: R_ADC_Set_OperationOn |
|||
* Description : This function enables comparator operation. |
|||
* Arguments : None |
|||
* Return Value : None |
|||
***********************************************************************************************************************/ |
|||
void R_ADC_Set_OperationOn(void) |
|||
{ |
|||
ADCE = 1U; /* enable AD comparator */ |
|||
} |
|||
|
|||
/***********************************************************************************************************************
|
|||
* Function Name: R_ADC_Set_OperationOff |
|||
* Description : This function stops comparator operation. |
|||
* Arguments : None |
|||
* Return Value : None |
|||
***********************************************************************************************************************/ |
|||
void R_ADC_Set_OperationOff(void) |
|||
{ |
|||
ADCE = 0U; /* disable AD comparator */ |
|||
} |
|||
|
|||
/***********************************************************************************************************************
|
|||
* Function Name: R_ADC_Get_Result |
|||
* Description : This function returns the conversion result in the buffer. |
|||
* Arguments : buffer - |
|||
* the address where to write the conversion result |
|||
* Return Value : None |
|||
***********************************************************************************************************************/ |
|||
void R_ADC_Get_Result(uint16_t * const buffer) |
|||
{ |
|||
*buffer = (uint16_t)(ADCR >> 6U); |
|||
} |
|||
|
|||
/* Start user code for adding. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
@ -0,0 +1,223 @@ |
|||
/***********************************************************************************************************************
|
|||
* DISCLAIMER |
|||
* This software is supplied by Renesas Electronics Corporation and is only intended for use with Renesas products. |
|||
* No other uses are authorized. This software is owned by Renesas Electronics Corporation and is protected under all |
|||
* applicable laws, including copyright laws. |
|||
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING THIS SOFTWARE, WHETHER EXPRESS, IMPLIED |
|||
* OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
* NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY |
|||
* LAW, NEITHER RENESAS ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE FOR ANY DIRECT, |
|||
* INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR |
|||
* ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. |
|||
* Renesas reserves the right, without notice, to make changes to this software and to discontinue the availability |
|||
* of this software. By using this software, you agree to the additional terms and conditions found by accessing the |
|||
* following link: |
|||
* http://www.renesas.com/disclaimer
|
|||
* |
|||
* Copyright (C) 2012, 2021 Renesas Electronics Corporation. All rights reserved. |
|||
***********************************************************************************************************************/ |
|||
|
|||
/***********************************************************************************************************************
|
|||
* File Name : r_cg_adc.h |
|||
* Version : CodeGenerator for RL78/F14 V2.03.07.02 [08 Nov 2021] |
|||
* Device(s) : R5F10PPJ |
|||
* Tool-Chain : CCRL |
|||
* Description : This file implements device driver for ADC module. |
|||
* Creation Date: 2026-01-13 |
|||
***********************************************************************************************************************/ |
|||
|
|||
#ifndef ADC_H |
|||
#define ADC_H |
|||
|
|||
/***********************************************************************************************************************
|
|||
Macro definitions (Register bit) |
|||
***********************************************************************************************************************/ |
|||
/*
|
|||
Peripheral enable register 0 (PER0) |
|||
*/ |
|||
/* Control of AD converter input clock (ADCEN) */ |
|||
#define _00_AD_CLOCK_STOP (0x00U) /* stop supply of input clock */ |
|||
#define _20_AD_CLOCK_SUPPLY (0x20U) /* supply input clock */ |
|||
|
|||
/*
|
|||
AD converter mode register 0 (ADM0) |
|||
*/ |
|||
#define _00_AD_ADM0_INITIALVALUE (0x00U) |
|||
/* AD conversion operation control (ADCS) */ |
|||
#define _80_AD_CONVERSION_ENABLE (0x80U) /* enable AD conversion operation control */ |
|||
#define _00_AD_CONVERSION_DISABLE (0x00U) /* disable AD conversion operation control */ |
|||
/* Specification of AD conversion operation mode (ADMD) */ |
|||
#define _00_AD_OPERMODE_SELECT (0x00U) /* select operation mode */ |
|||
#define _40_AD_OPERMODE_SCAN (0x40U) /* scan operation mode */ |
|||
/* AD conversion clock selection (FR2 - FR0) */ |
|||
#define _00_AD_CONVERSION_CLOCK_64 (0x00U) /* fCLK/64 */ |
|||
#define _08_AD_CONVERSION_CLOCK_32 (0x08U) /* fCLK/32 */ |
|||
#define _10_AD_CONVERSION_CLOCK_16 (0x10U) /* fCLK/16 */ |
|||
#define _18_AD_CONVERSION_CLOCK_8 (0x18U) /* fCLK/8 */ |
|||
#define _20_AD_CONVERSION_CLOCK_6 (0x20U) /* fCLK/6 */ |
|||
#define _28_AD_CONVERSION_CLOCK_5 (0x28U) /* fCLK/5 */ |
|||
#define _30_AD_CONVERSION_CLOCK_4 (0x30U) /* fCLK/4 */ |
|||
#define _38_AD_CONVERSION_CLOCK_2 (0x38U) /* fCLK/2 */ |
|||
/* Specification AD conversion time mode (LV1, LV0) */ |
|||
#define _00_AD_TIME_MODE_NORMAL_1 (0x00U) /* normal 1 mode */ |
|||
#define _02_AD_TIME_MODE_NORMAL_2 (0x02U) /* normal 2 mode */ |
|||
/* AD comparator operation control (ADCE) */ |
|||
#define _01_AD_COMPARATOR_ENABLE (0x01U) /* enable comparator operation control */ |
|||
#define _00_AD_COMPARATOR_DISABLE (0x00U) /* disable comparator operation control */ |
|||
|
|||
/*
|
|||
Analog input channel specification register (ADS) |
|||
*/ |
|||
/* Specification of analog input channel (ADISS, ADS4 - ADS0) */ |
|||
/* Select mode */ |
|||
#define _00_AD_INPUT_CHANNEL_0 (0x00U) /* ANI0 */ |
|||
#define _01_AD_INPUT_CHANNEL_1 (0x01U) /* ANI1 */ |
|||
#define _02_AD_INPUT_CHANNEL_2 (0x02U) /* ANI2 */ |
|||
#define _03_AD_INPUT_CHANNEL_3 (0x03U) /* ANI3 */ |
|||
#define _04_AD_INPUT_CHANNEL_4 (0x04U) /* ANI4 */ |
|||
#define _05_AD_INPUT_CHANNEL_5 (0x05U) /* ANI5 */ |
|||
#define _06_AD_INPUT_CHANNEL_6 (0x06U) /* ANI6 */ |
|||
#define _07_AD_INPUT_CHANNEL_7 (0x07U) /* ANI7 */ |
|||
#define _08_AD_INPUT_CHANNEL_8 (0x08U) /* ANI8 */ |
|||
#define _09_AD_INPUT_CHANNEL_9 (0x09U) /* ANI9 */ |
|||
#define _0A_AD_INPUT_CHANNEL_10 (0x0AU) /* ANI10 */ |
|||
#define _0B_AD_INPUT_CHANNEL_11 (0x0BU) /* ANI11 */ |
|||
#define _0C_AD_INPUT_CHANNEL_12 (0x0CU) /* ANI12 */ |
|||
#define _0D_AD_INPUT_CHANNEL_13 (0x0DU) /* ANI13 */ |
|||
#define _0E_AD_INPUT_CHANNEL_14 (0x0EU) /* ANI14 */ |
|||
#define _0F_AD_INPUT_CHANNEL_15 (0x0FU) /* ANI15 */ |
|||
#define _10_AD_INPUT_CHANNEL_16 (0x10U) /* ANI16 */ |
|||
#define _11_AD_INPUT_CHANNEL_17 (0x11U) /* ANI17 */ |
|||
#define _12_AD_INPUT_CHANNEL_18 (0x12U) /* ANI18 */ |
|||
#define _13_AD_INPUT_CHANNEL_19 (0x13U) /* ANI19 */ |
|||
#define _14_AD_INPUT_CHANNEL_20 (0x14U) /* ANI20 */ |
|||
#define _15_AD_INPUT_CHANNEL_21 (0x15U) /* ANI21 */ |
|||
#define _16_AD_INPUT_CHANNEL_22 (0x16U) /* ANI22 */ |
|||
#define _17_AD_INPUT_CHANNEL_23 (0x17U) /* ANI23 */ |
|||
#define _18_AD_INPUT_CHANNEL_24 (0x18U) /* ANI24 */ |
|||
#define _19_AD_INPUT_CHANNEL_25 (0x19U) /* ANI25 */ |
|||
#define _1A_AD_INPUT_CHANNEL_26 (0x1AU) /* ANI26 */ |
|||
#define _1B_AD_INPUT_CHANNEL_27 (0x1BU) /* ANI27 */ |
|||
#define _1C_AD_INPUT_CHANNEL_28 (0x1CU) /* ANI28 */ |
|||
#define _1D_AD_INPUT_CHANNEL_29 (0x1DU) /* ANI29 */ |
|||
#define _1E_AD_INPUT_CHANNEL_30 (0x1EU) /* ANI30 */ |
|||
#define _80_AD_INPUT_TEMPERSENSOR_0 (0x80U) /* temperature sensor 0 output is used to be the input channel */ |
|||
#define _81_AD_INPUT_INTERREFVOLT (0x81U) /* internal reference voltage output is used to be the input channel */ |
|||
/* Scan mode */ |
|||
#define _00_AD_INPUT_CHANNEL_0_3 (0x00U) /* ANI0 - ANI3 */ |
|||
#define _01_AD_INPUT_CHANNEL_1_4 (0x01U) /* ANI1 - ANI4 */ |
|||
#define _02_AD_INPUT_CHANNEL_2_5 (0x02U) /* ANI2 - ANI5 */ |
|||
#define _03_AD_INPUT_CHANNEL_3_6 (0x03U) /* ANI3 - ANI6 */ |
|||
#define _04_AD_INPUT_CHANNEL_4_7 (0x04U) /* ANI4 - ANI7 */ |
|||
#define _05_AD_INPUT_CHANNEL_5_8 (0x05U) /* ANI5 - ANI8 */ |
|||
#define _06_AD_INPUT_CHANNEL_6_9 (0x06U) /* ANI6 - ANI9 */ |
|||
#define _07_AD_INPUT_CHANNEL_7_10 (0x07U) /* ANI7 - ANI10 */ |
|||
#define _08_AD_INPUT_CHANNEL_8_11 (0x08U) /* ANI8 - ANI11 */ |
|||
#define _09_AD_INPUT_CHANNEL_9_12 (0x09U) /* ANI9 - ANI12 */ |
|||
#define _0A_AD_INPUT_CHANNEL_10_13 (0x0AU) /* ANI10 - ANI13 */ |
|||
#define _0B_AD_INPUT_CHANNEL_11_14 (0x0BU) /* ANI11 - ANI14 */ |
|||
#define _0C_AD_INPUT_CHANNEL_12_15 (0x0CU) /* ANI12 - ANI15 */ |
|||
#define _0D_AD_INPUT_CHANNEL_13_16 (0x0DU) /* ANI13 - ANI16 */ |
|||
#define _0E_AD_INPUT_CHANNEL_14_17 (0x0EU) /* ANI14 - ANI17 */ |
|||
#define _0F_AD_INPUT_CHANNEL_15_18 (0x0FU) /* ANI15 - ANI18 */ |
|||
#define _10_AD_INPUT_CHANNEL_16_19 (0x10U) /* ANI16 - ANI19 */ |
|||
#define _11_AD_INPUT_CHANNEL_17_20 (0x11U) /* ANI17 - ANI20 */ |
|||
#define _12_AD_INPUT_CHANNEL_18_21 (0x12U) /* ANI18 - ANI21 */ |
|||
#define _13_AD_INPUT_CHANNEL_19_22 (0x13U) /* ANI19 - ANI22 */ |
|||
#define _14_AD_INPUT_CHANNEL_20_23 (0x14U) /* ANI20 - ANI23 */ |
|||
|
|||
/*
|
|||
AD converter mode register 1 (ADM1) |
|||
*/ |
|||
/* AD trigger mode selection (ADTMD1, ADTMD0) */ |
|||
#define _00_AD_TRIGGER_SOFTWARE (0x00U) /* software trigger mode */ |
|||
#define _80_AD_TRIGGER_HARDWARE_NOWAIT (0x80U) /* hardware trigger mode (no wait) */ |
|||
#define _C0_AD_TRIGGER_HARDWARE_WAIT (0xC0U) /* hardware trigger mode (wait) */ |
|||
/* AD convertion mode selection (ADSCM) */ |
|||
#define _00_AD_CONVMODE_CONSELECT (0x00U) /* continuous convertion mode */ |
|||
#define _20_AD_CONVMODE_ONESELECT (0x20U) /* oneshot convertion mode */ |
|||
/* Trigger signal selection (ADTRS1, ADTRS0) */ |
|||
#define _00_AD_TRIGGER_INTTM01 (0x00U) /* INTTM01 */ |
|||
#define _01_AD_TRIGGER_ELC (0x01U) /* ELC */ |
|||
#define _01_AD_TRIGGER_TIMER (0x01U) /* INTTRD0,INTTRJ0 */ |
|||
#define _02_AD_TRIGGER_INTRTC (0x02U) /* INTRTC */ |
|||
/*
|
|||
AD converter mode register 2 (ADM2) |
|||
*/ |
|||
/* AD VREF(+) selection (ADREFP1, ADREFP0) */ |
|||
#define _00_AD_POSITIVE_VDD (0x00U) /* use VDD as VREF(+) */ |
|||
#define _40_AD_POSITIVE_AVREFP (0x40U) /* use AVREFP as VREF(+) */ |
|||
#define _80_AD_POSITIVE_INTERVOLT (0x80U) /* use internal voltage as VREF(+) */ |
|||
/* AD VREF(-) selection (ADREFM) */ |
|||
#define _00_AD_NEGATIVE_VSS (0x00U) /* use VSS as VREF(-) */ |
|||
#define _20_AD_NEGATIVE_AVREFM (0x20U) /* use AVREFM as VREF(-) */ |
|||
/* AD conversion result upper/lower bound value selection (ADRCK) */ |
|||
#define _00_AD_AREA_MODE_1 (0x00U) /* generates INTAD when ADLL <= ADCRH <= ADUL */ |
|||
#define _08_AD_AREA_MODE_2_3 (0x08U) /* generates INTAD when ADUL < ADCRH or ADLL > ADCRH */ |
|||
/* AD wakeup function selection (AWC) */ |
|||
#define _00_AD_WAKEUP_OFF (0x00U) /* stop wakeup function */ |
|||
#define _04_AD_WAKEUP_ON (0x04U) /* use wakeup function */ |
|||
/* AD resolution selection (ADTYP) */ |
|||
#define _00_AD_RESOLUTION_10BIT (0x00U) /* 10 bits */ |
|||
#define _01_AD_RESOLUTION_8BIT (0x01U) /* 8 bits */ |
|||
|
|||
/*
|
|||
AD test function register (ADTES) |
|||
*/ |
|||
/* AD test mode signal (ADTES2 - ADTES0) */ |
|||
#define _00_AD_NORMAL_INPUT (0x00U) /* normal mode */ |
|||
#define _02_AD_TEST_AVREFM (0x02U) /* use AVREFM as test signal */ |
|||
#define _03_AD_TEST_AVREFP (0x03U) /* use AVREFP as test signal */ |
|||
/*
|
|||
Format of A/D Converter Trigger Select Register 0 (ADTRGS0)(F13 only) |
|||
*/ |
|||
/* Selection of the operation trigger of the A/D converter when the timer RD0 input capture B/compare match B
|
|||
interrupt request is generated (ADTRGS00) */ |
|||
#define _01_AD_TRIGGER_INTTRD0 (0x01U) /* A/D conversion is started when the interrupt request is generated */ |
|||
|
|||
/*
|
|||
Format of A/D Converter Trigger Select Register 1 (ADTRGS1)(F13 only) |
|||
*/ |
|||
/* Selection of the operation trigger of the A/D converter when the timer RJ0 interrupt request is generated (ADTRGS10) */ |
|||
#define _01_AD_TRIGGER_INTTRJ0 (0x01U) /* A/D conversion is started when the interrupt request is generated */ |
|||
|
|||
/***********************************************************************************************************************
|
|||
Macro definitions |
|||
***********************************************************************************************************************/ |
|||
/* Upper bound (ADUL) value */ |
|||
#define _FF_AD_ADUL_VALUE (0xFFU) |
|||
/* Upper bound (ADLL) value */ |
|||
#define _00_AD_ADLL_VALUE (0x00U) |
|||
|
|||
/***********************************************************************************************************************
|
|||
Typedef definitions |
|||
***********************************************************************************************************************/ |
|||
typedef enum |
|||
{ |
|||
ADCHANNEL0, ADCHANNEL1, ADCHANNEL2, ADCHANNEL3, ADCHANNEL4, ADCHANNEL5, ADCHANNEL6, |
|||
ADCHANNEL7, ADCHANNEL8, ADCHANNEL9, ADCHANNEL10, ADCHANNEL11, ADCHANNEL12, |
|||
ADCHANNEL13, ADCHANNEL14, ADCHANNEL15, ADCHANNEL16, ADCHANNEL17, ADCHANNEL18, |
|||
ADCHANNEL19, ADCHANNEL20, ADCHANNEL21, ADCHANNEL22, ADCHANNEL23, ADCHANNEL24 = 24U, |
|||
ADCHANNEL25, ADCHANNEL26, ADCHANNEL27, ADCHANNEL28, ADCHANNEL29, ADCHANNEL30, |
|||
ADTEMPERSENSOR0 = 128U, ADINTERREFVOLT |
|||
} ad_channel_t; |
|||
typedef enum |
|||
{ |
|||
ADNORMALINPUT, |
|||
ADAVREFM = 2U, |
|||
ADAVREFP |
|||
} test_channel_t; |
|||
|
|||
/***********************************************************************************************************************
|
|||
Global functions |
|||
***********************************************************************************************************************/ |
|||
void R_ADC_Create(void); |
|||
void R_ADC_Start(void); |
|||
void R_ADC_Stop(void); |
|||
void R_ADC_Set_OperationOn(void); |
|||
void R_ADC_Set_OperationOff(void); |
|||
void R_ADC_Get_Result(uint16_t * const buffer); |
|||
|
|||
/* Start user code for function. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
#endif |
|||
@ -0,0 +1,64 @@ |
|||
/***********************************************************************************************************************
|
|||
* DISCLAIMER |
|||
* This software is supplied by Renesas Electronics Corporation and is only intended for use with Renesas products. |
|||
* No other uses are authorized. This software is owned by Renesas Electronics Corporation and is protected under all |
|||
* applicable laws, including copyright laws. |
|||
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING THIS SOFTWARE, WHETHER EXPRESS, IMPLIED |
|||
* OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
* NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY |
|||
* LAW, NEITHER RENESAS ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE FOR ANY DIRECT, |
|||
* INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR |
|||
* ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. |
|||
* Renesas reserves the right, without notice, to make changes to this software and to discontinue the availability |
|||
* of this software. By using this software, you agree to the additional terms and conditions found by accessing the |
|||
* following link: |
|||
* http://www.renesas.com/disclaimer
|
|||
* |
|||
* Copyright (C) 2012, 2021 Renesas Electronics Corporation. All rights reserved. |
|||
***********************************************************************************************************************/ |
|||
|
|||
/***********************************************************************************************************************
|
|||
* File Name : r_cg_adc_user.c |
|||
* Version : CodeGenerator for RL78/F14 V2.03.07.02 [08 Nov 2021] |
|||
* Device(s) : R5F10PPJ |
|||
* Tool-Chain : CCRL |
|||
* Description : This file implements device driver for ADC module. |
|||
* Creation Date: 2026-01-13 |
|||
***********************************************************************************************************************/ |
|||
|
|||
/***********************************************************************************************************************
|
|||
Includes |
|||
***********************************************************************************************************************/ |
|||
#include "r_cg_macrodriver.h" |
|||
#include "r_cg_adc.h" |
|||
/* Start user code for include. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
#include "r_cg_userdefine.h" |
|||
|
|||
/***********************************************************************************************************************
|
|||
Pragma directive |
|||
***********************************************************************************************************************/ |
|||
#pragma interrupt r_adc_interrupt(vect=INTAD) |
|||
/* Start user code for pragma. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
|
|||
/***********************************************************************************************************************
|
|||
Global variables and functions |
|||
***********************************************************************************************************************/ |
|||
/* Start user code for global. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
|
|||
/***********************************************************************************************************************
|
|||
* Function Name: r_adc_interrupt |
|||
* Description : This function is INTAD interrupt service routine. |
|||
* Arguments : None |
|||
* Return Value : None |
|||
***********************************************************************************************************************/ |
|||
static void __near r_adc_interrupt(void) |
|||
{ |
|||
/* Start user code. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
} |
|||
|
|||
/* Start user code for adding. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
@ -0,0 +1,63 @@ |
|||
/***********************************************************************************************************************
|
|||
* DISCLAIMER |
|||
* This software is supplied by Renesas Electronics Corporation and is only intended for use with Renesas products. |
|||
* No other uses are authorized. This software is owned by Renesas Electronics Corporation and is protected under all |
|||
* applicable laws, including copyright laws. |
|||
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING THIS SOFTWARE, WHETHER EXPRESS, IMPLIED |
|||
* OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
* NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY |
|||
* LAW, NEITHER RENESAS ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE FOR ANY DIRECT, |
|||
* INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR |
|||
* ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. |
|||
* Renesas reserves the right, without notice, to make changes to this software and to discontinue the availability |
|||
* of this software. By using this software, you agree to the additional terms and conditions found by accessing the |
|||
* following link: |
|||
* http://www.renesas.com/disclaimer
|
|||
* |
|||
* Copyright (C) 2012, 2021 Renesas Electronics Corporation. All rights reserved. |
|||
***********************************************************************************************************************/ |
|||
|
|||
/***********************************************************************************************************************
|
|||
* File Name : r_cg_port.c |
|||
* Version : CodeGenerator for RL78/F14 V2.03.07.02 [08 Nov 2021] |
|||
* Device(s) : R5F10PPJ |
|||
* Tool-Chain : CCRL |
|||
* Description : This file implements device driver for PORT module. |
|||
* Creation Date: 2026-01-13 |
|||
***********************************************************************************************************************/ |
|||
|
|||
/***********************************************************************************************************************
|
|||
Includes |
|||
***********************************************************************************************************************/ |
|||
#include "r_cg_macrodriver.h" |
|||
#include "r_cg_port.h" |
|||
/* Start user code for include. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
#include "r_cg_userdefine.h" |
|||
|
|||
/***********************************************************************************************************************
|
|||
Pragma directive |
|||
***********************************************************************************************************************/ |
|||
/* Start user code for pragma. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
|
|||
/***********************************************************************************************************************
|
|||
Global variables and functions |
|||
***********************************************************************************************************************/ |
|||
/* Start user code for global. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
|
|||
/***********************************************************************************************************************
|
|||
* Function Name: R_PORT_Create |
|||
* Description : This function initializes the Port I/O. |
|||
* Arguments : None |
|||
* Return Value : None |
|||
***********************************************************************************************************************/ |
|||
void R_PORT_Create(void) |
|||
{ |
|||
P13 = _00_Pn0_OUTPUT_0; |
|||
POM6 = _04_POMn2_NCH_ON | _08_POMn3_NCH_ON; |
|||
} |
|||
|
|||
/* Start user code for adding. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
@ -0,0 +1,265 @@ |
|||
/***********************************************************************************************************************
|
|||
* DISCLAIMER |
|||
* This software is supplied by Renesas Electronics Corporation and is only intended for use with Renesas products. |
|||
* No other uses are authorized. This software is owned by Renesas Electronics Corporation and is protected under all |
|||
* applicable laws, including copyright laws. |
|||
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING THIS SOFTWARE, WHETHER EXPRESS, IMPLIED |
|||
* OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
* NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY |
|||
* LAW, NEITHER RENESAS ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE FOR ANY DIRECT, |
|||
* INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR |
|||
* ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. |
|||
* Renesas reserves the right, without notice, to make changes to this software and to discontinue the availability |
|||
* of this software. By using this software, you agree to the additional terms and conditions found by accessing the |
|||
* following link: |
|||
* http://www.renesas.com/disclaimer
|
|||
* |
|||
* Copyright (C) 2012, 2021 Renesas Electronics Corporation. All rights reserved. |
|||
***********************************************************************************************************************/ |
|||
|
|||
/***********************************************************************************************************************
|
|||
* File Name : r_cg_port.h |
|||
* Version : CodeGenerator for RL78/F14 V2.03.07.02 [08 Nov 2021] |
|||
* Device(s) : R5F10PPJ |
|||
* Tool-Chain : CCRL |
|||
* Description : This file implements device driver for PORT module. |
|||
* Creation Date: 2026-01-13 |
|||
***********************************************************************************************************************/ |
|||
|
|||
#ifndef PORT_H |
|||
#define PORT_H |
|||
|
|||
/***********************************************************************************************************************
|
|||
Macro definitions (Register bit) |
|||
***********************************************************************************************************************/ |
|||
/*
|
|||
Port Mode Register (PMm) |
|||
*/ |
|||
/* Pmn pin I/O mode selection (PMm7 - PMm0) */ |
|||
#define _01_PMn0_NOT_USE (0x01U) /* not use Pn0 as digital I/O */ |
|||
#define _01_PMn0_MODE_INPUT (0x01U) /* use Pn0 as input mode */ |
|||
#define _00_PMn0_MODE_OUTPUT (0x00U) /* use Pn0 as output mode */ |
|||
#define _02_PMn1_NOT_USE (0x02U) /* not use Pn1 as digital I/O */ |
|||
#define _02_PMn1_MODE_INPUT (0x02U) /* use Pn1 as input mode */ |
|||
#define _00_PMn1_MODE_OUTPUT (0x00U) /* use Pn1 as output mode */ |
|||
#define _04_PMn2_NOT_USE (0x04U) /* not use Pn2 as digital I/O */ |
|||
#define _04_PMn2_MODE_INPUT (0x04U) /* use Pn2 as input mode */ |
|||
#define _00_PMn2_MODE_OUTPUT (0x00U) /* use Pn2 as output mode */ |
|||
#define _08_PMn3_NOT_USE (0x08U) /* not use Pn3 as digital I/O */ |
|||
#define _08_PMn3_MODE_INPUT (0x08U) /* use Pn3 as input mode */ |
|||
#define _00_PMn3_MODE_OUTPUT (0x00U) /* use Pn3 as output mode */ |
|||
#define _10_PMn4_NOT_USE (0x10U) /* not use Pn4 as digital I/O */ |
|||
#define _10_PMn4_MODE_INPUT (0x10U) /* use Pn4 as input mode */ |
|||
#define _00_PMn4_MODE_OUTPUT (0x00U) /* use Pn4 as output mode */ |
|||
#define _20_PMn5_NOT_USE (0x20U) /* not use Pn5 as digital I/O */ |
|||
#define _20_PMn5_MODE_INPUT (0x20U) /* use Pn5 as input mode */ |
|||
#define _00_PMn5_MODE_OUTPUT (0x00U) /* use Pn5 as output mode */ |
|||
#define _40_PMn6_NOT_USE (0x40U) /* not use Pn6 as digital I/O */ |
|||
#define _40_PMn6_MODE_INPUT (0x40U) /* use Pn6 as input mode */ |
|||
#define _00_PMn6_MODE_OUTPUT (0x00U) /* use Pn6 as output mode */ |
|||
#define _80_PMn7_NOT_USE (0x80U) /* not use Pn7 as digital I/O */ |
|||
#define _80_PMn7_MODE_INPUT (0x80U) /* use Pn7 as input mode */ |
|||
#define _00_PMn7_MODE_OUTPUT (0x00U) /* use Pn7 as output mode */ |
|||
|
|||
/*
|
|||
Port Register (Pm) |
|||
*/ |
|||
/* Pmn pin data (Pm0 to Pm7) */ |
|||
#define _00_Pn0_OUTPUT_0 (0x00U) /* Pn0 output 0 */ |
|||
#define _01_Pn0_OUTPUT_1 (0x01U) /* Pn0 output 1 */ |
|||
#define _00_Pn1_OUTPUT_0 (0x00U) /* Pn1 output 0 */ |
|||
#define _02_Pn1_OUTPUT_1 (0x02U) /* Pn1 output 1 */ |
|||
#define _00_Pn2_OUTPUT_0 (0x00U) /* Pn2 output 0 */ |
|||
#define _04_Pn2_OUTPUT_1 (0x04U) /* Pn2 output 1 */ |
|||
#define _00_Pn3_OUTPUT_0 (0x00U) /* Pn3 output 0 */ |
|||
#define _08_Pn3_OUTPUT_1 (0x08U) /* Pn3 output 1 */ |
|||
#define _00_Pn4_OUTPUT_0 (0x00U) /* Pn4 output 0 */ |
|||
#define _10_Pn4_OUTPUT_1 (0x10U) /* Pn4 output 1 */ |
|||
#define _00_Pn5_OUTPUT_0 (0x00U) /* Pn5 output 0 */ |
|||
#define _20_Pn5_OUTPUT_1 (0x20U) /* Pn5 output 1 */ |
|||
#define _00_Pn6_OUTPUT_0 (0x00U) /* Pn6 output 0 */ |
|||
#define _40_Pn6_OUTPUT_1 (0x40U) /* Pn6 output 1 */ |
|||
#define _00_Pn7_OUTPUT_0 (0x00U) /* Pn7 output 0 */ |
|||
#define _80_Pn7_OUTPUT_1 (0x80U) /* Pn7 output 1 */ |
|||
|
|||
/*
|
|||
Pull-up Resistor Option Register (PUm) |
|||
*/ |
|||
/* Pmn pin on-chip pull-up resistor selection (PUmn) */ |
|||
#define _00_PUn0_PULLUP_OFF (0x00U) /* Pn0 pull-up resistor not connected */ |
|||
#define _01_PUn0_PULLUP_ON (0x01U) /* Pn0 pull-up resistor connected */ |
|||
#define _00_PUn1_PULLUP_OFF (0x00U) /* Pn1 pull-up resistor not connected */ |
|||
#define _02_PUn1_PULLUP_ON (0x02U) /* Pn1 pull-up resistor connected */ |
|||
#define _00_PUn2_PULLUP_OFF (0x00U) /* Pn2 Pull-up resistor not connected */ |
|||
#define _04_PUn2_PULLUP_ON (0x04U) /* Pn2 pull-up resistor connected */ |
|||
#define _00_PUn3_PULLUP_OFF (0x00U) /* Pn3 pull-up resistor not connected */ |
|||
#define _08_PUn3_PULLUP_ON (0x08U) /* Pn3 pull-up resistor connected */ |
|||
#define _00_PUn4_PULLUP_OFF (0x00U) /* Pn4 pull-up resistor not connected */ |
|||
#define _10_PUn4_PULLUP_ON (0x10U) /* Pn4 pull-up resistor connected */ |
|||
#define _00_PUn5_PULLUP_OFF (0x00U) /* Pn5 pull-up resistor not connected */ |
|||
#define _20_PUn5_PULLUP_ON (0x20U) /* Pn5 pull-up resistor connected */ |
|||
#define _00_PUn6_PULLUP_OFF (0x00U) /* Pn6 pull-up resistor not connected */ |
|||
#define _40_PUn6_PULLUP_ON (0x40U) /* Pn6 pull-up resistor connected */ |
|||
#define _00_PUn7_PULLUP_OFF (0x00U) /* Pn7 pull-up resistor not connected */ |
|||
#define _80_PUn7_PULLUP_ON (0x80U) /* Pn7 pull-up resistor connected */ |
|||
|
|||
/*
|
|||
Port Input Mode Register (PIMm) |
|||
*/ |
|||
/* Pmn pin input buffer selection (PIMmn) */ |
|||
#define _00_PIMn0_TTL_OFF (0x00U) /* set Pn0 normal input buffer */ |
|||
#define _01_PIMn0_TTL_ON (0x01U) /* set Pn0 TTL input buffer */ |
|||
#define _00_PIMn1_TTL_OFF (0x00U) /* set Pn1 normal input buffer */ |
|||
#define _02_PIMn1_TTL_ON (0x02U) /* set Pn1 TTL input buffer */ |
|||
#define _00_PIMn2_TTL_OFF (0x00U) /* set Pn2 normal input buffer */ |
|||
#define _04_PIMn2_TTL_ON (0x04U) /* set Pn2 TTL input buffer */ |
|||
#define _00_PIMn3_TTL_OFF (0x00U) /* set Pn3 normal input buffer */ |
|||
#define _08_PIMn3_TTL_ON (0x08U) /* set Pn3 TTL input buffer */ |
|||
#define _00_PIMn4_TTL_OFF (0x00U) /* set Pn4 normal input buffer */ |
|||
#define _10_PIMn4_TTL_ON (0x10U) /* set Pn4 TTL input buffer */ |
|||
#define _00_PIMn5_TTL_OFF (0x00U) /* set Pn5 normal input buffer */ |
|||
#define _20_PIMn5_TTL_ON (0x20U) /* set Pn5 TTL input buffer */ |
|||
#define _00_PIMn6_TTL_OFF (0x00U) /* set Pn6 normal input buffer */ |
|||
#define _40_PIMn6_TTL_ON (0x40U) /* set Pn6 TTL input buffer */ |
|||
#define _00_PIMn7_TTL_OFF (0x00U) /* set Pn7 normal input buffer */ |
|||
#define _80_PIMn7_TTL_ON (0x80U) /* set Pn7 TTL input buffer */ |
|||
|
|||
/*
|
|||
Port Input Threshold Control Register (PITHLm) |
|||
*/ |
|||
/* Pmn pin input threshold selection (PITHLmn) */ |
|||
#define _00_PITHLn0_SCHMITT3_OFF (0x00U) /* set Pn0 schmitt 1 input (default) */ |
|||
#define _01_PITHLn0_SCHMITT3_ON (0x01U) /* set Pn0 schmitt 3 input */ |
|||
#define _00_PITHLn1_SCHMITT3_OFF (0x00U) /* set Pn1 schmitt 1 input (default) */ |
|||
#define _02_PITHLn1_SCHMITT3_ON (0x02U) /* set Pn1 schmitt 3 input */ |
|||
#define _00_PITHLn2_SCHMITT3_OFF (0x00U) /* set Pn2 schmitt 1 input (default) */ |
|||
#define _04_PITHLn2_SCHMITT3_ON (0x04U) /* set Pn2 schmitt 3 input */ |
|||
#define _00_PITHLn3_SCHMITT3_OFF (0x00U) /* set Pn3 schmitt 1 input (default) */ |
|||
#define _08_PITHLn3_SCHMITT3_ON (0x08U) /* set Pn3 schmitt 3 input */ |
|||
#define _00_PITHLn4_SCHMITT3_OFF (0x00U) /* set Pn4 schmitt 1 input (default) */ |
|||
#define _10_PITHLn4_SCHMITT3_ON (0x10U) /* set Pn4 schmitt 3 input */ |
|||
#define _00_PITHLn5_SCHMITT3_OFF (0x00U) /* set Pn5 schmitt 1 input (default) */ |
|||
#define _20_PITHLn5_SCHMITT3_ON (0x20U) /* set Pn5 schmitt 3 input */ |
|||
#define _00_PITHLn6_SCHMITT3_OFF (0x00U) /* set Pn6 schmitt 1 input (default) */ |
|||
#define _40_PITHLn6_SCHMITT3_ON (0x40U) /* set Pn6 schmitt 3 input */ |
|||
#define _00_PITHLn7_SCHMITT3_OFF (0x00U) /* set Pn7 schmitt 1 input (default) */ |
|||
#define _80_PITHLn7_SCHMITT3_ON (0x80U) /* set Pn7 schmitt 3 input */ |
|||
|
|||
/*
|
|||
Port Output Mode Register (POMm) |
|||
*/ |
|||
/* Pmn pin output mode selection (POMmn) */ |
|||
#define _00_POMn0_NCH_OFF (0x00U) /* set Pn0 output normal mode */ |
|||
#define _01_POMn0_NCH_ON (0x01U) /* set Pn0 output N-ch open-drain mode */ |
|||
#define _00_POMn1_NCH_OFF (0x00U) /* set Pn1 output normal mode */ |
|||
#define _02_POMn1_NCH_ON (0x02U) /* set Pn1 output N-ch open-drain mode */ |
|||
#define _00_POMn2_NCH_OFF (0x00U) /* set Pn2 output normal mode */ |
|||
#define _04_POMn2_NCH_ON (0x04U) /* set Pn2 output N-ch open-drain mode */ |
|||
#define _00_POMn3_NCH_OFF (0x00U) /* set Pn3 output normal mode */ |
|||
#define _08_POMn3_NCH_ON (0x08U) /* set Pn3 output N-ch open-drain mode */ |
|||
#define _00_POMn4_NCH_OFF (0x00U) /* set Pn4 output normal mode */ |
|||
#define _10_POMn4_NCH_ON (0x10U) /* set Pn4 output N-ch open-drain mode */ |
|||
#define _00_POMn5_NCH_OFF (0x00U) /* set Pn5 output normal mode */ |
|||
#define _20_POMn5_NCH_ON (0x20U) /* set Pn5 output N-ch open-drain mode */ |
|||
#define _00_POMn6_NCH_OFF (0x00U) /* set Pn6 output normal mode */ |
|||
#define _40_POMn6_NCH_ON (0x40U) /* set Pn6 output N-ch open-drain mode */ |
|||
#define _00_POMn7_NCH_OFF (0x00U) /* set Pn7 output normal mode */ |
|||
#define _80_POMn7_NCH_ON (0x80U) /* set Pn7 output N-ch open-drain mode */ |
|||
|
|||
/*
|
|||
Port Operation Mode Register (PMCm) |
|||
*/ |
|||
/* Pmn pin digital input buffer selection (PMCmn) */ |
|||
#define _01_PMCn0_NOT_USE (0x01U) /* not use Pn0 digital input */ |
|||
#define _00_PMCn0_DI_ON (0x00U) /* enable Pn0 digital input */ |
|||
#define _02_PMCn1_NOT_USE (0x02U) /* not use Pn1 digital input */ |
|||
#define _00_PMCn1_DI_ON (0x00U) /* enable Pn1 digital input */ |
|||
#define _04_PMCn2_NOT_USE (0x04U) /* not use Pn2 digital input */ |
|||
#define _00_PMCn2_DI_ON (0x00U) /* enable Pn2 digital input */ |
|||
#define _08_PMCn3_NOT_USE (0x08U) /* not use Pn3 digital input */ |
|||
#define _00_PMCn3_DI_ON (0x00U) /* enable Pn3 digital input */ |
|||
#define _10_PMCn4_NOT_USE (0x10U) /* not use Pn4 digital input */ |
|||
#define _00_PMCn4_DI_ON (0x00U) /* enable Pn4 digital input */ |
|||
#define _20_PMCn5_NOT_USE (0x20U) /* not use Pn5 digital input */ |
|||
#define _00_PMCn5_DI_ON (0x00U) /* enable Pn5 digital input */ |
|||
#define _40_PMCn6_NOT_USE (0x40U) /* not use Pn6 digital input */ |
|||
#define _00_PMCn6_DI_ON (0x00U) /* enable Pn6 digital input */ |
|||
#define _80_PMCn7_NOT_USE (0x80U) /* not use Pn7 digital input */ |
|||
#define _00_PMCn7_DI_ON (0x00U) /* enable Pn7 digital input */ |
|||
|
|||
/*
|
|||
Port output slew rate select register (PSRSEL) |
|||
*/ |
|||
/* P140/PCLBUZ0 pin output mode selection (PSR140) */ |
|||
#define _00_PSR140_NORMAL (0x00U) /* normal mode (5 V/5 ns) */ |
|||
#define _20_PSR140_SLOW (0x20U) /* slow mode (25 V/5 ns (target) (TYP.)) */ |
|||
/* P14/SCK01/SCL01/TO06/TRDIOC0 pin output mode selection (PSR14) */ |
|||
#define _00_PSR14_NORMAL (0x00U) /* normal mode (5 V/5 ns) */ |
|||
#define _10_PSR14_SLOW (0x10U) /* slow mode (25 V/5 ns (target) (TYP.)) */ |
|||
/* P120/SO01/TO07/TRDIOD0 pin output mode selection (PSR120) */ |
|||
#define _00_PSR120_NORMAL (0x00U) /* normal mode (5 V/5 ns) */ |
|||
#define _08_PSR120_SLOW (0x08U) /* slow mode (25 V/5 ns (target) (TYP.)) */ |
|||
/* P30/TO01/TRDIOD1/SNZOUT0 pin output mode selection (PSR30) */ |
|||
#define _00_PSR30_NORMAL (0x00U) /* normal mode (5 V/5 ns) */ |
|||
#define _04_PSR30_SLOW (0x04U) /* slow mode (25 V/5 ns (target) (TYP.)) */ |
|||
/* P12/SO10/TO11/(TRDIOD0)/TXD1/SNZOUT3 pin output mode selection (PSR12) */ |
|||
#define _00_PSR12_NORMAL (0x00U) /* normal mode (5 V/5 ns) */ |
|||
#define _02_PSR12_SLOW (0x02U) /* slow mode (25 V/5 ns (target) (TYP.)) */ |
|||
/* P10/SCK10/TO13/TRJO0/SCL10/LTXD1/CTXD0 pin output mode selection (PSR10) */ |
|||
#define _00_PSR10_NORMAL (0x00U) /* normal mode (5 V/5 ns) */ |
|||
#define _01_PSR10_SLOW (0x01U) /* slow mode (25 V/5 ns (target) (TYP.)) */ |
|||
|
|||
|
|||
/*
|
|||
AD port configuration register (ADPC) |
|||
*/ |
|||
/* Analog input/digital input switching (ADPC4 - ADPC0) */ |
|||
#define _00_ADPC_DI_OFF (0x00U) /* use P33, P34, P80 - P87, P90 - P97, P100 - P105 as analog input */ |
|||
#define _18_ADPC_DI_ON (0x18U) /* use P105 as digital input */ |
|||
#define _17_ADPC_DI_ON (0x17U) /* use P104 - P105 as digital input */ |
|||
#define _16_ADPC_DI_ON (0x16U) /* use P103 - P105 as digital input */ |
|||
#define _15_ADPC_DI_ON (0x15U) /* use P102 - P105 as digital input */ |
|||
#define _14_ADPC_DI_ON (0x14U) /* use P101 - P105 as digital input */ |
|||
#define _13_ADPC_DI_ON (0x13U) /* use P100 - P105 as digital input */ |
|||
#define _12_ADPC_DI_ON (0x12U) /* use P97, P100 - P105 as digital input */ |
|||
#define _11_ADPC_DI_ON (0x11U) /* use P96 - P97, P100 - P105 as digital input */ |
|||
#define _10_ADPC_DI_ON (0x10U) /* use P95 - P97, P100 - P105 as digital input */ |
|||
#define _0F_ADPC_DI_ON (0x0FU) /* use P94 - P97, P100 - P105 as digital input */ |
|||
#define _0E_ADPC_DI_ON (0x0EU) /* use P93 - P97, P100 - P105 as digital input */ |
|||
#define _0D_ADPC_DI_ON (0x0DU) /* use P92 - P97, P100 - P105 as digital input */ |
|||
#define _0C_ADPC_DI_ON (0x0CU) /* use P91 - P97, P100 - P105 as digital input */ |
|||
#define _0B_ADPC_DI_ON (0x0BU) /* use P90 - P97, P100 - P105 as digital input */ |
|||
#define _0A_ADPC_DI_ON (0x0AU) /* use P87, P90 - P97, P100 - P105 as digital input */ |
|||
#define _09_ADPC_DI_ON (0x09U) /* use P86 - P87, P90 - P97, P100 - P105 as digital input */ |
|||
#define _08_ADPC_DI_ON (0x08U) /* use P85 - P87, P90 - P97, P100 - P105 as digital input */ |
|||
#define _07_ADPC_DI_ON (0x07U) /* use P84 - P87, P90 - P97, P100 - P105 as digital input */ |
|||
#define _06_ADPC_DI_ON (0x06U) /* use P83 - P87, P90 - P97, P100 - P105 as digital input */ |
|||
#define _05_ADPC_DI_ON (0x05U) /* use P82 - P87, P90 - P97, P100 - P105 as digital input */ |
|||
#define _04_ADPC_DI_ON (0x04U) /* use P81 - P87, P90 - P97, P100 - P105 as digital input */ |
|||
#define _03_ADPC_DI_ON (0x03U) /* use P80 - P87, P90 - P97, P100 - P105 as digital input */ |
|||
#define _02_ADPC_DI_ON (0x02U) /* use P34, P80 - P87, P90 - P97, P100 - P105 as digital input */ |
|||
#define _01_ADPC_DI_ON (0x01U) /* use P33, P34, P80 - P87, P90 - P97, P100 - P105 as digital input */ |
|||
|
|||
/***********************************************************************************************************************
|
|||
Macro definitions |
|||
***********************************************************************************************************************/ |
|||
#define _F0_PM0_DEFAULT (0xF0U) /* PM0 default value */ |
|||
#define _E0_PM3_DEFAULT (0xE0U) /* PM3 default value */ |
|||
#define _1E_PM12_DEFAULT (0x1EU) /* PM12 default value */ |
|||
#define _FE_PM14_DEFAULT (0xFEU) /* PM14 default value */ |
|||
#define _E0_PMC7_DEFAULT (0xE0U) /* PMC7 default value */ |
|||
#define _DE_PMC12_DEFAULT (0xDEU) /* PMC12 default value */ |
|||
|
|||
|
|||
/***********************************************************************************************************************
|
|||
Typedef definitions |
|||
***********************************************************************************************************************/ |
|||
|
|||
/***********************************************************************************************************************
|
|||
Global functions |
|||
***********************************************************************************************************************/ |
|||
void R_PORT_Create(void); |
|||
|
|||
/* Start user code for function. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
#endif |
|||
@ -0,0 +1,51 @@ |
|||
/***********************************************************************************************************************
|
|||
* DISCLAIMER |
|||
* This software is supplied by Renesas Electronics Corporation and is only intended for use with Renesas products. |
|||
* No other uses are authorized. This software is owned by Renesas Electronics Corporation and is protected under all |
|||
* applicable laws, including copyright laws. |
|||
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING THIS SOFTWARE, WHETHER EXPRESS, IMPLIED |
|||
* OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
* NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY |
|||
* LAW, NEITHER RENESAS ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE FOR ANY DIRECT, |
|||
* INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR |
|||
* ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. |
|||
* Renesas reserves the right, without notice, to make changes to this software and to discontinue the availability |
|||
* of this software. By using this software, you agree to the additional terms and conditions found by accessing the |
|||
* following link: |
|||
* http://www.renesas.com/disclaimer
|
|||
* |
|||
* Copyright (C) 2012, 2021 Renesas Electronics Corporation. All rights reserved. |
|||
***********************************************************************************************************************/ |
|||
|
|||
/***********************************************************************************************************************
|
|||
* File Name : r_cg_port_user.c |
|||
* Version : CodeGenerator for RL78/F14 V2.03.07.02 [08 Nov 2021] |
|||
* Device(s) : R5F10PPJ |
|||
* Tool-Chain : CCRL |
|||
* Description : This file implements device driver for PORT module. |
|||
* Creation Date: 2026-01-13 |
|||
***********************************************************************************************************************/ |
|||
|
|||
/***********************************************************************************************************************
|
|||
Includes |
|||
***********************************************************************************************************************/ |
|||
#include "r_cg_macrodriver.h" |
|||
#include "r_cg_port.h" |
|||
/* Start user code for include. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
#include "r_cg_userdefine.h" |
|||
|
|||
/***********************************************************************************************************************
|
|||
Pragma directive |
|||
***********************************************************************************************************************/ |
|||
/* Start user code for pragma. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
|
|||
/***********************************************************************************************************************
|
|||
Global variables and functions |
|||
***********************************************************************************************************************/ |
|||
/* Start user code for global. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
|
|||
/* Start user code for adding. Do not edit comment generated here */ |
|||
/* End user code. Do not edit comment generated here */ |
|||
@ -0,0 +1,182 @@ |
|||
#include "uart.h" |
|||
#include "delay.h" |
|||
#include "r_cg_adc.h" |
|||
#include "r_cg_port.h" |
|||
|
|||
#define RS485_EN_PORT P4 |
|||
#define RS485_EN_PM PM4 |
|||
#define RS485_EN_MASK (0x20U) // P4.5
|
|||
|
|||
float g_adc_bytes[ADC_NUM_CH] = {0.0f}; |
|||
uint8_t g_adc_len = 0; |
|||
|
|||
void rs485_set_tx(uint8_t on) |
|||
{ |
|||
if (on) RS485_EN_PORT |= RS485_EN_MASK; // EN=1 (TX)
|
|||
else RS485_EN_PORT &= (uint8_t)~RS485_EN_MASK; // EN=0 (RX)
|
|||
} |
|||
|
|||
void rs485_init(void) |
|||
{ |
|||
RS485_EN_PM &= (uint8_t)~RS485_EN_MASK; // 출력
|
|||
rs485_set_tx(0); // 기본 RX 모드
|
|||
} |
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: uart_send_string |
|||
* 목적: null 종료된 문자열을 UART0로 전송 |
|||
* |
|||
* 매개변수: |
|||
* - str : 전송할 문자열 (C 문자열, '\0'로 종료) |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) 문자열 길이 계산 |
|||
* - 문자열 끝을 나타내는 '\0'이 나올 때까지 len 증가 |
|||
* |
|||
* 2) UART 전송 |
|||
* - R_UART0_Send() 함수를 사용하여 계산한 길이만큼 문자열 전송 |
|||
* - (uint8_t *)로 캐스팅하여 바이트 배열 형식 전달 |
|||
* |
|||
* 참고: |
|||
* - null 문자('\0')는 전송되지 않음 |
|||
* - UART0 초기화와 전송 준비는 별도로 되어 있어야 함 |
|||
*/ |
|||
|
|||
// UART0(RS485)
|
|||
void uart_send_string(const char *str) |
|||
{ |
|||
uint16_t len = 0; |
|||
while (str[len] != '\0') len++; |
|||
|
|||
rs485_set_tx(1); |
|||
R_UART0_Send((uint8_t *)str, len); |
|||
} |
|||
|
|||
// UART1(PC)
|
|||
void uart1_send_string(const char *str) |
|||
{ |
|||
uint16_t len = 0; |
|||
while (str[len] != '\0') len++; |
|||
R_UART1_Send((uint8_t *)str, len); |
|||
} |
|||
|
|||
/**
|
|||
* 함수명: uart_send_hex |
|||
* 목적: 8비트 값(uint8_t)을 16진수 문자열로 변환 후 UART0로 전송 |
|||
* |
|||
* 매개변수: |
|||
* - val : 전송할 8비트 값 |
|||
* |
|||
* 반환값: 없음 (void) |
|||
* |
|||
* 동작 방식: |
|||
* 1) 상위/하위 4비트 분리 |
|||
* - high = val >> 4, 상위 4비트 |
|||
* - low = val & 0x0F, 하위 4비트 |
|||
* |
|||
* 2) 16진수 문자로 변환 |
|||
* - 0~9 → '0'~'9' |
|||
* - 10~15 → 'A'~'F' |
|||
* - hex[0] = 상위 4비트 문자 |
|||
* - hex[1] = 하위 4비트 문자 |
|||
* |
|||
* 3) UART 전송 |
|||
* - R_UART0_Send()를 사용해 2바이트 전송 |
|||
* |
|||
* 4) 전송 후 지연 |
|||
* - delay(10000)으로 약간의 전송 간격 확보 |
|||
* |
|||
* 참고: |
|||
* - 이 함수는 1바이트 값을 항상 2자리 16진수로 표현 |
|||
* - 예: val = 0xAF → "AF" 전송 |
|||
*/ |
|||
void uart_send_hex(uint8_t val) |
|||
{ |
|||
uint8_t hex[2]; |
|||
uint8_t high = (val >> 4) & 0x0F; |
|||
uint8_t low = val & 0x0F; |
|||
|
|||
hex[0] = (high < 10) ? ('0' + high) : ('A' + (high - 10)); |
|||
hex[1] = (low < 10) ? ('0' + low) : ('A' + (low - 10)); |
|||
|
|||
rs485_set_tx(1); |
|||
R_UART0_Send(hex, 2); |
|||
delay(10000); |
|||
} |
|||
|
|||
void uart1_send_hex(uint8_t val) |
|||
{ |
|||
uint8_t hex[2]; |
|||
uint8_t high = (val >> 4) & 0x0F; |
|||
uint8_t low = val & 0x0F; |
|||
|
|||
hex[0] = (high < 10) ? ('0' + high) : ('A' + (high - 10)); |
|||
hex[1] = (low < 10) ? ('0' + low ) : ('A' + (low - 10)); |
|||
|
|||
R_UART1_Send(hex, 2); |
|||
delay(10000); |
|||
} |
|||
|
|||
|
|||
|
|||
/**
|
|||
* 함수명: ADC_ReadAndSend_UART |
|||
* 목적: 여러 ADC 채널을 읽고 전압으로 변환하여 전역 배열에 저장 |
|||
* |
|||
* 동작 방식: |
|||
* 1) ADC 채널 배열 정의 |
|||
* - ADC_NUM_CH 개수만큼 읽을 채널 지정 |
|||
* - 예: {0x02, 0x03, 0x04, 0x05} |
|||
* |
|||
* 2) 각 채널 순차적으로 읽기 |
|||
* for (i = 0; i < ADC_NUM_CH; i++) |
|||
* a) ADS 레지스터에 채널 선택 |
|||
* b) R_ADC_Start()로 변환 시작 |
|||
* c) 변환 완료 대기 (ADIF == 1 될 때까지) |
|||
* d) ADIF 플래그 클리어 |
|||
* e) 변환 값 읽기: R_ADC_Get_Result(&adc_value) |
|||
* f) ADC 정지: R_ADC_Stop() |
|||
* |
|||
* 3) ADC 값을 전압으로 변환 |
|||
* - voltage = (adc_value / ADC_RESOLUTION) * VREF |
|||
* - 예: 12bit ADC, VREF = 5V이면 0~4095 → 0~5V 변환 |
|||
* |
|||
* 4) 전역 배열에 저장 |
|||
* - g_adc_bytes[i] = voltage |
|||
* - g_adc_len 증가 |
|||
* |
|||
* 참고: |
|||
* - g_adc_bytes[]: 변환된 전압 저장용 전역 배열 |
|||
* - g_adc_len: 현재 읽은 채널 수 |
|||
*/ |
|||
void ADC_ReadAndSend_UART(void) |
|||
{ |
|||
static const uint8_t ADC_CHANNELS[ADC_NUM_CH] = { 0x02,0x03,0x04,0x05}; |
|||
|
|||
uint16_t adc_value; |
|||
float voltage; |
|||
int i; |
|||
|
|||
g_adc_len = 0; |
|||
|
|||
for (i = 0; i < ADC_NUM_CH; i++) { |
|||
ADS = ADC_CHANNELS[i]; // 채널 선택
|
|||
R_ADC_Start(); // 변환 시작
|
|||
while (ADIF == 0U); // 변환 완료 대기
|
|||
ADIF = 0U; |
|||
|
|||
R_ADC_Get_Result(&adc_value); |
|||
R_ADC_Stop(); |
|||
|
|||
/* V 계산 */ |
|||
voltage = (adc_value / ADC_RESOLUTION) * VREF; |
|||
|
|||
g_adc_bytes[i] = voltage; |
|||
g_adc_len++; |
|||
} |
|||
|
|||
} |
|||
@ -0,0 +1,37 @@ |
|||
#include "r_cg_macrodriver.h" |
|||
#include "r_cg_serial.h" |
|||
#include "r_cg_adc.h" |
|||
|
|||
|
|||
|
|||
|
|||
#define ADC_RESOLUTION 1023.0f // 10-bit ADC
|
|||
#define VREF 5.06f // V
|
|||
#define ADC_NUM_CH 4 |
|||
#define RAM_BYTES 13 |
|||
#define UART_RX_BUF_SIZE 96 |
|||
|
|||
extern float g_adc_bytes[ADC_NUM_CH]; |
|||
extern uint8_t g_adc_len; |
|||
|
|||
extern volatile uint8_t uart_rx_done; |
|||
extern volatile uint8_t uart_rx_index; |
|||
extern volatile uint8_t uart_rx_buffer[UART_RX_BUF_SIZE]; |
|||
extern volatile uint16_t uart_rx_length; |
|||
|
|||
|
|||
void uart_send_string(const char *str); // UART0(RS485)
|
|||
void uart_send_hex(uint8_t val); // UART0(RS485)
|
|||
|
|||
void uart1_send_string(const char *str); // UART1(PC)
|
|||
void uart1_send_hex(uint8_t val); // UART1(PC)
|
|||
|
|||
//void UART0_ReceiveHandler(void);
|
|||
void ADC_ReadAndSend_UART(void); |
|||
void cmd_enter_command_mode(const unsigned char *d, unsigned int len); |
|||
void cmd_unknown(const unsigned char *d, unsigned int len); |
|||
|
|||
// RS485 EN(P45)
|
|||
void rs485_init(void); |
|||
void rs485_set_tx(uint8_t on); |
|||
|
|||
Loading…
Reference in new issue