huahua/RP-01
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

增加通风加热

Browse Source
This commit is contained in:
sunbeam 2024-12-18 17:07:26 +08:00
parent 23b3ce33dd
commit 2c43f79bf5
19 changed files with 800 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
cva_asw_m0146/cva_asw_m0146.ewp
View File

@ -1104,7 +1104,7 @@
<data> <data>
<buildActions> <buildActions>
<buildAction> <buildAction>
<cmdline>powershell -ExecutionPolicy Bypass -File $PROJ_DIR$\fresh_extern.ps1 &amp;&amp; echo &gt; "$BUILD_FILES_DIR$/.postbuild"</cmdline> <cmdline>powershell -ExecutionPolicy Bypass -File $PROJ_DIR$\fresh_extern.ps1</cmdline>
<workingDirectory>$PROJ_DIR$</workingDirectory> <workingDirectory>$PROJ_DIR$</workingDirectory>
<buildSequence>preCompile</buildSequence> <buildSequence>preCompile</buildSequence>
</buildAction> </buildAction>
@ -3020,6 +3020,9 @@
<file> <file>
<name>$PROJ_DIR$\src\extern.c</name> <name>$PROJ_DIR$\src\extern.c</name>
</file> </file>
<file>
<name>$PROJ_DIR$\src\FanHeat.c</name>
</file>
<file> <file>
<name>$PROJ_DIR$\src\hwctrl.c</name> <name>$PROJ_DIR$\src\hwctrl.c</name>
</file> </file>

6
cva_asw_m0146/cva_asw_m0146.ewt
View File

@ -3644,9 +3644,9 @@
</file> </file>
<file> <file>
<name>$PROJ_DIR$\src\extern.c</name> <name>$PROJ_DIR$\src\extern.c</name>
<configuration> </file>
<name>Debug</name> <file>
</configuration> <name>$PROJ_DIR$\src\FanHeat.c</name>
</file> </file>
<file> <file>
<name>$PROJ_DIR$\src\hwctrl.c</name> <name>$PROJ_DIR$\src\hwctrl.c</name>

2
cva_asw_m0146/settings/cva_asw_m0146.dnx
View File

@ -25,8 +25,8 @@
<MemConfigValue>E:\Program Files\IAR Systems\Embedded Workbench 9.2\arm\config\debugger\CVAChip\CVM0144.ddf</MemConfigValue> <MemConfigValue>E:\Program Files\IAR Systems\Embedded Workbench 9.2\arm\config\debugger\CVAChip\CVM0144.ddf</MemConfigValue>
</PlDriver> </PlDriver>
<ArmDriver> <ArmDriver>
<EnforceMemoryConfiguration>1</EnforceMemoryConfiguration>
<EnableCache>0</EnableCache> <EnableCache>0</EnableCache>
<EnforceMemoryConfiguration>1</EnforceMemoryConfiguration>
</ArmDriver> </ArmDriver>
<DebugChecksum> <DebugChecksum>
<Checksum>3001005802</Checksum> <Checksum>3001005802</Checksum>

8
cva_asw_m0146/settings/cva_asw_m0146.wsdt
View File

File diff suppressed because one or more lines are too long

113
cva_asw_m0146/src/FanHeat.c Normal file
View File

@ -0,0 +1,113 @@
/*******************************************************************************
* the includes
******************************************************************************/
#include "FanHeat.h"
#include "key.h"
#include "hwctrl.h"
#include "scm_canmatrix-binutil.h"
/*******************************************************************************
* the defines
******************************************************************************/
/*******************************************************************************
* the typedefs
******************************************************************************/
/*******************************************************************************
* the globals
******************************************************************************/
static uint8_t HeatState,FanState;
static uint16_t HeatDutyCounter;
/*******************************************************************************
* the const
******************************************************************************/
const uint8_t HeatDutyTab[4] = {0,10,20,80};
const uint8_t FanDutyTab[4] = {0,10,30,100};
/*******************************************************************************
* the functions
******************************************************************************/
static void HeatTask(void);
static void SetFanHeatMsg(void);
static void FanTask(void);
void FanHeatInit(void)
{
HeatState = 0;
FanState = 0;
HeatDutyCounter = 0;
}
void FanHeatMainTaks(void)//10ms
{
if (getKeyPressFlag(KEY_HEAT) == KEY_PRESSED)
{
HeatState++;
if (HeatState > 3)
{
HeatState = 0;
}
}
if (getKeyPressFlag(KEY_FAN) == KEY_PRESSED)
{
FanState++;
if (FanState > 3)
{
FanState = 0;
}
}
FanTask();
HeatTask();
SetFanHeatMsg();
}
static void HeatTask(void)
{
if (HeatState!=0)
{
if (HeatDutyCounter > HeatDutyTab[HeatState])
{
HeatDrv1Ctrl(0);
}
else
{
HeatDrv1Ctrl(1);
}
HeatDutyCounter++;
if (HeatDutyCounter >= 100)
{
HeatDutyCounter = 0;
}
}
else
{
HeatDutyCounter = 0;
}
}
static void FanTask(void)
{
static uint8_t LastFanState=0;
if (LastFanState != FanState)
{
LastFanState = FanState;
FanCtrlDuty(FanDutyTab[FanState]);
}
}
static void SetFanHeatMsg(void)
{
scm_canmatrix_tx.SCM_STATE.ZY_FAN_STATE = FanState;
scm_canmatrix_tx.SCM_STATE.ZY_HEAT_STATE = HeatState;
}

33
cva_asw_m0146/src/FanHeat.h Normal file
View File

@ -0,0 +1,33 @@
#ifndef __FANHEAT__
#define __FANHEAT__
/*******************************************************************************
* the includes
******************************************************************************/
/*******************************************************************************
* the defines
******************************************************************************/
/*******************************************************************************
* the typedefs
******************************************************************************/
/*******************************************************************************
* the globals
******************************************************************************/
/*******************************************************************************
* the functions
******************************************************************************/
void FanHeatMainTaks(void);
void FanHeatInit(void);
#endif

82
cva_asw_m0146/src/MotorCtrl.c
View File

@ -49,7 +49,9 @@ MOTOR_DATA MotorData[6];
uint16_t MemoryLoc[3][6]; uint16_t MemoryLoc[3][6];
MEMORY_DATA MemoryData; MEMORY_DATA MemoryData;
uint8_t OC1flag,OC2flag,OC3flag; uint8_t OC1flag,OC2flag,OC3flag;
uint16_t OC1Count,OC2Count,OC3Count;
uint8_t MotorState[6],MotorStateReal[6]; uint8_t MotorState[6],MotorStateReal[6];
uint8_t MotorHallIO[6];
uint16_t MotorHallLoc[6],MotorHardStop1[6],MotorHardStop2[6]; uint16_t MotorHallLoc[6],MotorHardStop1[6],MotorHardStop2[6];
uint8_t MotorLearnState[6]; uint8_t MotorLearnState[6];
uint8_t MotorErr[6]; uint8_t MotorErr[6];
@ -64,12 +66,13 @@ uint16_t HallErrorCount[6];
******************************************************************************/ ******************************************************************************/
/******************************************************************************* /*******************************************************************************
* the local function prototypes * the local function
******************************************************************************/ ******************************************************************************/
static void MotorCtrl(void); static void MotorCtrl(void);
static void AutoCalCtrl(void); static void AutoCalCtrl(void);
static void MotorValueInit(void); static void MotorValueInit(void);
static void CurrentDetect(void);
static uint16_t getOverCurrentTh(uint8_t ch);
/******************************************************************************* /*******************************************************************************
* the local functions * the local functions
@ -538,18 +541,51 @@ static void MotorCtrl(void)//10ms
} }
static void CurrentDetect(void) #define OC_DELAY_TIME 200
void CurrentDetect(void)
{ {
uint32_t oc_th,current;
oc_th = getOverCurrentTh(0);
current = GetAdcmv(ADCH_RLY1)/10;
if (current > oc_th)
{
OC1Count++;
if (OC1Count > OC_DELAY_TIME)
{
OC1Count = 0;
OC1flag = 1;
}
}
else
{
OC1Count = 0;
}
oc_th = getOverCurrentTh(1);
current = GetAdcmv(ADCH_RLY3)/10;
if (current > oc_th)
{
OC2Count++;
if (OC2Count > OC_DELAY_TIME)
{
OC2Count = 0;
OC2flag = 1;
}
}
else
{
OC2Count = 0;
}
} }
/******************************************************************************* /*******************************************************************************
* the global functions * the global functions
******************************************************************************/ ******************************************************************************/
void MotorCtrl_Init(McuType *obj) void MotorCtrl_Init(void)
{ {
for (uint8_t i = 0; i < 6; i++) for (uint8_t i = 0; i < 6; i++)
{ {
hw_MotorCtrl(obj, i, Motor_ACT_NOACT); hw_MotorCtrl(i, Motor_ACT_NOACT);
} }
MotorValueInit(); MotorValueInit();
} }
@ -560,13 +596,38 @@ static void SetMotorMsg(void)
scm_canmatrix_tx.SCM_STATE.MOTOR_KB_STATE = MotorState[MotorKB]; scm_canmatrix_tx.SCM_STATE.MOTOR_KB_STATE = MotorState[MotorKB];
scm_canmatrix_tx.SCM_STATE.MOTOR_TT_STATE = MotorState[MotorTT]; scm_canmatrix_tx.SCM_STATE.MOTOR_TT_STATE = MotorState[MotorTT];
scm_canmatrix_tx.SCM_STATE.MOTOR_ZY_STATE = MotorState[MotorZY]; scm_canmatrix_tx.SCM_STATE.MOTOR_ZY_STATE = MotorState[MotorZY];
scm_canmatrix_tx.SCM_DEBUG1.DEBUG_MOTOR_HG_STATUS = MotorStateReal[MotorHG];
scm_canmatrix_tx.SCM_DEBUG2.DEBUG_MOTOR_KB_STATUS = MotorStateReal[MotorKB];
scm_canmatrix_tx.SCM_DEBUG3.DEBUG_MOTOR_TT_STATUS = MotorStateReal[MotorTT];
scm_canmatrix_tx.SCM_DEBUG4.DEBUG_MOTOR_ZY_STATUS = MotorStateReal[MotorZY];
scm_canmatrix_tx.SCM_DEBUG1.DEBUG_MOTOR_HG_LOC = MotorHallLoc[MotorHG];
scm_canmatrix_tx.SCM_DEBUG2.DEBUG_MOTOR_KB_LOC = MotorHallLoc[MotorKB];
scm_canmatrix_tx.SCM_DEBUG3.DEBUG_MOTOR_TT_LOC = MotorHallLoc[MotorTT];
scm_canmatrix_tx.SCM_DEBUG4.DEBUG_MOTOR_ZY_LOC = MotorHallLoc[MotorZY];
scm_canmatrix_tx.SCM_DEBUG1.DEBUG_MOTOR_HG_STOP_1 = MotorHardStop1[MotorHG];
scm_canmatrix_tx.SCM_DEBUG1.DEBUG_MOTOR_HG_STOP_2 = MotorHardStop2[MotorHG];
scm_canmatrix_tx.SCM_DEBUG2.DEBUG_MOTOR_KB_STOP_1 = MotorHardStop1[MotorKB];
scm_canmatrix_tx.SCM_DEBUG2.DEBUG_MOTOR_KB_STOP_2 = MotorHardStop2[MotorKB];
scm_canmatrix_tx.SCM_DEBUG3.DEBUG_MOTOR_TT_STOP_1 = MotorHardStop1[MotorTT];
scm_canmatrix_tx.SCM_DEBUG3.DEBUG_MOTOR_TT_STOP_2 = MotorHardStop2[MotorTT];
scm_canmatrix_tx.SCM_DEBUG4.DEBUG_MOTOR_ZY_STOP_1 = MotorHardStop1[MotorZY];
scm_canmatrix_tx.SCM_DEBUG4.DEBUG_MOTOR_ZY_STOP_2 = MotorHardStop2[MotorZY];
scm_canmatrix_tx.SCM_DEBUG1.DEBUG_MOTOR_HG_HALLIO = MotorHallIO[MotorHG];
scm_canmatrix_tx.SCM_DEBUG2.DEBUG_MOTOR_KB_HALLIO = MotorHallIO[MotorKB];
scm_canmatrix_tx.SCM_DEBUG3.DEBUG_MOTOR_TT_HALLIO = MotorHallIO[MotorTT];
scm_canmatrix_tx.SCM_DEBUG4.DEBUG_MOTOR_ZY_HALLIO = MotorHallIO[MotorZY];
} }
void MotorCtrl_Maintask(McuType *obj)//10ms task void MotorCtrl_Maintask(void)//10ms task
{ {
MotorCtrl(); MotorCtrl();
for (Motor_ID_Type i = 0; i < MOTOR_NUM; i++) for (Motor_ID_Type i = 0; i < MOTOR_NUM; i++)
{ {
hw_MotorCtrl(obj, i, MotorStateReal[i]); hw_MotorCtrl( i, MotorStateReal[i]);
} }
SetMotorMsg(); SetMotorMsg();
} }
@ -626,9 +687,9 @@ void StopAutoCal(void)
uint16_t getOverCurrentTh(uint8_t ch) static uint16_t getOverCurrentTh(uint8_t ch)
{ {
uint16_t th = 10; uint16_t th = 50;
switch (ch) switch (ch)
{ {
case 0: case 0:
@ -673,7 +734,8 @@ void HallDetecte(void)
uint8_t i,hallstate; uint8_t i,hallstate;
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++)
{ {
hallstate = GetIOState(i+1); hallstate = GetHallIO(i);
MotorHallIO[i] = hallstate;
if (hallstate != HallLastState[i]) if (hallstate != HallLastState[i])
{ {
HallDelay[i]++; HallDelay[i]++;

8
cva_asw_m0146/src/MotorCtrl.h
View File

@ -27,14 +27,14 @@ typedef enum
void MotorCtrl_Init(McuType *obj); void MotorCtrl_Init(void);
void MotorCtrl_Maintask(McuType *obj); void MotorCtrl_Maintask(void);
void setMotorState(Motor_ID_Type motorid,Motor_ACT_Type act); void setMotorState(Motor_ID_Type motorid,Motor_ACT_Type act);
void setMotorTarget(uint8_t motorid,uint16_t target); void setMotorTarget(uint8_t motorid,uint16_t target);
void StartAutoCal(void); void StartAutoCal(void);
void StopAutoCal(void); void StopAutoCal(void);
void CurrentDetect(void);
void HallDetecte(void);
#endif #endif

20
cva_asw_m0146/src/appTask.c
View File

@ -12,7 +12,7 @@
#include "canuser.h" #include "canuser.h"
#include "key.h" #include "key.h"
#include "scm_canmatrix-binutil.h" #include "scm_canmatrix-binutil.h"
#include "FanHeat.h"
/******************************************************************************* /*******************************************************************************
* the defines * the defines
******************************************************************************/ ******************************************************************************/
@ -28,7 +28,7 @@
uint8_t udsSendBuf[UDS_SEND_BUF] = {0}; uint8_t udsSendBuf[UDS_SEND_BUF] = {0};
uint8_t udsRecvBuf[UDS_RECV_BUF] = {0}; uint8_t udsRecvBuf[UDS_RECV_BUF] = {0};
extern McuType mcu;
UdsType udsObj; UdsType udsObj;
int64_t Get_Cur_Time_Stamp(void); int64_t Get_Cur_Time_Stamp(void);
@ -74,19 +74,21 @@ void SysTick_Handler(void)
timer_1ms++; timer_1ms++;
Uds_Tick(&udsObj); Uds_Tick(&udsObj);
} }
void appTask(McuType *obj) void appTask(void)
{ {
if(gSystick1msEvent > 0u) if(gSystick1msEvent > 0u)
{ {
if(udsObj.session == UDS_SESSION_PROGRAMMING) if(udsObj.session == UDS_SESSION_PROGRAMMING)
{ {
Asw_SetBootloaderRequest(); Asw_SetBootloaderRequest();
ResetDrv_SoftwareResetModule(&obj->resetDrv, RESETDRV_SWRESET_SYS); ResetDrv_SoftwareResetModule(&mcu.resetDrv, RESETDRV_SWRESET_SYS);
} }
gSystick1msEvent--; gSystick1msEvent--;
gSystick1msCnt++; gSystick1msCnt++;
gSysTick1sCnt++; gSysTick1sCnt++;
MsgTask(&udsObj); MsgTask(&udsObj);
CurrentDetect();
HallDetecte();
if (gSystick1msCnt % 5 == 0) if (gSystick1msCnt % 5 == 0)
{ {
KeyScanTask(); KeyScanTask();
@ -95,7 +97,8 @@ void appTask(McuType *obj)
if (gSystick1msCnt % 10 == 0) if (gSystick1msCnt % 10 == 0)
{ {
MotorCtrl_Maintask(obj); MotorCtrl_Maintask();
FanHeatMainTaks();
} }
if (gSystick1msCnt % 50 == 0) if (gSystick1msCnt % 50 == 0)
@ -119,13 +122,16 @@ void appTask(McuType *obj)
} }
} }
void appTaskInit(McuType *obj) void appTaskInit(void)
{ {
/* UDS init */ /* UDS init */
Uds_UserInit(&udsObj, &udsParam); Uds_UserInit(&udsObj, &udsParam);
MotorCtrl_Init(obj); MotorCtrl_Init();
power_ctrl(1);
FanHeatInit();
} }

4
cva_asw_m0146/src/appTask.h
View File

@ -4,7 +4,7 @@
#include "Mcu.h" #include "Mcu.h"
void appTask(McuType *obj); void appTask(void);
void appTaskInit(McuType *obj); void appTaskInit(void);
#endif #endif

51
cva_asw_m0146/src/canuser.c
View File

@ -18,6 +18,7 @@ typedef enum
UDS_MSG_IDX_STD_ECU_DEBUG1, UDS_MSG_IDX_STD_ECU_DEBUG1,
UDS_MSG_IDX_STD_ECU_DEBUG2, UDS_MSG_IDX_STD_ECU_DEBUG2,
UDS_MSG_IDX_STD_ECU_DEBUG3, UDS_MSG_IDX_STD_ECU_DEBUG3,
UDS_MSG_IDX_STD_ECU_DEBUG4,
UDS_MSG_IDX_NUM UDS_MSG_IDX_NUM
} Uds_MsgIdIdxType; } Uds_MsgIdIdxType;
@ -118,6 +119,10 @@ static uint8_t rxMsgBuf2[8] = {0};
static uint8_t debugMode; static uint8_t debugMode;
CAN_MESSAGE CAN_D_scm_state; CAN_MESSAGE CAN_D_scm_state;
CAN_MESSAGE CAN_D_scm_debug1;
CAN_MESSAGE CAN_D_scm_debug2;
CAN_MESSAGE CAN_D_scm_debug3;
CAN_MESSAGE CAN_D_scm_debug4;
/******************************************************************************* /*******************************************************************************
@ -133,6 +138,7 @@ const FlexCanDrv_MsgCfgType msgCfgObj[UDS_MSG_IDX_NUM] = {
{UDS_MSG_IDX_STD_ECU_DEBUG1,1, APP_TX_ECU_DEBUG1_MSG_ID,false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, false, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_TX */ {UDS_MSG_IDX_STD_ECU_DEBUG1,1, APP_TX_ECU_DEBUG1_MSG_ID,false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, false, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_TX */
{UDS_MSG_IDX_STD_ECU_DEBUG2,1, APP_TX_ECU_DEBUG2_MSG_ID,false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, false, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_TX */ {UDS_MSG_IDX_STD_ECU_DEBUG2,1, APP_TX_ECU_DEBUG2_MSG_ID,false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, false, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_TX */
{UDS_MSG_IDX_STD_ECU_DEBUG3,1, APP_TX_ECU_DEBUG3_MSG_ID,false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, false, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_TX */ {UDS_MSG_IDX_STD_ECU_DEBUG3,1, APP_TX_ECU_DEBUG3_MSG_ID,false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, false, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_TX */
{UDS_MSG_IDX_STD_ECU_DEBUG4,1, APP_TX_ECU_DEBUG4_MSG_ID,false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, false, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_TX */
}; };
@ -162,6 +168,17 @@ static void TxMessage(CAN_MESSAGE* msg)
{ {
FlexCanBoot_TxMessage(msg->MsgId, msg->Data, msg->DLC); FlexCanBoot_TxMessage(msg->MsgId, msg->Data, msg->DLC);
} }
static void CAN_TxMsg_Change(void)
{
scm_canmatrix_tx.SCM_STATE.test1 = GetAdcmv(ADCH_Power)/10;
scm_canmatrix_tx.SCM_STATE.test2 = GetAdcmv(ADCH_RLY1)/10;
scm_canmatrix_tx.SCM_STATE.test3 = GetAdcmv(ADCH_RLY3)/10;
scm_canmatrix_tx.SCM_STATE.test4 = GetAdcmv(ADCH_RLY5)/10;
scm_canmatrix_tx.SCM_STATE.test5 = GetAdcmv(ADCH_VBG)/10;
}
void MsgTask(UdsType *obj)//1ms task void MsgTask(UdsType *obj)//1ms task
{ {
static uint16_t msg_counter=0; static uint16_t msg_counter=0;
@ -172,19 +189,19 @@ void MsgTask(UdsType *obj)//1ms task
if (msg_counter >= 50) if (msg_counter >= 50)
{ {
msg_counter = 0; msg_counter = 0;
scm_canmatrix_tx.SCM_STATE.test1 = (uint8_t)adcResult[0];
scm_canmatrix_tx.SCM_STATE.test2 = (uint8_t)adcResult[1]; CAN_TxMsg_Change();
scm_canmatrix_tx.SCM_STATE.test3 = (uint8_t)adcResult[2];
scm_canmatrix_tx.SCM_STATE.test4 = (uint8_t)adcResult[3];
scm_canmatrix_tx.SCM_STATE.test5 = (uint8_t)adcResult[4];
Pack_SCM_STATE_CANmatrix(&scm_canmatrix_tx.SCM_STATE,&CAN_D_scm_state); Pack_SCM_STATE_CANmatrix(&scm_canmatrix_tx.SCM_STATE,&CAN_D_scm_state);
Pack_SCM_DEBUG1_CANmatrix(&scm_canmatrix_tx.SCM_DEBUG1,&CAN_D_scm_debug1);
Pack_SCM_DEBUG2_CANmatrix(&scm_canmatrix_tx.SCM_DEBUG2,&CAN_D_scm_debug2);
Pack_SCM_DEBUG3_CANmatrix(&scm_canmatrix_tx.SCM_DEBUG3,&CAN_D_scm_debug3);
Pack_SCM_DEBUG4_CANmatrix(&scm_canmatrix_tx.SCM_DEBUG4,&CAN_D_scm_debug4);
TxMessage(&CAN_D_scm_state); TxMessage(&CAN_D_scm_state);
if (debugMode!=0) TxMessage(&CAN_D_scm_debug1);
{ TxMessage(&CAN_D_scm_debug2);
FlexCanBoot_TxMessage(APP_TX_ECU_DEBUG1_MSG_ID, txMsgBuf2, 8); TxMessage(&CAN_D_scm_debug3);
FlexCanBoot_TxMessage(APP_TX_ECU_DEBUG2_MSG_ID, txMsgBuf3, 8); TxMessage(&CAN_D_scm_debug4);
FlexCanBoot_TxMessage(APP_TX_ECU_DEBUG3_MSG_ID, txMsgBuf4, 8);
}
} }
@ -235,7 +252,7 @@ int8_t FlexCanBoot_TxMessage(uint32_t msgId, const uint8_t* pData, uint8_t size)
return 0; return 0;
} }
void FlexCanBoot_Init(McuType *obj) void FlexCanBoot_Init()
{ {
uint32_t busClockFreq = 0; uint32_t busClockFreq = 0;
@ -249,13 +266,13 @@ void FlexCanBoot_Init(McuType *obj)
flexCanCfg.msgNum = sizeof(msgCfgObj) / sizeof(FlexCanDrv_MsgCfgType); flexCanCfg.msgNum = sizeof(msgCfgObj) / sizeof(FlexCanDrv_MsgCfgType);
flexCanCfg.msgCfg = msgCfgObj; flexCanCfg.msgCfg = msgCfgObj;
flexCanDrv_DemoObj = &obj->flexCanDrv0; flexCanDrv_DemoObj = &mcu.flexCanDrv0;
/* set PTE4 as MUX 5 - CAN0.RX */ /* set PTE4 as MUX 5 - CAN0.RX */
PinsDrv_SetMuxModeSel(&obj->ptb, 0, PINSDRV_MUX_ALT5); PinsDrv_SetMuxModeSel(&mcu.ptb, 0, PINSDRV_MUX_ALT5);
/* set PTE5 as MUX 5 - CAN0.TX */ /* set PTE5 as MUX 5 - CAN0.TX */
PinsDrv_SetMuxModeSel(&obj->ptb, 1, PINSDRV_MUX_ALT5); PinsDrv_SetMuxModeSel(&mcu.ptb, 1, PINSDRV_MUX_ALT5);
flexCanCfg.clkSrc = FLEXCANDRV_CLKSRC_CHICLK; flexCanCfg.clkSrc = FLEXCANDRV_CLKSRC_CHICLK;
flexCanCfg.fdEnable = false; flexCanCfg.fdEnable = false;
@ -266,11 +283,11 @@ void FlexCanBoot_Init(McuType *obj)
if(flexCanCfg.clkSrc == FLEXCANDRV_CLKSRC_CHICLK) if(flexCanCfg.clkSrc == FLEXCANDRV_CLKSRC_CHICLK)
{ {
ClockDrv_GetFreq(&obj->clockDrv, CLOCKDRV_APB, &busClockFreq); ClockDrv_GetFreq(&mcu.clockDrv, CLOCKDRV_APB, &busClockFreq);
} }
else else
{ {
ClockDrv_GetFreq(&obj->clockDrv, CLOCKDRV_SOSC_DIV2, &busClockFreq); ClockDrv_GetFreq(&mcu.clockDrv, CLOCKDRV_SOSC_DIV2, &busClockFreq);
} }
if(flexCanCfg.fdEnable == true) if(flexCanCfg.fdEnable == true)

2
cva_asw_m0146/src/canuser.h
View File

@ -41,7 +41,7 @@ typedef struct
* the function prototypes * the function prototypes
******************************************************************************/ ******************************************************************************/
void FlexCanBoot_Init(McuType *obj); void FlexCanBoot_Init(void);
int8_t FlexCanBoot_TxMessage(uint32_t msgId, const uint8_t* pData, uint8_t size); int8_t FlexCanBoot_TxMessage(uint32_t msgId, const uint8_t* pData, uint8_t size);
bool FlexCanBoot_ReadoutMsg(FlexCan_FrameStructureType* pRxMsgObj); bool FlexCanBoot_ReadoutMsg(FlexCan_FrameStructureType* pRxMsgObj);
void MsgTask(UdsType *obj); void MsgTask(UdsType *obj);

7
cva_asw_m0146/src/event.c
View File

@ -3,12 +3,13 @@
#include "mcu.h" #include "mcu.h"
#include "hwctrl.h" #include "hwctrl.h"
extern McuType mcu; //extern McuType mcu;
/*
void ADC0_Handler() void ADC0_Handler()
{ {
for(uint8_t i=0;i<ADCH_NUM;i++){ for(uint8_t i=0;i<ADCH_NUM;i++){
adcResult[i] = AdcDrv_GetRn(&mcu.adc0Drv, i); adcResult[i] = AdcDrv_GetRn(&mcu.adc0Drv, i);
} }
} }
*/

714
cva_asw_m0146/src/hwctrl.c
View File

@ -14,6 +14,9 @@
******************************************************************************/ ******************************************************************************/
#define ADC_DEMO_LAST_CHANNLE ADCH_HEAT_C2 #define ADC_DEMO_LAST_CHANNLE ADCH_HEAT_C2
#define PDB_BB_SEL (0u) //000b : PDB0 and PDB1 operates independently. #define PDB_BB_SEL (0u) //000b : PDB0 and PDB1 operates independently.
#define DMA_CHANNEL0 0
#define DMA_CHANNEL1 1
#define PWM_PERIOD_HZ 1000
/******************************************************************************* /*******************************************************************************
* the typedefs * the typedefs
******************************************************************************/ ******************************************************************************/
@ -23,9 +26,11 @@
/******************************************************************************* /*******************************************************************************
* the globals * the globals
******************************************************************************/ ******************************************************************************/
uint32_t adcResult[ADCH_NUM]; static uint32_t adcResult[ADCH_NUM];
EDmaDrv_StateType dmaController_State;
EDmaDrv_ChnStateType *pEdmaChnState[16]; /* Runtime state structure for the eDMA driver */
EDmaDrv_ChnStateType edmaChnState[16];
static PwmLiteDrv_ModuleConfigType moduleConfig;
/******************************************************************************* /*******************************************************************************
* the const * the const
******************************************************************************/ ******************************************************************************/
@ -33,6 +38,7 @@ uint32_t adcResult[ADCH_NUM];
*/ */
const TrgMuxDrv_InOutMappingType c_trgmuxInOutMappings[] = { const TrgMuxDrv_InOutMappingType c_trgmuxInOutMappings[] = {
{TRGMUXDRV_TRIGSOURCE_SIM_SW_TRIG, TRGMUXDRV_TARGETMODULE_PDB0_TRG_IN, false}, /* Use SIM_SW_TRIG trigger PDB0 */ {TRGMUXDRV_TRIGSOURCE_SIM_SW_TRIG, TRGMUXDRV_TARGETMODULE_PDB0_TRG_IN, false}, /* Use SIM_SW_TRIG trigger PDB0 */
{TRGMUXDRV_TRIGSOURCE_SIM_SW_TRIG, TRGMUXDRV_TARGETMODULE_PDB1_TRG_IN, false}, /* Use SIM_SW_TRIG trigger PDB0 */
}; };
const uint16_t c_numOfTrgmuxInOutMappings = sizeof(c_trgmuxInOutMappings) / sizeof(TrgMuxDrv_InOutMappingType); const uint16_t c_numOfTrgmuxInOutMappings = sizeof(c_trgmuxInOutMappings) / sizeof(TrgMuxDrv_InOutMappingType);
@ -40,33 +46,33 @@ const uint16_t c_numOfTrgmuxInOutMappings = sizeof(c_trgmuxInOutMappings) / size
* the function prototypes * the function prototypes
******************************************************************************/ ******************************************************************************/
static void hw_IO_Init(McuType *obj); static void hw_IO_Init();
static void ADC_Init(McuType *obj); static void ADC_Init();
static void hw_clock_init(McuType *obj) static void hw_clock_init()
{ {
/* Setup the clock */ /* Setup the clock */
ClockDrv_ModuleClkConfigType clockConfig; ClockDrv_ModuleClkConfigType clockConfig;
uint32_t tTcr = 0; uint32_t tTcr = 0;
WdgDrv_Disable(&(obj->wdgDrv)); WdgDrv_Disable(&mcu.wdgDrv);
SEGGER_RTT_printf(0,"-----clock_INIT-----\n"); SEGGER_RTT_printf(0,"-----clock_INIT-----\n");
/* Enable the clock for all ports */ /* Enable the clock for all ports */
clockConfig.gating = true; clockConfig.gating = true;
ClockDrv_ConfigureClock(&obj->clockDrv, CLOCKDRV_PORTA, &clockConfig); ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTA, &clockConfig);
ClockDrv_ConfigureClock(&obj->clockDrv, CLOCKDRV_PORTB, &clockConfig); ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTB, &clockConfig);
ClockDrv_ConfigureClock(&obj->clockDrv, CLOCKDRV_PORTC, &clockConfig); ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTC, &clockConfig);
ClockDrv_ConfigureClock(&obj->clockDrv, CLOCKDRV_PORTD, &clockConfig); ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTD, &clockConfig);
ClockDrv_ConfigureClock(&obj->clockDrv, CLOCKDRV_PORTE, &clockConfig); ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTE, &clockConfig);
/* Setup the Pll div2 clock */ /* Setup the Pll div2 clock */
clockConfig.gating = true; clockConfig.gating = true;
clockConfig.source = CLOCKDRV_PLL; clockConfig.source = CLOCKDRV_PLL;
clockConfig.div = 1; clockConfig.div = 1;
ClockDrv_ConfigureClock(&obj->clockDrv, CLOCKDRV_PLL_DIV2, &clockConfig); ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PLL_DIV2, &clockConfig);
/* Setup the FIRC2 div2 clock */ /* Setup the FIRC2 div2 clock */
@ -74,43 +80,112 @@ static void hw_clock_init(McuType *obj)
clockConfig.gating = true; clockConfig.gating = true;
clockConfig.source = CLOCKDRV_SOSC; clockConfig.source = CLOCKDRV_SOSC;
clockConfig.div = 1; clockConfig.div = 1;
ClockDrv_ConfigureClock(&obj->clockDrv, CLOCKDRV_SOSC_DIV2, &clockConfig); ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_SOSC_DIV2, &clockConfig);
/* Setup the SPI clock */ /* Setup the SPI clock */
clockConfig.gating = true; clockConfig.gating = true;
clockConfig.source = CLOCKDRV_PLL_DIV2; clockConfig.source = CLOCKDRV_PLL_DIV2;
ClockDrv_ConfigureClock(&obj->clockDrv, CLOCKDRV_SPI2, &clockConfig); ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_SPI2, &clockConfig);
tTcr = SpiReg_GetTcr((const SpiRegType *)&obj->spiDrv2.reg); tTcr = SpiReg_GetTcr((const SpiRegType *)&mcu.spiDrv2.reg);
SpiDrv_SetPrescaler(&tTcr,0x03); SpiDrv_SetPrescaler(&tTcr,0x03);
//adc功能 //adc功能
/* Enable the clock for PDB0 */ /* Enable the clock for PDB0 */
ClockDrv_ConfigureClock(&obj->clockDrv, CLOCKDRV_PDB0, &clockConfig); clockConfig.gating = true;
ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PDB0, &clockConfig);
/* TRGMUX */ ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PDB1, &clockConfig);
TrgMuxDrv_ConfigType trgmuxConfig;
trgmuxConfig.numOfInOutMappings = c_numOfTrgmuxInOutMappings;
trgmuxConfig.inOutMapping = c_trgmuxInOutMappings;
TrgMuxDrv_Configure(&obj->trgMuxDrv, &trgmuxConfig);
/* Enable the clock for ADC */ /* Enable the clock for ADC */
clockConfig.gating = true; clockConfig.gating = true;
clockConfig.source = CLOCKDRV_PLL; clockConfig.source = CLOCKDRV_PLL;
clockConfig.div = 4; clockConfig.div = 4;
ClockDrv_ConfigureClock(&obj->clockDrv, CLOCKDRV_ADC0, &clockConfig); ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_ADC0, &clockConfig);
ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_ADC1, &clockConfig);
/* Enable the clock for DMAMUX */
clockConfig.gating = true;
ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_DMA_MUX, &clockConfig);
clockConfig.gating = true;
ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_DMA, &clockConfig);
ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PWMLITE0, &clockConfig);
} }
static void ADC_Init(McuType *obj) static void ADC_Init()
{ {
for (uint8_t i = 0; i < ADCH_NUM; i++) for (uint8_t i = 0; i < ADCH_NUM; i++)
{ {
adcResult[i] = 0; adcResult[i] = 0;
} }
/* TRGMUX */
TrgMuxDrv_ConfigType trgmuxConfig;
trgmuxConfig.numOfInOutMappings = c_numOfTrgmuxInOutMappings;
trgmuxConfig.inOutMapping = c_trgmuxInOutMappings;
TrgMuxDrv_Configure(&mcu.trgMuxDrv, &trgmuxConfig);
pEdmaChnState[0] = &edmaChnState[0];
pEdmaChnState[1] = &edmaChnState[1];
/* Configure EDMA module */
EDmaDrv_ModuleConfigType edmaCfg;
EDmaDrv_GetDefaultConfigure(&edmaCfg);
EDmaDrv_Configure(&mcu.edmaDrv, &dmaController_State, &edmaCfg);
EDmaDrv_ChannelConfigType edmaChannelCfg;
EDmaDrv_GetDefaultChannelConfigure(&edmaChannelCfg);
edmaChannelCfg.chnConfig = DMA_CHANNEL0;
edmaChannelCfg.source = EDMA_REQ_ADC0;
edmaChannelCfg.channelPriority = EDMADRV_CHN_PRIORITY_0;
EDmaDrv_ConfigureChannel(&mcu.edmaDrv, &pEdmaChnState[0], &edmaChannelCfg);
edmaChannelCfg.chnConfig = DMA_CHANNEL1;
edmaChannelCfg.source = EDMA_REQ_ADC1;
edmaChannelCfg.channelPriority = EDMADRV_CHN_PRIORITY_0;
EDmaDrv_ConfigureChannel(&mcu.edmaDrv, &pEdmaChnState[0], &edmaChannelCfg);
EDmaDrv_TransferConfigType edmaTransferCfg;
EDmaDrv_LoopTransferConfigType edmaLoopCfg;
edmaLoopCfg.majorLoopIterationCount = 5;
edmaLoopCfg.srcOffsetEnable = true;
edmaLoopCfg.dstOffsetEnable = true;
edmaLoopCfg.minorLoopOffset = 0;
edmaLoopCfg.minorLoopChnLinkEnable = false;
edmaLoopCfg.minorLoopChnLinkNumber = 0;
edmaLoopCfg.majorLoopChnLinkEnable = false;
edmaLoopCfg.majorLoopChnLinkNumber = 0;
edmaTransferCfg.srcAddr = (uint32_t)&mcu.adc0Drv.adcReg->R[0];
edmaTransferCfg.destAddr = (uint32_t)&adcResult[0];
edmaTransferCfg.srcDestTransferSize = EDMADRV_TRANSFER_SIZE_4B;
edmaTransferCfg.srcOffset = 4;
edmaTransferCfg.destOffset = 4;
edmaTransferCfg.srcLastAddrAdjust = -20;
edmaTransferCfg.destLastAddrAdjust = -20;
edmaTransferCfg.srcModulo = EDMADRV_MODULO_OFF;
edmaTransferCfg.destModulo = EDMADRV_MODULO_OFF;
edmaTransferCfg.minorByteTransferCount = 4;
edmaTransferCfg.scatterGatherEnable = false;
edmaTransferCfg.scatterGatherNextDescAddr = false;
edmaTransferCfg.interruptEnable = false;
edmaTransferCfg.hardClrDone = true;
edmaTransferCfg.loopTransferConfig = &edmaLoopCfg;
EDmaDrv_ConfigLoopTransfer(&mcu.edmaDrv, DMA_CHANNEL0, &edmaTransferCfg);
edmaTransferCfg.srcAddr = (uint32_t)&mcu.adc1Drv.adcReg->R[0];
edmaTransferCfg.destAddr = (uint32_t)&adcResult[ADCH_RLY1];
EDmaDrv_ConfigLoopTransfer(&mcu.edmaDrv, DMA_CHANNEL1, &edmaTransferCfg);
EDmaDrv_StartChannel(&mcu.edmaDrv, DMA_CHANNEL0);
EDmaDrv_StartChannel(&mcu.edmaDrv, DMA_CHANNEL1);
/* Configure ADC module */ /* Configure ADC module */
AdcDrv_ConfigType adcCfg; AdcDrv_ConfigType adcCfg;
@ -120,29 +195,32 @@ static void ADC_Init(McuType *obj)
adcCfg.avgSamplesSel = ADCDRV_AVERAGE_32; /* Select 32 samples average */ adcCfg.avgSamplesSel = ADCDRV_AVERAGE_32; /* Select 32 samples average */
adcCfg.continuousMode = ADCDRV_ONESHOT; /* Select one-shot mode */ adcCfg.continuousMode = ADCDRV_ONESHOT; /* Select one-shot mode */
adcCfg.chnCfg[ADCH_Power].chnSel = ADCDRV_INCHN_EXT3; adcCfg.chnCfg[ADCH_Power].chnSel = ADCDRV_INCHN_EXT3;
adcCfg.chnCfg[ADCH_RLY1].chnSel = ADCDRV_INCHN_VBG;
adcCfg.chnCfg[ADCH_RLY3].chnSel = ADCDRV_INCHN_EXT0; adcCfg.chnCfg[ADCH_RLY3].chnSel = ADCDRV_INCHN_EXT0;
adcCfg.chnCfg[ADCH_RLY5].chnSel = ADCDRV_INCHN_EXT1; adcCfg.chnCfg[ADCH_RLY5].chnSel = ADCDRV_INCHN_EXT1;
adcCfg.chnCfg[ADCH_HEAT_SENSOR1].chnSel = ADCDRV_INCHN_LDO_VOLT; adcCfg.chnCfg[ADCH_HEAT_C1].chnSel = ADCDRV_INCHN_EXT15;
adcCfg.chnCfg[ADCH_HEAT_SENSOR2].chnSel = ADCDRV_INCHN_EXT3; adcCfg.chnCfg[ADCH_HEAT_C2].chnSel = ADCDRV_INCHN_EXT7;
adcCfg.chnCfg[ADCH_HEAT_C1].chnSel = ADCDRV_INCHN_EXT3;
adcCfg.chnCfg[ADCH_HEAT_C2].chnSel = ADCDRV_INCHN_EXT3;
adcCfg.chnCfg[ADC_DEMO_LAST_CHANNLE].intEnable = true; /* Last channel enable interrupt */ //adcCfg.chnCfg[ADCH_HEAT_C2].intEnable = true; /* Last channel enable interrupt */
adcCfg.trgSrcCfg.trgSrc = ADCDRV_HW_TRIGGER; adcCfg.trgSrcCfg.trgSrc = ADCDRV_HW_TRIGGER;
adcCfg.trgSrcCfg.hwTrgSrc = ADCDRV_HW_TRGSRC_PDB; adcCfg.dmaEnable = true;
adcCfg.trgSrcCfg.swPretrgSrc = ADCDRV_SWPRETRG_PRETRIGGER_0;
adcCfg.trgSrcCfg.pretrgSrc = ADCDRV_PRETRG_PDB_PRETRIGGER;
/* Enable ADC interrupts */ /* Enable ADC interrupts */
IrqDrv_EnableIrq(ADC0_IRQn); //IrqDrv_EnableIrq(ADC0_IRQn);
AdcDrv_Configure(&obj->adc0Drv, &adcCfg); AdcDrv_Configure(&mcu.adc0Drv, &adcCfg);
AdcDrv_EnableAdc(&obj->adc0Drv); AdcDrv_EnableAdc(&mcu.adc0Drv);
adcCfg.chnCfg[0].chnSel = ADCDRV_INCHN_EXT5;
adcCfg.chnCfg[1].chnSel = ADCDRV_INCHN_EXT2;
adcCfg.chnCfg[2].chnSel = ADCDRV_INCHN_EXT7;
adcCfg.chnCfg[3].chnSel = ADCDRV_INCHN_VBG;
adcCfg.chnCfg[4].chnSel = ADCDRV_INCHN_LPVBG;
AdcDrv_Configure(&mcu.adc1Drv, &adcCfg);
AdcDrv_EnableAdc(&mcu.adc1Drv);
/* Configure PDB module */ /* Configure PDB module */
uint32_t pdbFreq; uint32_t pdbFreq;
ClockDrv_GetFreq(&obj->clockDrv, CLOCKDRV_PDB0, &pdbFreq); ClockDrv_GetFreq(&mcu.clockDrv, CLOCKDRV_PDB0, &pdbFreq);
PdbDrv_ConfigType pdbCfg; PdbDrv_ConfigType pdbCfg;
PdbDrv_GetDefaultConfig(&pdbCfg); PdbDrv_GetDefaultConfig(&pdbCfg);
@ -156,261 +234,308 @@ static void ADC_Init(McuType *obj)
pdbCfg.preTrgCfg.mode[0][2] = PDBDRV_PRETRG_BB_MODE; pdbCfg.preTrgCfg.mode[0][2] = PDBDRV_PRETRG_BB_MODE;
pdbCfg.preTrgCfg.mode[0][3] = PDBDRV_PRETRG_BB_MODE; pdbCfg.preTrgCfg.mode[0][3] = PDBDRV_PRETRG_BB_MODE;
pdbCfg.preTrgCfg.mode[0][4] = PDBDRV_PRETRG_BB_MODE; pdbCfg.preTrgCfg.mode[0][4] = PDBDRV_PRETRG_BB_MODE;
pdbCfg.preTrgCfg.mode[0][5] = PDBDRV_PRETRG_BB_MODE;
pdbCfg.preTrgCfg.mode[0][6] = PDBDRV_PRETRG_BB_MODE; pdbCfg.dlyCfg.modCnt = 1*pdbFreq / 128 / 40 /1000; /* Periodic triggering PDB in 1s*/
pdbCfg.preTrgCfg.mode[0][7] = PDBDRV_PRETRG_BB_MODE;
pdbCfg.dlyCfg.modCnt = 1*pdbFreq / 128 / 40; /* Periodic triggering PDB in 1s*/
pdbCfg.dlyCfg.dlyCnt[0][0] = 0; /* first channel don't need delay time*/ pdbCfg.dlyCfg.dlyCnt[0][0] = 0; /* first channel don't need delay time*/
pdbCfg.bbSel = PDB_BB_SEL; /* Internal channel chaining of PDB0 CH0 and CH1. pdbCfg.bbSel = PDB_BB_SEL; /* Internal channel chaining of PDB0 CH0 and CH1.
* CH0 and CH1 of PDB0 back-to-back operation with COCO[7:0] and COCO[15:8] of ADC0. * CH0 and CH1 of PDB0 back-to-back operation with COCO[7:0] and COCO[15:8] of ADC0.
*/ */
PdbDrv_Configure(&obj->pdb0Drv, &pdbCfg); PdbDrv_Configure(&mcu.pdb0Drv, &pdbCfg);
PdbDrv_Configure(&mcu.pdb1Drv, &pdbCfg);
PdbDrv_EnablePdb(&obj->pdb0Drv); /* Enable PDB0 */
TrgMuxDrv_GenSWTrigger(&obj->trgMuxDrv, 100); /* Trigger PDB0 */
PdbDrv_EnablePdb(&mcu.pdb0Drv); /* Enable PDB0 */
PdbDrv_EnablePdb(&mcu.pdb1Drv); /* Enable PDB1 */
TrgMuxDrv_GenSWTrigger(&mcu.trgMuxDrv, 10); /* Trigger PDB0 */
} }
void hw_init(McuType *obj) static void PWM_Init(void)
{
uint32_t apbClkFreq = 0;
ClockDrv_GetFreq(&mcu.clockDrv, CLOCKDRV_APB, &apbClkFreq);
/* Configure PWM Module */
PwmLiteDrv_GetDefaultModuleConfig(&moduleConfig);
moduleConfig.period = apbClkFreq / PWM_PERIOD_HZ;
moduleConfig.syncType = PWMLITEDRV_SYNC_AT_PERIOD;
PwmLiteDrv_ModuleConfig(&mcu.pwmLiteDrv0, &moduleConfig);
/* Configure PWM channel 0 */
PwmLiteDrv_ChannelConfigType channelConfig;
PwmLiteDrv_GetDefaultChannelConfig(&channelConfig);
channelConfig.pwmMuxType.channelNumber = PWMLITEDRV_MUX_PWM0_CH0;
channelConfig.pwmMuxType.padNumber = PWMLITEDRV_MUX_PAD_PWM4;
channelConfig.behavior0 = PWMLITEDRV_HIGH_AT_REACH;
channelConfig.behavior1 = PWMLITEDRV_LOW_AT_REACH;
channelConfig.threshold0 = 0;
channelConfig.threshold1 = moduleConfig.period * 25 / 100;
PwmLiteDrv_ConfigChannel(&mcu.pwmLiteDrv0, PWMLITEDRV_PWM_CH0, &channelConfig);
/* Enable PWM Module */
PwmLiteDrv_EnableModule(&mcu.pwmLiteDrv0);
}
void hw_init(void)
{ {
uint32_t gCpuClockFrequency = 0; uint32_t gCpuClockFrequency = 0;
hw_clock_init(obj); hw_clock_init();
SEGGER_RTT_printf(0,"-----SPI_INIT-----\n"); SEGGER_RTT_printf(0,"-----SPI_INIT-----\n");
SBC_SPI_INIT(); SBC_SPI_INIT();
FlexCanBoot_Init(obj); FlexCanBoot_Init();
hw_IO_Init(obj); hw_IO_Init();
/* Set system tick clock, 1ms event */ /* Set system tick clock, 1ms event */
ClockDrv_GetFreq(&obj->clockDrv, CLOCKDRV_CORE, &gCpuClockFrequency); ClockDrv_GetFreq(&mcu.clockDrv, CLOCKDRV_CORE, &gCpuClockFrequency);
SysTick_Config(gCpuClockFrequency / 1000u); SysTick_Config(gCpuClockFrequency / 1000u);
IrqDrv_EnableIrq(SysTick_IRQn); IrqDrv_EnableIrq(SysTick_IRQn);
SBC_Init(); SBC_Init();
SEGGER_RTT_printf(0,"-----ADC_Init-----\n");
ADC_Init();
ADC_Init(obj); PWM_Init();
SEGGER_RTT_printf(0,"-----InitFinished-----\n");
} }
#define PINSDRV_DIR_OUTPUT 1 #define PINSDRV_DIR_OUTPUT 1
#define PINSDRV_DIR_INPUT 0 #define PINSDRV_DIR_INPUT 0
static void hw_IO_Init(McuType *obj) static void hw_IO_Init(void)
{ {
//1 //1
PinsDrv_SetMuxModeSel(&obj->ptd, 1, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptd, 1, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptd.port, 1, 1); PortReg_SetPcrDrvStr(mcu.ptd.port, 1, 1);
PortReg_SetPcrSr(obj->ptd.port, 1, 1); PortReg_SetPcrSr(mcu.ptd.port, 1, 1);
PinsDrv_SetPinDirection(&obj->ptd, 1, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.ptd, 1, PINSDRV_DIR_OUTPUT);
//2 //2
PinsDrv_SetMuxModeSel(&obj->ptd, 0, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptd, 0, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptd.port, 0, 1); PortReg_SetPcrDrvStr(mcu.ptd.port, 0, 1);
PortReg_SetPcrSr(obj->ptd.port, 0, 1); PortReg_SetPcrSr(mcu.ptd.port, 0, 1);
PinsDrv_SetPinDirection(&obj->ptd, 0, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.ptd, 0, PINSDRV_DIR_OUTPUT);
//3 //3
PinsDrv_SetMuxModeSel(&obj->pte, 11, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pte, 11, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pte.port, 11, 1); PortReg_SetPcrDrvStr(mcu.pte.port, 11, 1);
PortReg_SetPcrSr(obj->pte.port, 11, 1); PortReg_SetPcrSr(mcu.pte.port, 11, 1);
PinsDrv_SetPinDirection(&obj->pte, 11, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pte, 11, PINSDRV_DIR_OUTPUT);
//4 //4
PinsDrv_SetMuxModeSel(&obj->pte, 10, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pte, 10, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pte.port, 10, 1); PortReg_SetPcrDrvStr(mcu.pte.port, 10, 1);
PortReg_SetPcrSr(obj->pte.port, 10, 1); PortReg_SetPcrSr(mcu.pte.port, 10, 1);
PinsDrv_SetPinDirection(&obj->pte, 10, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pte, 10, PINSDRV_DIR_OUTPUT);
//5 //5
PinsDrv_SetMuxModeSel(&obj->pte, 5, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pte, 5, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pte.port, 5, 1); PortReg_SetPcrDrvStr(mcu.pte.port, 5, 1);
PortReg_SetPcrSr(obj->pte.port, 5, 1); PortReg_SetPcrSr(mcu.pte.port, 5, 1);
PinsDrv_SetPinDirection(&obj->pte, 5, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pte, 5, PINSDRV_DIR_OUTPUT);
//6 //6
PinsDrv_SetMuxModeSel(&obj->pte, 4, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pte, 4, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pte.port, 4, 1); PortReg_SetPcrDrvStr(mcu.pte.port, 4, 1);
PortReg_SetPcrSr(obj->pte.port, 4, 1); PortReg_SetPcrSr(mcu.pte.port, 4, 1);
PinsDrv_SetPinDirection(&obj->pte, 4, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pte, 4, PINSDRV_DIR_OUTPUT);
//7-12电源 //7-12电源
//13 //13
PinsDrv_SetMuxModeSel(&obj->pte, 3, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pte, 3, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pte.port, 3, 1); PortReg_SetPcrDrvStr(mcu.pte.port, 3, 1);
PortReg_SetPcrSr(obj->pte.port, 3, 1); PortReg_SetPcrSr(mcu.pte.port, 3, 1);
PinsDrv_SetPinDirection(&obj->pte, 3, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pte, 3, PINSDRV_DIR_OUTPUT);
//14 //14
PinsDrv_SetMuxModeSel(&obj->ptd, 16, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptd, 16, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptd.port, 16, 1); PortReg_SetPcrDrvStr(mcu.ptd.port, 16, 1);
PortReg_SetPcrSr(obj->ptd.port, 16, 1); PortReg_SetPcrSr(mcu.ptd.port, 16, 1);
PinsDrv_SetPinDirection(&obj->ptd, 16, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.ptd, 16, PINSDRV_DIR_OUTPUT);
//15 //15
PinsDrv_SetMuxModeSel(&obj->ptd, 15, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptd, 15, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptd.port, 15, 1); PortReg_SetPcrDrvStr(mcu.ptd.port, 15, 1);
PortReg_SetPcrSr(obj->ptd.port, 15, 1); PortReg_SetPcrSr(mcu.ptd.port, 15, 1);
PinsDrv_SetPinDirection(&obj->ptd, 15, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.ptd, 15, PINSDRV_DIR_OUTPUT);
//16 //16
PinsDrv_SetMuxModeSel(&obj->pte, 9, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pte, 9, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pte.port, 9, 1); PortReg_SetPcrDrvStr(mcu.pte.port, 9, 1);
PortReg_SetPcrSr(obj->pte.port, 9, 1); PortReg_SetPcrSr(mcu.pte.port, 9, 1);
PinsDrv_SetPinDirection(&obj->pte, 9, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pte, 9, PINSDRV_DIR_OUTPUT);
//17 //17
PinsDrv_SetMuxModeSel(&obj->pte, 8, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pte, 8, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pte.port, 8, 1); PortReg_SetPcrDrvStr(mcu.pte.port, 8, 1);
PortReg_SetPcrSr(obj->pte.port, 8, 1); PortReg_SetPcrSr(mcu.pte.port, 8, 1);
PinsDrv_SetPinDirection(&obj->pte, 8, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pte, 8, PINSDRV_DIR_OUTPUT);
//18 //18
PinsDrv_SetMuxModeSel(&obj->ptb, 5, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptb, 5, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptb.port, 5, 1); PortReg_SetPcrDrvStr(mcu.ptb.port, 5, 1);
PortReg_SetPcrSr(obj->ptb.port, 5, 1); PortReg_SetPcrSr(mcu.ptb.port, 5, 1);
PinsDrv_SetPinDirection(&obj->ptb, 5, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.ptb, 5, PINSDRV_DIR_OUTPUT);
//19 //19
PinsDrv_SetMuxModeSel(&obj->ptb, 4, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptb, 4, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptb.port, 4, 1); PortReg_SetPcrDrvStr(mcu.ptb.port, 4, 1);
PortReg_SetPcrSr(obj->ptb.port, 4, 1); PortReg_SetPcrSr(mcu.ptb.port, 4, 1);
PinsDrv_SetPinDirection(&obj->ptb, 4, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.ptb, 4, PINSDRV_DIR_OUTPUT);
//20-22预留 //20-22预留
//23 //23
PinsDrv_SetMuxModeSel(&obj->ptd, 6, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptd, 6, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptd.port, 6, 1); PortReg_SetPcrDrvStr(mcu.ptd.port, 6, 1);
PortReg_SetPcrSr(obj->ptd.port, 6, 1); PortReg_SetPcrSr(mcu.ptd.port, 6, 1);
PinsDrv_SetPinDirection(&obj->ptd, 6, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.ptd, 6, PINSDRV_DIR_OUTPUT);
//24 //24
PinsDrv_SetMuxModeSel(&obj->ptd, 5, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptd, 5, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptd.port, 5, 1); PortReg_SetPcrDrvStr(mcu.ptd.port, 5, 1);
PortReg_SetPcrSr(obj->ptd.port, 5, 1); PortReg_SetPcrSr(mcu.ptd.port, 5, 1);
PinsDrv_SetPinDirection(&obj->ptd, 5, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.ptd, 5, PINSDRV_DIR_OUTPUT);
//25-26 SPI //25-26 SPI
//27 //27
PinsDrv_SetMuxModeSel(&obj->ptc, 17, PINSDRV_PIN_DISABLED); PinsDrv_SetMuxModeSel(&mcu.ptc, 17, PINSDRV_PIN_DISABLED);
PortReg_SetPcrDrvStr(obj->ptc.port, 17, 1); PortReg_SetPcrAen(mcu.ptc.port, 1, 1);
PortReg_SetPcrSr(obj->ptc.port, 17, 1); PortReg_SetPcrSr(mcu.ptc.port, 1, 1);
PinsDrv_SetPinDirection(&mcu.ptc, 1,0);
PinsDrv_SetPortInputDisable(&mcu.ptc,0);
//28 //28
PinsDrv_SetMuxModeSel(&obj->ptc, 16, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptc, 16, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptc.port, 16, 1); PortReg_SetPcrDrvStr(mcu.ptc.port, 16, 1);
PortReg_SetPcrSr(obj->ptc.port, 16, 1); PortReg_SetPcrSr(mcu.ptc.port, 16, 1);
PinsDrv_SetPinDirection(&obj->ptc, 16,PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.ptc, 16,PINSDRV_DIR_OUTPUT);
//29 30 SPI //29 30 SPI
//31 //31
PinsDrv_SetMuxModeSel(&obj->ptb, 3, PINSDRV_PIN_DISABLED); PinsDrv_SetMuxModeSel(&mcu.ptb, 3, PINSDRV_PIN_DISABLED);
PortReg_SetPcrDrvStr(obj->ptb.port, 3, 1); PortReg_SetPcrAen(mcu.ptb.port, 3, 1);
PortReg_SetPcrSr(obj->ptb.port, 3, 1); PortReg_SetPcrSr(mcu.ptb.port, 3, 1);
PinsDrv_SetPinDirection(&mcu.ptb, 3,0);
PinsDrv_SetPortInputDisable(&mcu.ptb,0);
//32 //32
PinsDrv_SetMuxModeSel(&obj->ptb, 2, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptb, 2, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptb.port, 2, 1); PortReg_SetPcrDrvStr(mcu.ptb.port, 2, 1);
PortReg_SetPcrSr(obj->ptb.port, 2, 1); PortReg_SetPcrSr(mcu.ptb.port, 2, 1);
//33 34 CAN //33 34 CAN
//35 //35
PinsDrv_SetMuxModeSel(&obj->ptc, 9, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptc, 9, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptc.port, 9, 1); PortReg_SetPcrDrvStr(mcu.ptc.port, 9, 1);
PortReg_SetPcrSr(obj->ptc.port, 9, 1); PortReg_SetPcrSr(mcu.ptc.port, 9, 1);
PinsDrv_SetPinDirection(&obj->ptc, 9,PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.ptc, 9,PINSDRV_DIR_OUTPUT);
//36 //36
PinsDrv_SetMuxModeSel(&obj->ptc, 8, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptc, 8, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptc.port, 8, 1); PortReg_SetPcrDrvStr(mcu.ptc.port, 8, 1);
PortReg_SetPcrSr(obj->ptc.port, 8, 1); PortReg_SetPcrSr(mcu.ptc.port, 8, 1);
//37 //37
PinsDrv_SetMuxModeSel(&obj->pta, 7, PINSDRV_PIN_DISABLED); PinsDrv_SetMuxModeSel(&mcu.pta, 7, PINSDRV_PIN_DISABLED);
PortReg_SetPcrAen(obj->pta.port, 7, 1); PortReg_SetPcrAen(mcu.pta.port, 7, 1);
PortReg_SetPcrSr(obj->pta.port, 7, 1); PortReg_SetPcrSr(mcu.pta.port, 7, 1);
PinsDrv_SetPinDirection(&obj->pta, 7,0); PinsDrv_SetPinDirection(&mcu.pta, 7,0);
PinsDrv_SetPortInputDisable(&obj->pta,0); PinsDrv_SetPortInputDisable(&mcu.pta,0);
//38 //38
PinsDrv_SetMuxModeSel(&obj->pta, 6, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pta, 6, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pta.port, 6, 1); PortReg_SetPcrDrvStr(mcu.pta.port, 6, 1);
PortReg_SetPcrSr(obj->pta.port, 6, 1); PortReg_SetPcrSr(mcu.pta.port, 6, 1);
//39 //39
PinsDrv_SetMuxModeSel(&obj->pte, 7, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pte, 7, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pte.port, 7, 1); PinsDrv_SetPinDirection(&mcu.pte, 7,0);
PortReg_SetPcrSr(obj->pte.port, 7, 1); PortReg_SetPcrSr(mcu.pte.port, 7, 1);
//40 41 VDD //40 41 VDD
//42 NC //42 NC
//43 //43
PinsDrv_SetMuxModeSel(&obj->ptb, 12, PINSDRV_PIN_DISABLED); PinsDrv_SetMuxModeSel(&mcu.ptb, 12, PINSDRV_PIN_DISABLED);
PortReg_SetPcrDrvStr(obj->ptb.port, 12, 1); PortReg_SetPcrAen(mcu.ptb.port, 12, 1);
PortReg_SetPcrSr(obj->ptb.port, 12, 1); PortReg_SetPcrSr(mcu.ptb.port, 12, 1);
PinsDrv_SetPinDirection(&mcu.ptb, 12,0);
PinsDrv_SetPortInputDisable(&mcu.ptb,0);
//44 //44
PinsDrv_SetMuxModeSel(&obj->ptd, 4, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptd, 4, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptd.port, 4, 1); PortReg_SetPcrDrvStr(mcu.ptd.port, 4, 1);
PortReg_SetPcrSr(obj->ptd.port, 4, 1); PortReg_SetPcrSr(mcu.ptd.port, 4, 1);
//45 //45
PinsDrv_SetMuxModeSel(&obj->ptd, 3, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptd, 3, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptd.port, 3, 1); PortReg_SetPcrDrvStr(mcu.ptd.port, 3, 1);
PortReg_SetPcrSr(obj->ptd.port, 3, 1); PortReg_SetPcrSr(mcu.ptd.port, 3, 1);
//46 //46
PinsDrv_SetMuxModeSel(&obj->ptd, 2, PINSDRV_PIN_DISABLED); PinsDrv_SetMuxModeSel(&mcu.ptd, 2, PINSDRV_PIN_DISABLED);
PortReg_SetPcrDrvStr(obj->ptd.port, 2, 1); PortReg_SetPcrAen(mcu.ptd.port, 2, 1);
PortReg_SetPcrSr(obj->ptd.port, 2, 1); PortReg_SetPcrSr(mcu.ptd.port, 2, 1);
PinsDrv_SetPinDirection(&mcu.ptd, 2,0);
PinsDrv_SetPortInputDisable(&mcu.ptd,0);
//47 //47
PinsDrv_SetMuxModeSel(&obj->pta, 3, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pta, 3, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pta.port, 3, 1); PortReg_SetPcrDrvStr(mcu.pta.port, 3, 1);
PortReg_SetPcrSr(obj->pta.port, 3, 1); PortReg_SetPcrSr(mcu.pta.port, 3, 1);
PinsDrv_SetPinDirection(&obj->pta, 3, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pta, 3, PINSDRV_DIR_OUTPUT);
//48 //48
PinsDrv_SetMuxModeSel(&obj->pta, 2, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pta, 2, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pta.port, 2, 1); PortReg_SetPcrDrvStr(mcu.pta.port, 2, 1);
PortReg_SetPcrSr(obj->pta.port, 2, 1); PortReg_SetPcrSr(mcu.pta.port, 2, 1);
PinsDrv_SetPinDirection(&obj->pta, 2, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pta, 2, PINSDRV_DIR_OUTPUT);
//49 //49
PinsDrv_SetMuxModeSel(&obj->pta, 1, PINSDRV_PIN_DISABLED); PinsDrv_SetMuxModeSel(&mcu.pta, 1, PINSDRV_PIN_DISABLED);
PortReg_SetPcrDrvStr(obj->pta.port, 1, 1); PortReg_SetPcrAen(mcu.pta.port, 1, 1);
PortReg_SetPcrSr(obj->pta.port, 1, 1); PortReg_SetPcrSr(mcu.pta.port, 1, 1);
PinsDrv_SetPinDirection(&mcu.pta, 1,0);
PinsDrv_SetPortInputDisable(&mcu.pta,0);
//50 //50
PinsDrv_SetMuxModeSel(&obj->pta, 0, PINSDRV_PIN_DISABLED); PinsDrv_SetMuxModeSel(&mcu.pta, 0, PINSDRV_PIN_DISABLED);
PortReg_SetPcrDrvStr(obj->pta.port, 0, 1); PortReg_SetPcrAen(mcu.pta.port, 0, 1);
PortReg_SetPcrSr(obj->pta.port, 0, 1); PortReg_SetPcrSr(mcu.pta.port, 0, 1);
PinsDrv_SetPinDirection(&mcu.pta, 0,0);
PinsDrv_SetPortInputDisable(&mcu.pta,0);
//51 //51
PinsDrv_SetMuxModeSel(&obj->ptc, 7, PINSDRV_PIN_DISABLED); PinsDrv_SetMuxModeSel(&mcu.ptc, 7, PINSDRV_PIN_DISABLED);
PortReg_SetPcrDrvStr(obj->ptc.port, 7, 1); PortReg_SetPcrAen(mcu.ptc.port, 7, 1);
PortReg_SetPcrSr(obj->ptc.port, 7, 1); PortReg_SetPcrSr(mcu.ptc.port, 7, 1);
PinsDrv_SetPinDirection(&mcu.ptc, 7,0);
PinsDrv_SetPortInputDisable(&mcu.ptc,0);
//52 //52
PinsDrv_SetMuxModeSel(&obj->ptc, 6, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.ptc, 6, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->ptc.port, 6, 1); PortReg_SetPcrDrvStr(mcu.ptc.port, 6, 1);
PortReg_SetPcrSr(obj->ptc.port, 6, 1); PortReg_SetPcrSr(mcu.ptc.port, 6, 1);
PinsDrv_SetPinDirection(&obj->ptc, 6, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.ptc, 6, PINSDRV_DIR_OUTPUT);
//53 //53
PinsDrv_SetMuxModeSel(&obj->pte, 6, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pte, 6, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pte.port, 6, 1); PortReg_SetPcrDrvStr(mcu.pte.port, 6, 1);
PortReg_SetPcrSr(obj->pte.port, 6, 1); PortReg_SetPcrSr(mcu.pte.port, 6, 1);
PinsDrv_SetPinDirection(&obj->pte, 6, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pte, 6, PINSDRV_DIR_OUTPUT);
//54 //54
PinsDrv_SetMuxModeSel(&obj->pte, 2, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pte, 2, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pte.port, 2, 1); PortReg_SetPcrDrvStr(mcu.pte.port, 2, 1);
PortReg_SetPcrSr(obj->pte.port, 2, 1); PortReg_SetPcrSr(mcu.pte.port, 2, 1);
PinsDrv_SetPinDirection(&obj->pte, 2, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pte, 2, PINSDRV_DIR_OUTPUT);
//55 //55
PinsDrv_SetMuxModeSel(&obj->pta, 13, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pta, 13, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pta.port, 13, 1); PortReg_SetPcrDrvStr(mcu.pta.port, 13, 1);
PortReg_SetPcrSr(obj->pta.port, 13, 1); PortReg_SetPcrSr(mcu.pta.port, 13, 1);
PinsDrv_SetPinDirection(&obj->pta, 12, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pta, 12, PINSDRV_DIR_OUTPUT);
//56 //56
PinsDrv_SetMuxModeSel(&obj->pta, 12, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pta, 12, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pta.port, 12, 1); PortReg_SetPcrDrvStr(mcu.pta.port, 12, 1);
PortReg_SetPcrSr(obj->pta.port, 12, 1); PortReg_SetPcrSr(mcu.pta.port, 12, 1);
PinsDrv_SetPinDirection(&obj->pta, 11, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pta, 12, PINSDRV_DIR_OUTPUT);
//57 //57
PinsDrv_SetMuxModeSel(&obj->pta, 11, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pta, 11, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pta.port, 11, 1); PortReg_SetPcrDrvStr(mcu.pta.port, 11, 1);
PortReg_SetPcrSr(obj->pta.port, 11, 1); PortReg_SetPcrSr(mcu.pta.port, 11, 1);
//58 //58
PinsDrv_SetMuxModeSel(&obj->pta, 10, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pta, 10, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pta.port, 10, 1); PortReg_SetPcrDrvStr(mcu.pta.port, 10, 1);
PortReg_SetPcrSr(obj->pta.port, 10, 1); PortReg_SetPcrSr(mcu.pta.port, 10, 1);
PinsDrv_SetPinDirection(&obj->pta, 10, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pta, 10, PINSDRV_DIR_OUTPUT);
//59 //59
PinsDrv_SetMuxModeSel(&obj->pte, 1, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pte, 1, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pte.port, 1, 1); PortReg_SetPcrDrvStr(mcu.pte.port, 1, 1);
PortReg_SetPcrSr(obj->pte.port, 1, 1); PortReg_SetPcrSr(mcu.pte.port, 1, 1);
PinsDrv_SetPinDirection(&obj->pte, 1, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pte, 1, PINSDRV_DIR_OUTPUT);
//60 //60
PinsDrv_SetMuxModeSel(&obj->pte, 0, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pte, 0, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pte.port, 0, 1); PortReg_SetPcrDrvStr(mcu.pte.port, 0, 1);
PortReg_SetPcrSr(obj->pte.port, 0, 1); PortReg_SetPcrSr(mcu.pte.port, 0, 1);
PinsDrv_SetPinDirection(&obj->pte, 0, PINSDRV_DIR_OUTPUT); PinsDrv_SetPinDirection(&mcu.pte, 0, PINSDRV_DIR_OUTPUT);
//61 //61
PinsDrv_SetMuxModeSel(&obj->pte, 5, PINSDRV_MUX_AS_GPIO); PinsDrv_SetMuxModeSel(&mcu.pte, 5, PINSDRV_MUX_AS_GPIO);
PortReg_SetPcrDrvStr(obj->pte.port, 5, 1); PortReg_SetPcrDrvStr(mcu.pte.port, 5, 1);
PortReg_SetPcrSr(obj->pte.port, 5, 1); PortReg_SetPcrSr(mcu.pte.port, 5, 1);
//62-64 SWD //62-64 SWD
} }
/*************************************motor driver *****************************************/ /*************************************motor driver *****************************************/
void hw_MotorCtrl(McuType *obj,Motor_ID_Type motorid,Motor_ACT_Type dir) void hw_MotorCtrl(Motor_ID_Type motorid,Motor_ACT_Type dir)
{ {
switch(motorid) switch(motorid)
{ {
@ -418,16 +543,16 @@ void hw_MotorCtrl(McuType *obj,Motor_ID_Type motorid,Motor_ACT_Type dir)
switch(dir) switch(dir)
{ {
case Motor_ACT_NOACT: case Motor_ACT_NOACT:
PinsDrv_ClearPin(&obj->ptd, 0); PinsDrv_ClearPin(&mcu.ptd, 0);
PinsDrv_ClearPin(&obj->ptd, 1); PinsDrv_ClearPin(&mcu.ptd, 1);
break; break;
case Motor_ACT_CW: case Motor_ACT_CW:
PinsDrv_SetPin(&obj->ptd, 0); PinsDrv_SetPin(&mcu.ptd, 0);
PinsDrv_ClearPin(&obj->ptd, 1); PinsDrv_ClearPin(&mcu.ptd, 1);
break; break;
case Motor_ACT_CCW: case Motor_ACT_CCW:
PinsDrv_SetPin(&obj->ptd, 1); PinsDrv_SetPin(&mcu.ptd, 1);
PinsDrv_ClearPin(&obj->ptd, 0); PinsDrv_ClearPin(&mcu.ptd, 0);
break; break;
} }
break; break;
@ -435,16 +560,16 @@ void hw_MotorCtrl(McuType *obj,Motor_ID_Type motorid,Motor_ACT_Type dir)
switch(dir) switch(dir)
{ {
case Motor_ACT_NOACT: case Motor_ACT_NOACT:
PinsDrv_ClearPin(&obj->pte, 10); PinsDrv_ClearPin(&mcu.pte, 10);
PinsDrv_ClearPin(&obj->pte, 11); PinsDrv_ClearPin(&mcu.pte, 11);
break; break;
case Motor_ACT_CW: case Motor_ACT_CW:
PinsDrv_SetPin(&obj->pte, 10); PinsDrv_SetPin(&mcu.pte, 10);
PinsDrv_ClearPin(&obj->pte, 11); PinsDrv_ClearPin(&mcu.pte, 11);
break; break;
case Motor_ACT_CCW: case Motor_ACT_CCW:
PinsDrv_SetPin(&obj->pte, 11); PinsDrv_SetPin(&mcu.pte, 11);
PinsDrv_ClearPin(&obj->pte, 10); PinsDrv_ClearPin(&mcu.pte, 10);
break; break;
} }
break; break;
@ -452,16 +577,16 @@ void hw_MotorCtrl(McuType *obj,Motor_ID_Type motorid,Motor_ACT_Type dir)
switch(dir) switch(dir)
{ {
case Motor_ACT_NOACT: case Motor_ACT_NOACT:
PinsDrv_ClearPin(&obj->pte, 4); PinsDrv_ClearPin(&mcu.pte, 4);
PinsDrv_ClearPin(&obj->pte, 5); PinsDrv_ClearPin(&mcu.pte, 5);
break; break;
case Motor_ACT_CW: case Motor_ACT_CW:
PinsDrv_SetPin(&obj->pte, 4); PinsDrv_SetPin(&mcu.pte, 4);
PinsDrv_ClearPin(&obj->pte, 5); PinsDrv_ClearPin(&mcu.pte, 5);
break; break;
case Motor_ACT_CCW: case Motor_ACT_CCW:
PinsDrv_SetPin(&obj->pte, 5); PinsDrv_SetPin(&mcu.pte, 5);
PinsDrv_ClearPin(&obj->pte, 4); PinsDrv_ClearPin(&mcu.pte, 4);
break; break;
} }
break; break;
@ -469,16 +594,16 @@ void hw_MotorCtrl(McuType *obj,Motor_ID_Type motorid,Motor_ACT_Type dir)
switch(dir) switch(dir)
{ {
case Motor_ACT_NOACT: case Motor_ACT_NOACT:
PinsDrv_ClearPin(&obj->pte, 3); PinsDrv_ClearPin(&mcu.pte, 3);
PinsDrv_ClearPin(&obj->ptd, 16); PinsDrv_ClearPin(&mcu.ptd, 16);
break; break;
case Motor_ACT_CW: case Motor_ACT_CW:
PinsDrv_SetPin(&obj->pte, 3); PinsDrv_SetPin(&mcu.pte, 3);
PinsDrv_ClearPin(&obj->ptd, 16); PinsDrv_ClearPin(&mcu.ptd, 16);
break; break;
case Motor_ACT_CCW: case Motor_ACT_CCW:
PinsDrv_SetPin(&obj->ptd, 16); PinsDrv_SetPin(&mcu.ptd, 16);
PinsDrv_ClearPin(&obj->pte, 3); PinsDrv_ClearPin(&mcu.pte, 3);
break; break;
} }
break; break;
@ -486,16 +611,16 @@ void hw_MotorCtrl(McuType *obj,Motor_ID_Type motorid,Motor_ACT_Type dir)
switch(dir) switch(dir)
{ {
case Motor_ACT_NOACT: case Motor_ACT_NOACT:
PinsDrv_ClearPin(&obj->pte, 9); PinsDrv_ClearPin(&mcu.pte, 9);
PinsDrv_ClearPin(&obj->ptd, 15); PinsDrv_ClearPin(&mcu.ptd, 15);
break; break;
case Motor_ACT_CW: case Motor_ACT_CW:
PinsDrv_SetPin(&obj->pte, 9); PinsDrv_SetPin(&mcu.pte, 9);
PinsDrv_ClearPin(&obj->ptd, 15); PinsDrv_ClearPin(&mcu.ptd, 15);
break; break;
case Motor_ACT_CCW: case Motor_ACT_CCW:
PinsDrv_SetPin(&obj->ptd, 15); PinsDrv_SetPin(&mcu.ptd, 15);
PinsDrv_ClearPin(&obj->pte, 9); PinsDrv_ClearPin(&mcu.pte, 9);
break; break;
} }
break; break;
@ -503,16 +628,16 @@ void hw_MotorCtrl(McuType *obj,Motor_ID_Type motorid,Motor_ACT_Type dir)
switch(dir) switch(dir)
{ {
case Motor_ACT_NOACT: case Motor_ACT_NOACT:
PinsDrv_ClearPin(&obj->pte, 8); PinsDrv_ClearPin(&mcu.pte, 8);
PinsDrv_ClearPin(&obj->ptb, 5); PinsDrv_ClearPin(&mcu.ptb, 5);
break; break;
case Motor_ACT_CW: case Motor_ACT_CW:
PinsDrv_SetPin(&obj->pte, 8); PinsDrv_SetPin(&mcu.pte, 8);
PinsDrv_ClearPin(&obj->ptb, 5); PinsDrv_ClearPin(&mcu.ptb, 5);
break; break;
case Motor_ACT_CCW: case Motor_ACT_CCW:
PinsDrv_SetPin(&obj->pte, 8); PinsDrv_SetPin(&mcu.pte, 8);
PinsDrv_ClearPin(&obj->ptb, 5); PinsDrv_ClearPin(&mcu.ptb, 5);
break; break;
} }
break; break;
@ -520,10 +645,103 @@ void hw_MotorCtrl(McuType *obj,Motor_ID_Type motorid,Motor_ACT_Type dir)
} }
void power_ctrl(uint8_t power)
{
if (power>0)
{
PinsDrv_SetPin(&mcu.ptc,9);
}
else
{
PinsDrv_ClearPin(&mcu.ptc,9);
}
}
uint32_t GetAdcRawData(ADCH_ID_type adch)
{
if (adch < ADCH_NUM)
{
return adcResult[adch];
}
return 0;
}
uint32_t GetAdcmv(ADCH_ID_type adch)
{
uint32_t adcval=0;
if (adch < ADCH_NUM)
{
adcval = adcResult[adch];
}
adcval = ( adcval * 3300 )>>12;
return adcval;
}
uint8_t GetHallIO(Motor_ID_Type motorid)
{
uint8_t ret = 0;
switch (motorid)
{
case MotorHG:
ret = PinsDrv_ReadPin(&mcu.pta,11);
break;
case MotorKB:
ret = PinsDrv_ReadPin(&mcu.ptd,4);
break;
case MotorTT:
ret = PinsDrv_ReadPin(&mcu.ptc,5);
break;
case MotorZY:
ret = PinsDrv_ReadPin(&mcu.pte,7);
break;
default:
break;
}
return ret;
}
void HeatDrv1Ctrl(uint8_t onoff)
{
if (onoff > 0)
{
PinsDrv_SetPin(&mcu.ptc, 16);
PinsDrv_SetPin(&mcu.ptb, 4);
}
else
{
PinsDrv_ClearPin(&mcu.ptc, 16);
PinsDrv_ClearPin(&mcu.ptb, 4);
}
}
void HeatDrv2Ctrl(uint8_t onoff)
{
if (onoff > 0)
{
PinsDrv_SetPin(&mcu.ptd, 5);
PinsDrv_SetPin(&mcu.ptd, 6);
}
else
{
PinsDrv_ClearPin(&mcu.ptd, 5);
PinsDrv_ClearPin(&mcu.ptd, 6);
}
}
void FanCtrlDuty(uint8_t duty)
{
uint32_t dutydata = 0;
if (duty > 100)
{
duty = 100;
}
dutydata = moduleConfig.period * duty / 100;
PwmLiteDrv_UpdatePwmThresholdAtRunning(&mcu.pwmLiteDrv0,PWMLITEDRV_PWM_CH0,0U,dutydata);
}

38
cva_asw_m0146/src/hwctrl.h
View File

@ -7,31 +7,39 @@
/******************************************************************************* /*******************************************************************************
* the defines * the defines
******************************************************************************/ ******************************************************************************/
extern McuType mcu;
extern uint32_t adcResult[]; //extern uint32_t adcResult[];
/******************************************************************************* /*******************************************************************************
* the typedefs * the typedefs
******************************************************************************/ ******************************************************************************/
typedef enum typedef enum
{ {
ADCH_Power=0, ADCH_Power=0,//ADC0CH3
ADCH_RLY1, ADCH_RLY3,//ADC0CH0
ADCH_RLY3, ADCH_RLY5,//ADC0CH1
ADCH_RLY5, ADCH_HEAT_C1,//ADC0CH15
ADCH_HEAT_SENSOR1, ADCH_HEAT_C2,//ADC0CH7
ADCH_HEAT_SENSOR2,
ADCH_HEAT_C1, ADCH_RLY1,//ADC1CH5
ADCH_HEAT_C2, ADCH_HEAT_SENSOR1,//ADC1CH2
ADCH_HEAT_SENSOR2,//ADC1CH7
ADCH_VBG,
ADCH_LPVBG,
ADCH_NUM, ADCH_NUM,
}ADCH_ID_type; }ADCH_ID_type;
/******************************************************************************* /*******************************************************************************
* the function prototypes * the function
******************************************************************************/ ******************************************************************************/
void hw_init(McuType *obj); void hw_init(void);
void hw_MotorCtrl(McuType *obj,Motor_ID_Type motorid,Motor_ACT_Type dir); void hw_MotorCtrl(Motor_ID_Type motorid,Motor_ACT_Type dir);
uint32_t GetAdcRawData(ADCH_ID_type adch);
uint32_t GetAdcmv(ADCH_ID_type adch);
void power_ctrl(uint8_t power);
uint8_t GetHallIO(Motor_ID_Type motorid);
void HeatDrv1Ctrl(uint8_t onoff);
void HeatDrv2Ctrl(uint8_t onoff);
void FanCtrlDuty(uint8_t duty);
#endif #endif

28
cva_asw_m0146/src/key.c
View File

@ -111,6 +111,10 @@ static uint8_t GetSigState(KEY_ID_type key_id)
return scm_canmatrix_rx.Panel_Key.KEY_ZY_U; return scm_canmatrix_rx.Panel_Key.KEY_ZY_U;
case KEY_ZY_D: case KEY_ZY_D:
return scm_canmatrix_rx.Panel_Key.KEY_ZY_D; return scm_canmatrix_rx.Panel_Key.KEY_ZY_D;
case KEY_FAN:
return scm_canmatrix_rx.Panel_Key.KEY_ZY_FAN;
case KEY_HEAT:
return scm_canmatrix_rx.Panel_Key.KEY_ZY_HEAT;
default: default:
return 0; return 0;
} }
@ -139,55 +143,55 @@ void KeyProTask(void)
//KB //KB
if (getKeyPressFlag(KEY_KB_F) == KEY_PRESSED) if (getKeyPressFlag(KEY_KB_F) == KEY_PRESSED)
{ {
setMotorState(MotorHG,Motor_ACT_CW); setMotorState(MotorKB,Motor_ACT_CW);
} }
if (getKeyReleaseFlag(KEY_KB_F) == KEY_PRESSED) if (getKeyReleaseFlag(KEY_KB_F) == KEY_PRESSED)
{ {
setMotorState(MotorHG,Motor_ACT_NOACT); setMotorState(MotorKB,Motor_ACT_NOACT);
} }
if (getKeyPressFlag(KEY_KB_R) == KEY_PRESSED) if (getKeyPressFlag(KEY_KB_R) == KEY_PRESSED)
{ {
setMotorState(MotorHG,Motor_ACT_CCW); setMotorState(MotorKB,Motor_ACT_CCW);
} }
if (getKeyReleaseFlag(KEY_KB_R) == KEY_PRESSED) if (getKeyReleaseFlag(KEY_KB_R) == KEY_PRESSED)
{ {
setMotorState(MotorHG,Motor_ACT_NOACT); setMotorState(MotorKB,Motor_ACT_NOACT);
} }
//TT //TT
if (getKeyPressFlag(KEY_TT_F) == KEY_PRESSED) if (getKeyPressFlag(KEY_TT_F) == KEY_PRESSED)
{ {
setMotorState(MotorHG,Motor_ACT_CW); setMotorState(MotorTT,Motor_ACT_CW);
} }
if (getKeyReleaseFlag(KEY_TT_F) == KEY_PRESSED) if (getKeyReleaseFlag(KEY_TT_F) == KEY_PRESSED)
{ {
setMotorState(MotorHG,Motor_ACT_NOACT); setMotorState(MotorTT,Motor_ACT_NOACT);
} }
if (getKeyPressFlag(KEY_TT_R) == KEY_PRESSED) if (getKeyPressFlag(KEY_TT_R) == KEY_PRESSED)
{ {
setMotorState(MotorHG,Motor_ACT_CCW); setMotorState(MotorTT,Motor_ACT_CCW);
} }
if (getKeyReleaseFlag(KEY_TT_R) == KEY_PRESSED) if (getKeyReleaseFlag(KEY_TT_R) == KEY_PRESSED)
{ {
setMotorState(MotorHG,Motor_ACT_NOACT); setMotorState(MotorTT,Motor_ACT_NOACT);
} }
//ZY //ZY
if (getKeyPressFlag(KEY_ZY_U) == KEY_PRESSED) if (getKeyPressFlag(KEY_ZY_U) == KEY_PRESSED)
{ {
setMotorState(MotorHG,Motor_ACT_CW); setMotorState(MotorZY,Motor_ACT_CW);
} }
if (getKeyReleaseFlag(KEY_ZY_U) == KEY_PRESSED) if (getKeyReleaseFlag(KEY_ZY_U) == KEY_PRESSED)
{ {
setMotorState(MotorHG,Motor_ACT_NOACT); setMotorState(MotorZY,Motor_ACT_NOACT);
} }
if (getKeyPressFlag(KEY_ZY_D) == KEY_PRESSED) if (getKeyPressFlag(KEY_ZY_D) == KEY_PRESSED)
{ {
setMotorState(MotorHG,Motor_ACT_CCW); setMotorState(MotorZY,Motor_ACT_CCW);
} }
if (getKeyReleaseFlag(KEY_ZY_D) == KEY_PRESSED) if (getKeyReleaseFlag(KEY_ZY_D) == KEY_PRESSED)
{ {
setMotorState(MotorHG,Motor_ACT_NOACT); setMotorState(MotorZY,Motor_ACT_NOACT);
} }
} }

2
cva_asw_m0146/src/key.h
View File

@ -19,6 +19,8 @@ typedef enum
KEY_TT_R, KEY_TT_R,
KEY_ZY_U,//上 KEY_ZY_U,//上
KEY_ZY_D,//下 KEY_ZY_D,//下
KEY_FAN,
KEY_HEAT,
KEY_NUM, KEY_NUM,
}KEY_ID_type; }KEY_ID_type;

6
cva_asw_m0146/src/main.c
View File

@ -71,15 +71,15 @@ int main(void)
SEGGER_RTT_Init(); SEGGER_RTT_Init();
hw_init(&mcu); hw_init();
appTaskInit(&mcu); appTaskInit();
IrqDrv_EnableGlobalInterrupt(); IrqDrv_EnableGlobalInterrupt();
SEGGER_RTT_printf(0,"-----init success-----\n"); SEGGER_RTT_printf(0,"-----init success-----\n");
while(1) while(1)
{ {
appTask(&mcu); appTask();
} }
} }

4
cva_asw_m0146/src/private_driver/drivers/cpu/startup/app_system_M014x.c
View File

@ -52,7 +52,7 @@ void SystemInit(void)
#if defined (_USE_EXT_OSC_) #if defined (_USE_EXT_OSC_)
/* Use External oscillator */ /* Use External oscillator */
AcgReg_SetOscRange(ACG, 3); /* set SOSC frequency range(use max value when SOSC as the clock source of the PLL) */ AcgReg_SetOscRange(ACG, 1); /* set SOSC frequency range(use max value when SOSC as the clock source of the PLL) */
AcgReg_SetEnSosc(ACG, 1); /* enable SOSC */ AcgReg_SetEnSosc(ACG, 1); /* enable SOSC */
while(AcgReg_GetStSoscRdy(ACG) == 0); /* wait until SOSC is ready */ while(AcgReg_GetStSoscRdy(ACG) == 0); /* wait until SOSC is ready */
@ -68,7 +68,7 @@ void SystemInit(void)
*/ */
AcgReg_SetPllClkIn(ACG, 2); AcgReg_SetPllClkIn(ACG, 2);
AcgReg_SetPllPreDiv(ACG, 0); AcgReg_SetPllPreDiv(ACG, 0);
AcgReg_SetPllM(ACG, 45); AcgReg_SetPllM(ACG, 90);
AcgReg_SetPllFbkSel(ACG, 0); AcgReg_SetPllFbkSel(ACG, 0);
AcgReg_SetPllPosDiv(ACG, 3); AcgReg_SetPllPosDiv(ACG, 3);
/* SCG PLL configuration: /* SCG PLL configuration: