andy/kunlun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2cb352f92c00476cf33fa8a2cbd2892ac89da9a4
kunlun/app/iot_cus_at_app/driver/app_gpio.c

1428 lines
43 KiB
C
Raw Normal View History

初始提交
2024-09-28 14:24:04 +08:00
/****************************************************************************
Copyright(c) 2019 by Aerospace C.Power (Chongqing) Microelectronics. ALL RIGHTS RESERVED.
This Information is proprietary to Aerospace C.Power (Chongqing) Microelectronics and MAY NOT
be copied by any method or incorporated into another program without
the express written consent of Aerospace C.Power. This Information or any portion
thereof remains the property of Aerospace C.Power. The Information contained herein
is believed to be accurate and Aerospace C.Power assumes no responsibility or
liability for its use in any way and conveys no license or title under
any patent or copyright and makes no representation or warranty that this
Information is free from patent or copyright infringement.
****************************************************************************/
#include "app_common.h"
#include "app_config.h"
#include "app_main.h"
#include "app_gpio.h"
#if (TARGET_VERSION == TARGET_KUNLUN)
#define PWM_ID_MAX 4 /* KL1 has 4 pwm channels */
#elif (TARGET_VERSION == TARGET_KUNLUN2)
#define PWM_ID_MAX 6 /* KL2 has 6 pwm channels */
#elif (TARGET_VERSION == TARGET_KUNLUN3)
#define PWM_ID_MAX 6 /* kl3 has 6 pwm channels */
#endif
static app_io_state g_hwio[APP_IO_PIN_MAX_NUM];
static uint16_t g_pwm_logar[101] = {
0,1,1,1,1,2,2,2,2,2,3
,3,3,3,4,4,4,5,5,6,6
,7,8,8,9,10,11,12,13,14,16
,17,19,21,23,25,28,30,33,36,40
,44,48,52,58,63,69,76,83,91,100
,110,120,132,145,158,174,191,209,229,251
,275,302,331,363,398,437,479,525,575,631
,692,759,832,912,1000,1096,1202,1318,1445,1585
,1738,1905,2089,2291,2512,2754,3020,3311,3631,3981
,4365,4786,5248,5754,6310,6918,7586,8318,9120,10000
};
static timer_id_t g_pwm_timer[PWM_ID_MAX];
static pwm_adjust_state g_pwm_adjust[PWM_ID_MAX] = {0};
#define IO_HTZD_CCO_3_PHASE_NUM 0
#define IO_HTZD_STA_1_PHASE_NUM 3
#define IO_LEDC_NUM 3
#define IO_Q111N_H_NUM 3
#define IO_Q111N_HS_NUM 3
#define IO_Q111N_ISC_NUM 5
#define IO_Q111N_ISF_NUM 12
#define IO_Q111N_ISG_NUM 5
#define IO_IPL_YY01_NUM 12
static uint8_t default_io_HTZD_STA_1_PHASE(app_io_state *io_state, uint8_t idx)
{
if (NULL == io_state || idx >= IO_HTZD_STA_1_PHASE_NUM) {
return ERR_FAIL;
}
switch(idx) {
case 0:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_10, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 1:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_28, 50, 5, 0, 0,
IOT_PWM_CHANNEL_0, 0};
break;
case 2:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_36, 50, 5, 0, 0,
IOT_PWM_CHANNEL_1, 0};
break;
default:
break;
}
return ERR_OK;
}
static uint8_t default_io_LEDC(app_io_state *io_state, uint8_t idx)
{
if (NULL == io_state || idx >= IO_LEDC_NUM) {
return ERR_FAIL;
}
switch(idx) {
case 0:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_10, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 1:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_28, 50, 5, 0, 0,
IOT_PWM_CHANNEL_0, 0};
break;
case 2:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_36, 50, 5, 0, 0,
IOT_PWM_CHANNEL_1, 0};
break;
default:
break;
}
return ERR_OK;
}
static uint8_t default_io_Q111N_H(app_io_state *io_state, uint8_t idx)
{
if (NULL == io_state || idx >= IO_Q111N_H_NUM) {
return ERR_FAIL;
}
switch(idx) {
case 0:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_22, 0, 5, 0, 0,
IOT_PWM_CHANNEL_0, 0};
break;
case 1:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_23, 0, 5, 0, 0,
IOT_PWM_CHANNEL_1, 0};
break;
case 2:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_36, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
default:
break;
}
return ERR_OK;
}
static uint8_t default_io_Q111N_HS(app_io_state *io_state, uint8_t idx)
{
if (NULL == io_state || idx >= IO_Q111N_HS_NUM) {
return ERR_FAIL;
}
switch(idx) {
case 0:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_22, 0, 5, 0, 0,
IOT_PWM_CHANNEL_0, 0};
break;
case 1:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_23, 0, 5, 0, 0,
IOT_PWM_CHANNEL_1, 0};
break;
case 2:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_36, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
default:
break;
}
return ERR_OK;
}
static uint8_t default_io_Q111N_ISC(app_io_state *io_state, uint8_t idx)
{
if (NULL == io_state || idx >= IO_Q111N_ISC_NUM) {
return ERR_FAIL;
}
switch(idx) {
case 0:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_22, 0, 5, 0, 0,
IOT_PWM_CHANNEL_0, 0};
break;
case 1:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_23, 0, 5, 0, 0,
IOT_PWM_CHANNEL_1, 0};
break;
case 2:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_10, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 3:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_28, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 4:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_36, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
default:
break;
}
return ERR_OK;
}
static uint8_t default_io_Q111N_ISF(app_io_state *io_state, uint8_t idx)
{
if (NULL == io_state || idx >= IO_Q111N_ISF_NUM) {
return ERR_FAIL;
}
switch(idx) {
case 0:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_22, 0, 5, 0, 0,
IOT_PWM_CHANNEL_0, 0};
break;
case 1:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_23, 0, 5, 0, 0,
IOT_PWM_CHANNEL_1, 0};
break;
case 2:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_10, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 3:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_28, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 4:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_33, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 5:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_36, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 6:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_37, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 7:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_38, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 8:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_39, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 9:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_40, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 10:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_41, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 11:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_42, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
default:
break;
}
return ERR_OK;
}
static uint8_t default_io_Q111N_ISF03(app_io_state *io_state, uint8_t idx)
{
if (NULL == io_state || idx >= IO_Q111N_ISF_NUM) {
return ERR_FAIL;
}
switch(idx) {
case 0:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_0, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 1:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_7, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 2:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_4, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 3:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_26, 0, 5, 0, 0,
IOT_PWM_CHANNEL_0, 0};
break;
case 4:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_31, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 5:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_39, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 6:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_37, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 7:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_34, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 8:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_35, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 9:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_36, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 10:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_38, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 11:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_8, 0, 5, 0, 0,
IOT_PWM_CHANNEL_1, 0};
break;
default:
break;
}
return ERR_OK;
}
static uint8_t default_io_Q111N_ISG(app_io_state *io_state, uint8_t idx)
{
if (NULL == io_state || idx >= IO_Q111N_ISG_NUM) {
return ERR_FAIL;
}
switch(idx){
case 0:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_22, 0, 5, 0, 0,
IOT_PWM_CHANNEL_0, 0};
break;
case 1:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_23, 0, 5, 0, 0,
IOT_PWM_CHANNEL_1, 0};
break;
case 2:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_10, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 3:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_28, 0, 5, 0, 0,
IOT_PWM_CHANNEL_2, 0};
break;
case 4:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_36, 0, 5, 0, 0,
IOT_PWM_CHANNEL_3, 0};
break;
default:
break;
}
return ERR_OK;
}
static uint8_t default_io_IPL_YY01(app_io_state *io_state, uint8_t idx)
{
if (NULL == io_state ||idx >= IO_IPL_YY01_NUM) {
return ERR_FAIL;
}
switch(idx) {
case 0:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_10, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 1:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_22, 0, 5, 0, 0,
IOT_PWM_CHANNEL_0, 0};
break;
case 2:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_23, 0, 5, 0, 0,
IOT_PWM_CHANNEL_1, 0};
break;
case 3:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_28, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 4:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_32, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 5:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_33, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 6:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_36, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 7:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_37, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 8:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_38, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 9:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_39, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 10:
*io_state = (app_io_state) {APP_PIN_GPIO, HI_GPIO_IDX_40, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 11:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_41, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
default:
break;
}
return ERR_OK;
}
static uint8_t default_io_IPL_YY03(app_io_state *io_state, uint8_t idx)
{
if (NULL == io_state ||idx >= IO_IPL_YY01_NUM) {
return ERR_FAIL;
}
switch(idx) {
case 0:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_26, 0, 5, 0, 0,
IOT_PWM_CHANNEL_0, 0};
break;
case 1:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_39, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 2:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_38, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 3:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_37, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 4:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_36, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 5:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_35, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 6:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_31, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 7:
*io_state = (app_io_state){APP_PIN_PWM, HI_GPIO_IDX_8, 0, 5, 0, 0,
IOT_PWM_CHANNEL_1, 0};
break;
case 8:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_7, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 9:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_4, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 10:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_1, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
case 11:
*io_state = (app_io_state){APP_PIN_GPIO, HI_GPIO_IDX_0, 0, 0, 0, 0,
IOT_PWM_CHANNEL_INVAL, 0};
break;
default:
break;
}
return ERR_OK;
}
static uint16_t app_get_io_param_from_nv(app_io_state *io_state)
{
nv_ftm_hwio_id nv_value = {0};
uint16_t ret;
uint32_t offset;
if (NULL == io_state) {
return ERR_FAIL;
}
os_mem_set(&nv_value, 0, sizeof(nv_value));
offset = NV_FTM_HWIO_ID * APP_NV_FTM_SIZE;
ret = app_flash_read(offset, (uint8_t*)&nv_value, sizeof(nv_value));
if (ret != ERR_OK) {
APP_PRINTF("[ERR] %s Read HWIO Failed !!", __FUNCTION__);
return ret;
}
os_mem_cpy(io_state, nv_value.io_type, sizeof(nv_value.io_type));
return ERR_OK;
}
static uint16_t app_save_io_param_to_nv(void)
{
nv_ftm_hwio_id nv_value = {0};
uint16_t ret;
uint32_t offset;
os_mem_cpy(nv_value.io_type, g_hwio, sizeof(nv_value.io_type));
offset = NV_FTM_HWIO_ID * APP_NV_FTM_SIZE;
ret = app_flash_write(offset, (uint8_t*)&nv_value, sizeof(nv_value));
if (ret != ERR_OK) {
APP_PRINTF("[ERR] %s Write HWIO Failed !!", __FUNCTION__);
return ret;
}
return ERR_OK;
}
void app_restore_hwio(void)
{
uint8_t i, ret;
os_mem_set(g_hwio, 0, APP_IO_PIN_MAX_NUM * sizeof(app_io_state));
switch (app_get_hw_ver()) {
case APP_HW_IPL_YY01:
for(i = 0; i < IO_IPL_YY01_NUM; i++) {
default_io_IPL_YY01(&g_hwio[i], i);
}
break;
case APP_HW_IPL_YY03:
for(i = 0; i < IO_IPL_YY01_NUM; i++) {
default_io_IPL_YY03(&g_hwio[i], i);
}
break;
case APP_HW_Q111N_H:
for(i = 0; i < IO_Q111N_H_NUM; i++) {
default_io_Q111N_H(&g_hwio[i], i);
}
break;
case APP_HW_Q111N_HS:
for(i = 0; i < IO_Q111N_HS_NUM; i++) {
default_io_Q111N_HS(&g_hwio[i], i);
}
break;
case APP_HW_Q111N_ISC:
for(i = 0; i < IO_Q111N_ISC_NUM; i++) {
default_io_Q111N_ISC(&g_hwio[i], i);
}
break;
case APP_HW_Q111N_ISF:
for(i = 0; i < IO_Q111N_ISF_NUM; i++) {
default_io_Q111N_ISF(&g_hwio[i], i);
}
break;
case APP_HW_Q111N_ISF03:
for(i = 0; i < IO_Q111N_ISF_NUM; i++) {
default_io_Q111N_ISF03(&g_hwio[i], i);
}
break;
case APP_HW_Q111N_ISG:
for(i = 0; i < IO_Q111N_ISG_NUM; i++) {
default_io_Q111N_ISG(&g_hwio[i], i);
}
break;
case APP_HW_LEDC_P:
case APP_HW_LEDC:
for(i = 0; i < IO_LEDC_NUM; i++) {
default_io_LEDC(&g_hwio[i], i);
}
break;
case APP_HW_HTZD_STA_1_PHASE:
for(i = 0; i < IO_HTZD_STA_1_PHASE_NUM; i++) {
default_io_HTZD_STA_1_PHASE(&g_hwio[i], i);
}
break;
case APP_HW_HTZD_CCO_3_PHASE:
break;
default:
for(i = 0; i < IO_LEDC_NUM; i++) {
default_io_LEDC(&g_hwio[i], i);
}
break;
}
ret = app_save_io_param_to_nv();
if (ret != ERR_OK) {
APP_PRINTF("[ERR] %s Save HWIO Failed !!", __FUNCTION__);
return;
}
}
uint8_t app_get_hw_io_array_size(void)
{
uint8_t size = 0;
uint32_t ver;
app_entity_t *app_entry = NULL;
app_entry = app_get_main_entry();
ver = app_entry->app_cfg.factory.hw_ver;
switch (ver) {
case APP_HW_IPL_YY01:
case APP_HW_IPL_YY03:
size = IO_IPL_YY01_NUM;
break;
case APP_HW_Q111N_H:
size = IO_Q111N_H_NUM;
break;
case APP_HW_Q111N_HS:
size = IO_Q111N_HS_NUM;
break;
case APP_HW_Q111N_ISC:
size = IO_Q111N_ISC_NUM;
break;
case APP_HW_Q111N_ISF:
case APP_HW_Q111N_ISF03:
size = IO_Q111N_ISF_NUM;
break;
case APP_HW_Q111N_ISG:
size = IO_Q111N_ISG_NUM;
break;
case APP_HW_LEDC_P:
case APP_HW_LEDC:
size = IO_LEDC_NUM;
break;
case APP_HW_HTZD_STA_1_PHASE:
size = IO_HTZD_STA_1_PHASE_NUM;
break;
case APP_HW_HTZD_CCO_3_PHASE:
size = IO_HTZD_CCO_3_PHASE_NUM;
break;
default:
break;
}
return size;
}
uint8_t app_get_io_num(uint8_t pin[], uint8_t size)
{
uint8_t cnt = 0;
app_entity_t *app_entry = NULL;
if(size < APP_IO_PIN_MAX_NUM) {
return cnt;
}
app_entry = app_get_main_entry();
switch (app_entry->app_cfg.factory.hw_ver) {
case APP_HW_IPL_YY01:
pin[cnt++] = HI_GPIO_IDX_10;
pin[cnt++] = HI_GPIO_IDX_22;
pin[cnt++] = HI_GPIO_IDX_23;
pin[cnt++] = HI_GPIO_IDX_28;
pin[cnt++] = HI_GPIO_IDX_32;
pin[cnt++] = HI_GPIO_IDX_33;
pin[cnt++] = HI_GPIO_IDX_36;
pin[cnt++] = HI_GPIO_IDX_37;
pin[cnt++] = HI_GPIO_IDX_38;
pin[cnt++] = HI_GPIO_IDX_39;
pin[cnt++] = HI_GPIO_IDX_40;
pin[cnt++] = HI_GPIO_IDX_41;
break;
case APP_HW_IPL_YY03:
pin[cnt++] = HI_GPIO_IDX_26;
pin[cnt++] = HI_GPIO_IDX_39;
pin[cnt++] = HI_GPIO_IDX_38;
pin[cnt++] = HI_GPIO_IDX_37;
pin[cnt++] = HI_GPIO_IDX_36;
pin[cnt++] = HI_GPIO_IDX_35;
pin[cnt++] = HI_GPIO_IDX_31;
pin[cnt++] = HI_GPIO_IDX_8;
pin[cnt++] = HI_GPIO_IDX_7;
pin[cnt++] = HI_GPIO_IDX_4;
pin[cnt++] = HI_GPIO_IDX_1;
pin[cnt++] = HI_GPIO_IDX_0;
break;
case APP_HW_Q111N_H:
pin[cnt++] = HI_GPIO_IDX_22;
pin[cnt++] = HI_GPIO_IDX_23;
pin[cnt++] = HI_GPIO_IDX_36;
break;
case APP_HW_Q111N_HS:
pin[cnt++] = HI_GPIO_IDX_22;
pin[cnt++] = HI_GPIO_IDX_23;
pin[cnt++] = HI_GPIO_IDX_36;
break;
case APP_HW_Q111N_ISC:
pin[cnt++] = HI_GPIO_IDX_22;
pin[cnt++] = HI_GPIO_IDX_23;
pin[cnt++] = HI_GPIO_IDX_10;
pin[cnt++] = HI_GPIO_IDX_28;
pin[cnt++] = HI_GPIO_IDX_36;
break;
case APP_HW_Q111N_ISF:
pin[cnt++] = HI_GPIO_IDX_22;
pin[cnt++] = HI_GPIO_IDX_23;
pin[cnt++] = HI_GPIO_IDX_10;
pin[cnt++] = HI_GPIO_IDX_28;
pin[cnt++] = HI_GPIO_IDX_33;
pin[cnt++] = HI_GPIO_IDX_36;
pin[cnt++] = HI_GPIO_IDX_37;
pin[cnt++] = HI_GPIO_IDX_38;
pin[cnt++] = HI_GPIO_IDX_39;
pin[cnt++] = HI_GPIO_IDX_40;
pin[cnt++] = HI_GPIO_IDX_41;
pin[cnt++] = HI_GPIO_IDX_42;
break;
case APP_HW_Q111N_ISF03:
pin[cnt++] = HI_GPIO_IDX_0;
pin[cnt++] = HI_GPIO_IDX_7;
pin[cnt++] = HI_GPIO_IDX_4;
pin[cnt++] = HI_GPIO_IDX_26;
pin[cnt++] = HI_GPIO_IDX_31;
pin[cnt++] = HI_GPIO_IDX_39;
pin[cnt++] = HI_GPIO_IDX_37;
pin[cnt++] = HI_GPIO_IDX_34;
pin[cnt++] = HI_GPIO_IDX_35;
pin[cnt++] = HI_GPIO_IDX_36;
pin[cnt++] = HI_GPIO_IDX_38;
pin[cnt++] = HI_GPIO_IDX_8;
break;
case APP_HW_Q111N_ISG:
pin[cnt++] = HI_GPIO_IDX_22;
pin[cnt++] = HI_GPIO_IDX_23;
pin[cnt++] = HI_GPIO_IDX_10;
pin[cnt++] = HI_GPIO_IDX_28;
pin[cnt++] = HI_GPIO_IDX_36;
break;
case APP_HW_LEDC_P:
case APP_HW_LEDC:
pin[cnt++] = HI_GPIO_IDX_10;
pin[cnt++] = HI_GPIO_IDX_28;
pin[cnt++] = HI_GPIO_IDX_36;
break;
case APP_HW_HTZD_STA_1_PHASE:
pin[cnt++] = HI_GPIO_IDX_10;
pin[cnt++] = HI_GPIO_IDX_28;
pin[cnt++] = HI_GPIO_IDX_36;
break;
case APP_HW_HTZD_CCO_3_PHASE:
break;
default:
break;
}
return cnt;
}
bool_t app_check_io_state_param(app_io_state *io_state)
{
app_entity_t *app_entry = NULL;
app_entry = app_get_main_entry();
switch (app_entry->app_cfg.factory.hw_ver) {
case APP_HW_IPL_YY01:
switch (io_state->pin_num) {
case HI_GPIO_IDX_10:
case HI_GPIO_IDX_22:
case HI_GPIO_IDX_23:
case HI_GPIO_IDX_28:
case HI_GPIO_IDX_32:
case HI_GPIO_IDX_33:
case HI_GPIO_IDX_36:
case HI_GPIO_IDX_37:
case HI_GPIO_IDX_38:
case HI_GPIO_IDX_39:
case HI_GPIO_IDX_40:
case HI_GPIO_IDX_41:
break;
default:
return false;
}
break;
case APP_HW_IPL_YY03:
switch (io_state->pin_num) {
case HI_GPIO_IDX_26:
case HI_GPIO_IDX_39:
case HI_GPIO_IDX_38:
case HI_GPIO_IDX_37:
case HI_GPIO_IDX_36:
case HI_GPIO_IDX_35:
case HI_GPIO_IDX_31:
case HI_GPIO_IDX_8:
case HI_GPIO_IDX_7:
case HI_GPIO_IDX_4:
case HI_GPIO_IDX_1:
case HI_GPIO_IDX_0:
break;
default:
return false;
}
break;
case APP_HW_Q111N_H:
switch (io_state->pin_num) {
case HI_GPIO_IDX_22:
case HI_GPIO_IDX_23:
case HI_GPIO_IDX_36:
break;
default:
return false;
}
break;
case APP_HW_Q111N_HS:
switch (io_state->pin_num) {
case HI_GPIO_IDX_22:
case HI_GPIO_IDX_23:
case HI_GPIO_IDX_36:
break;
default:
return false;
}
break;
case APP_HW_Q111N_ISC:
switch (io_state->pin_num) {
case HI_GPIO_IDX_22:
case HI_GPIO_IDX_23:
case HI_GPIO_IDX_10:
case HI_GPIO_IDX_28:
case HI_GPIO_IDX_36:
break;
default:
return false;
}
break;
case APP_HW_Q111N_ISF:
switch (io_state->pin_num) {
case HI_GPIO_IDX_22:
case HI_GPIO_IDX_23:
case HI_GPIO_IDX_10:
case HI_GPIO_IDX_28:
case HI_GPIO_IDX_33:
case HI_GPIO_IDX_36:
case HI_GPIO_IDX_37:
case HI_GPIO_IDX_38:
case HI_GPIO_IDX_39:
case HI_GPIO_IDX_40:
case HI_GPIO_IDX_41:
case HI_GPIO_IDX_42:
break;
default:
return false;
}
break;
case APP_HW_Q111N_ISF03:
switch (io_state->pin_num) {
case HI_GPIO_IDX_0:
case HI_GPIO_IDX_7:
case HI_GPIO_IDX_4:
case HI_GPIO_IDX_26:
case HI_GPIO_IDX_31:
case HI_GPIO_IDX_39:
case HI_GPIO_IDX_37:
case HI_GPIO_IDX_34:
case HI_GPIO_IDX_35:
case HI_GPIO_IDX_36:
case HI_GPIO_IDX_38:
case HI_GPIO_IDX_8:
break;
default:
return false;
}
break;
case APP_HW_Q111N_ISG:
switch (io_state->pin_num) {
case HI_GPIO_IDX_22:
case HI_GPIO_IDX_23:
case HI_GPIO_IDX_10:
case HI_GPIO_IDX_28:
case HI_GPIO_IDX_36:
break;
default:
return false;
}
break;
case APP_HW_LEDC_P:
case APP_HW_LEDC:
switch (io_state->pin_num) {
case HI_GPIO_IDX_10:
case HI_GPIO_IDX_28:
case HI_GPIO_IDX_36:
break;
default:
return false;
}
break;
case APP_HW_HTZD_STA_1_PHASE:
switch (io_state->pin_num) {
case HI_GPIO_IDX_10:
case HI_GPIO_IDX_28:
case HI_GPIO_IDX_36:
break;
default:
return false;
}
break;
default:
return false;
}
switch (io_state->type) {
case APP_PIN_GPIO_IN:
break;
case APP_PIN_GPIO:
if (io_state->state > APP_GPIO_STATE_MAX_VALUE) {
return false;
}
break;
case APP_PIN_PWM:
if (io_state->state > APP_PWM_DUTY_CYCLE_MAX_VALUE) {
return false;
} else if (io_state->pwm_freq < APP_PWM_FREQ_MIN_VALUE ||
io_state->pwm_freq > APP_PWM_FREQ_MAX_VALUE) {
return false;
} else if (io_state->pwm_ctl_mode > APP_PWM_MODE_MAX_VALUE) {
return false;
} else if (io_state->pwm_adjust_time > APP_PWM_ADJUST_TIME_MAX_VALUE) {
return false;
}
break;
default:
return false;
}
return true;
}
static app_io_state * get_io_state(uint8_t pin_num)
{
uint16_t i = 0;
for (i = 0; i < app_get_hw_io_array_size(); i++) {
if ((pin_num == g_hwio[i].pin_num) && (g_hwio[i].type > 0)) {
return &g_hwio[i];
}
}
return NULL;
}
static void set_pwm_state(app_io_state *io_state, uint8_t duty,
uint8_t freq)
{
uint32_t pwm_duty = 0;
uint32_t pwm_freq = 0;
if (NULL == io_state) {
return;
}
if (duty > APP_PWM_DUTY_CYCLE_MAX_VALUE) {
duty = APP_PWM_DUTY_CYCLE_MAX_VALUE;
}
if (freq < APP_PWM_FREQ_MIN_VALUE || freq > APP_PWM_FREQ_MAX_VALUE) {
freq = PWM_FREQ_DEF_VAL;
}
/* default clock rate: 25MHz，support: KL1\KL2\KL3 */
pwm_freq = freq * 1000;
if (APP_PWM_CTL_REALTIME == io_state->pwm_ctl_mode) {
pwm_duty = duty * 100;
}
else if (APP_PWM_CTL_LINAR == io_state->pwm_ctl_mode) {
pwm_duty = duty * 100;
}
else if (APP_PWM_CTL_LOGAR == io_state->pwm_ctl_mode) {
pwm_duty = g_pwm_logar[duty];
}
else {
return;
}
app_pwm_config(io_state->pwm_channel, io_state->pin_num, pwm_freq, pwm_duty);
io_state->state = duty;
io_state->pwm_freq = freq;
APP_PRINTF("[INF] %s GPIO%d state:%d freq:%d pwm_duty:%d\n",
__FUNCTION__, io_state->pin_num, duty, freq, pwm_duty);
}
static void pwm_timer_callback(timer_id_t tid, void *arg)
{
app_io_state *p =(app_io_state *)arg;
pwm_adjust_state *adjust_st = (pwm_adjust_state *)&g_pwm_adjust[p->pwm_channel];
if (adjust_st->end_val == adjust_st->current_val) {
os_stop_timer(g_pwm_timer[p->pwm_channel]);
return;
}
if (0 == adjust_st->times) {
adjust_st->current_val = adjust_st->end_val;
} else {
adjust_st->times--;
if (adjust_st->end_val > adjust_st->current_val) {
/* step up */
adjust_st->current_val += ADJUST_PWM_STEPS;
} else if (adjust_st->end_val < adjust_st->current_val) {
/* step down */
adjust_st->current_val -= ADJUST_PWM_STEPS;
}
}
/* update pwm duty */
set_pwm_state(p, adjust_st->current_val, p->pwm_freq);
return;
}
static void pwm_smooth_adjust(app_io_state *p, pwm_adjust_state *state)
{
uint8_t value = 0;
uint16_t period = 0;
if (NULL == p || NULL == state) {
return;
}
APP_PRINTF("[INF] set PWM pin_num:%d state from:%d to:%d\n",
p->pin_num, state->current_val, state->end_val);
if (p->pwm_channel >= PWM_ID_MAX) {
APP_PRINTF("[INF] invalid pwm channel\n");
return;
}
if (state->current_val == state->end_val) {
set_pwm_state(p, p->state, p->pwm_freq);
return;
}
if (state->current_val > state->end_val) {
value = state->current_val - state->end_val;
} else {
value = state->end_val - state->current_val;
}
g_pwm_adjust[p->pwm_channel].duration = state->duration;
g_pwm_adjust[p->pwm_channel].times = value;
g_pwm_adjust[p->pwm_channel].end_val = state->end_val;
g_pwm_adjust[p->pwm_channel].current_val = state->current_val;
period = g_pwm_adjust[p->pwm_channel].duration * 10;
/* Create a timer */
if (g_pwm_adjust[p->pwm_channel].timer_init == 0) {
g_pwm_timer[p->pwm_channel] = os_create_timer(IOT_APP_DEMO_MID, 1,
(os_timer_func_t)pwm_timer_callback, (void *)p);
g_pwm_adjust[p->pwm_channel].timer_init = 1;
if (0 == g_pwm_timer[p->pwm_channel]) {
APP_PRINTF("[ERR] %s Create Timer Failed !!", __FUNCTION__);
return;
}
}
/* Start the timer */
os_start_timer(g_pwm_timer[p->pwm_channel], period);
}
void app_pwm_config(uint8_t ch, uint8_t gpio_p, uint32_t pwm_freq,
uint32_t pwm_duty)
{
iot_epwm_global_config_t epwm_glb_cfg = IOT_EPWM_GLOBAL_CONFIG_DEFAULT;
iot_epwm_ch_config_t epwm_ch_cfg = IOT_EPWM_CHANNEL_CONFIG_DEFAULT;
iot_pwm_api_mode_select(IOT_API_MODE_EPWM);
iot_epwm_global_config_set(&epwm_glb_cfg);
iot_epwm_global_stop();
epwm_ch_cfg.ch_usage = IOT_EPWM_CH_USEAGE_COMMON;
epwm_ch_cfg.ch_clk_div = 1;
epwm_ch_cfg.ch_common_cfg.freq = pwm_freq;
epwm_ch_cfg.ch_common_cfg.duty = pwm_duty;
epwm_ch_cfg.ch_pin_outa = gpio_p;
if(0 != iot_epwm_ch_config_set(ch, &epwm_ch_cfg)) {
APP_PRINTF("[INFO] %s epwm config failed!!", __FUNCTION__);
return;
}
iot_epwm_ch_start(ch);
iot_epwm_global_start();
}
uint16_t app_get_io_map(app_io_state *io_state)
{
uint16_t i = 0;
for (i = 0; i < app_get_hw_io_array_size(); i++) {
if ((io_state->pin_num == g_hwio[i].pin_num)
&& (g_hwio[i].type > 0)) {
os_mem_cpy(io_state, &g_hwio[i], sizeof(app_io_state));
return ERR_OK;
}
}
return ERR_FAIL;
}
uint8_t app_pwm_get_usable_channel(void)
{
uint16_t i = 0;
uint8_t flag_pwm_chl = 0;
for (i = 0; i < app_get_hw_io_array_size(); i++) {
if (APP_PIN_PWM == g_hwio[i].type) {
uint8_t chl = g_hwio[i].pwm_channel;
if (chl >= IOT_PWM_CHANNEL_0 && chl <= PWM_ID_MAX) {
flag_pwm_chl |= (1 << chl);
}
}
}
for (i = IOT_PWM_CHANNEL_0; i <= PWM_ID_MAX; i++) {
if ((flag_pwm_chl & (1 << i)) == 0) {
APP_PRINTF("[INF] %s Got unused pwm channel:%d\n", __FUNCTION__, i);
return i;
}
}
APP_PRINTF("[INF] %s Got no unused pwm channel !!\n", __FUNCTION__);
return IOT_PWM_CHANNEL_INVAL;
}
uint16_t app_get_gpio_state(app_io_state *io_state)
{
app_io_state * p = NULL;
int value;
if (NULL == io_state) {
return ERR_FAIL;
}
p = get_io_state(io_state->pin_num);
if (NULL == p) {
APP_PRINTF("[ERR] %s Invalid pin num %d !!", __FUNCTION__, io_state->pin_num);
return ERR_FAIL;
}
io_state->type = p->type;
if (APP_PIN_PWM == p->type) {
io_state->state = p->state;
io_state->pwm_channel = p->pwm_channel;
io_state->pwm_freq = p->pwm_freq;
io_state->pwm_ctl_mode = p->pwm_ctl_mode;
io_state->pwm_adjust_time = p->pwm_adjust_time;
APP_PRINTF("[INF] get PWM pin_num:%d state:%d freq:%d mode:%d adjust: %d\n",
io_state->pin_num, io_state->state, io_state->pwm_freq,
io_state->pwm_ctl_mode, io_state->pwm_adjust_time);
} else if (APP_PIN_GPIO == p->type || APP_PIN_GPIO_IN == p->type) {
if (APP_PIN_GPIO_IN == p->type) {
value = iot_gpio_value_get(io_state->pin_num);
} else if (ERR_OK != iot_gpio_output_value_get(io_state->pin_num, &value)) {
APP_PRINTF("[ERR] %s Get GPIO:%d Failed !!", __FUNCTION__,
io_state->pin_num);
return ERR_FAIL;
}
io_state->state = (uint8_t)value;
io_state->pwm_channel = IOT_PWM_CHANNEL_INVAL;
io_state->pwm_freq = 0;
io_state->pwm_ctl_mode = 0;
io_state->pwm_adjust_time = 0;
APP_PRINTF("[INF] get GPIO pin_num:%d state:%d\n", io_state->pin_num,
io_state->state);
} else {
APP_PRINTF("[ERR] %s Invalid pin type %d !!", __FUNCTION__, p->type);
return ERR_FAIL;
}
return ERR_OK;
}
uint16_t app_set_gpio_state(app_io_state *new_state, uint8_t save_flash)
{
app_io_state *p = NULL;
#if (TARGET_VERSION == TARGET_KUNLUN)
app_io_state *temp_io = NULL;
uint8_t io_pin[APP_IO_PIN_MAX_NUM] = {0}, i, num = 0, freq = 0, cnt = 0;
#endif
if (NULL == new_state) {
return ERR_FAIL;
}
p = get_io_state(new_state->pin_num);
if (NULL == p) {
APP_PRINTF("[ERR] %s Invalid pin num %d !!",
__FUNCTION__, new_state->pin_num);
return ERR_FAIL;
}
/* handle gpio type. */
if (new_state->init_state == 0) {
/* Stop PWM, and set channel free. */
if (APP_PIN_PWM == p->type && p->pwm_channel < PWM_ID_MAX) {
if (g_pwm_adjust[p->pwm_channel].timer_init == 1) {
if (os_is_timer_active(g_pwm_timer[p->pwm_channel])) {
os_stop_timer(g_pwm_timer[p->pwm_channel]);
}
}
}
/* when in kl1 chip,the pwm which is more than one channel
in use can't change freq, otherwise The pwm mode of more than one
channel needs to be switched to gpio mode */
#if (TARGET_VERSION == TARGET_KUNLUN)
if ((APP_PIN_PWM != p->type) && (APP_PIN_PWM != new_state->type)) {
iot_gpio_close(p->pin_num);
} else if (APP_PIN_PWM == p->type &&
(APP_PIN_GPIO == new_state->type ||
APP_PIN_GPIO_IN == new_state->type)) {
/* if one pwm channel close when in kl1 chip,
all pwm can't output wave shape */
if (p->pwm_channel != IOT_PWM_CHANNEL_INVAL) {
iot_epwm_ch_close(p->pwm_channel);
}
} else if (APP_PIN_PWM == new_state->type) {
num = app_get_io_num(io_pin, sizeof(io_pin));
for (i = 0; i < num; i++) {
temp_io = get_io_state(io_pin[i]);
if (temp_io->type == APP_PIN_PWM) {
freq = temp_io->pwm_freq;
cnt++;
}
}
if (APP_PIN_PWM == p->type && APP_PIN_PWM == new_state->type) {
if (cnt > 1 && new_state->pwm_freq != p->pwm_freq) {
APP_PRINTF("[ERR] %s pwm can't change freq !!", __FUNCTION__);
return ERR_FAIL;
}
}
if ((APP_PIN_GPIO == p->type || APP_PIN_GPIO_IN == p->type) &&
APP_PIN_PWM == new_state->type) {
if (cnt == 0 || freq == new_state->pwm_freq) {
iot_gpio_close(p->pin_num);
} else {
APP_PRINTF("[ERR] %s pwm freq isn't equal to other pwm freq !!",
__FUNCTION__);
return ERR_FAIL;
}
}
}
#elif (TARGET_VERSION == TARGET_KUNLUN3)
if ((APP_PIN_GPIO == new_state->type ||
APP_PIN_GPIO_IN == new_state->type) &&
APP_PIN_PWM == p->type) {
iot_epwm_ch_close(p->pwm_channel);
} else if (APP_PIN_GPIO == p->type || APP_PIN_GPIO_IN == p->type) {
iot_gpio_close(p->pin_num);
}
#endif
if (APP_PIN_GPIO == p->type || APP_PIN_GPIO == new_state->type) {
p->pwm_channel = IOT_PWM_CHANNEL_INVAL;
}
p->init_state = 0;
}
/* set new state. */
if (APP_PIN_GPIO == new_state->type) {
if (0 == p->init_state) {
if (ERR_OK != iot_gpio_open_as_output(p->pin_num)) {
APP_PRINTF("[ERR] %s Set GPIO:%d as output Failed !!",
__FUNCTION__, p->pin_num);
return ERR_FAIL;
}
if (ERR_OK != iot_gpio_value_set(p->pin_num , new_state->state)) {
APP_PRINTF("[ERR] %s Set GPIO:%d value Failed !!",
__FUNCTION__, p->pin_num);
return ERR_FAIL;
}
p->init_state = 1;
}
} else if (APP_PIN_GPIO_IN == new_state->type) {
if (0 == p->init_state) {
if (ERR_OK != iot_gpio_open_as_input(p->pin_num)) {
APP_PRINTF("[ERR] %s Set GPIO:%d as input Failed !!",
__FUNCTION__, p->pin_num);
return ERR_FAIL;
}
if (ERR_OK != iot_gpio_set_pull_mode(p->pin_num, GPIO_PULL_DOWN)) {
APP_PRINTF("[ERR] %s Set GPIO:%d input pull mode Failed !!",
__FUNCTION__, p->pin_num);
return ERR_FAIL;
}
p->init_state = 1;
}
} else if (APP_PIN_PWM == new_state->type) {
if (0 == p->init_state) {
if (IOT_PWM_CHANNEL_INVAL == p->pwm_channel) {
uint8_t chl = app_pwm_get_usable_channel();
if (IOT_PWM_CHANNEL_INVAL == chl ) {
APP_PRINTF("[ERR] %s Get usable pwm channel Failed !!",
__FUNCTION__);
return ERR_FAIL;
}
p->pwm_channel = chl;
}
p->pwm_ctl_mode = new_state->pwm_ctl_mode;
p->pwm_adjust_time = new_state->pwm_adjust_time;
p->init_state = 1;
}
if (APP_PWM_CTL_REALTIME == p->pwm_ctl_mode) {
if(p->pwm_freq != new_state->pwm_freq) {
p->pwm_freq = new_state->pwm_freq;
}
set_pwm_state(p, new_state->state, p->pwm_freq);
} else {
pwm_adjust_state pwm_state;
p->pwm_freq = PWM_FREQ_DEF_VAL;
pwm_state.duration = p->pwm_adjust_time;
pwm_state.current_val = p->state;
pwm_state.end_val = new_state->state;
pwm_smooth_adjust(p, &pwm_state);
}
}
p->type = new_state->type;
p->state = new_state->state;
APP_PRINTF("[INF] %s Set GPIO pin_num:%d type:%d state:%d save:%d\n",
__FUNCTION__, p->pin_num, p->type, p->state, save_flash);
/* Save new state to flash */
if (save_flash == STATE_SAVE_FLASH) {
if (ERR_OK != app_save_io_param_to_nv()) {
return ERR_FAIL;
}
}
return ERR_OK;
}
void app_io_init(void)
{
uint8_t i = 0, ch, ret;
ret = app_get_io_param_from_nv(g_hwio);
if (ret != ERR_OK) {
APP_PRINTF("%s read io param error\n", __FUNCTION__);
return;
}
for (i = 0; i < app_get_hw_io_array_size(); i++) {
app_io_state * p = &g_hwio[i];
if (APP_PIN_GPIO == p->type) {
p->init_state = 0;
if (ERR_OK != iot_gpio_open_as_output(p->pin_num)) {
APP_PRINTF("[ERR] %s Open Gpio %d as output Failed !!",
__FUNCTION__, p->pin_num);
continue;
}
p->init_state = 1;
if (ERR_OK != iot_gpio_value_set(p->pin_num, p->state)) {
APP_PRINTF("[ERR] %s Set Gpio %d value Failed !!",
__FUNCTION__, p->pin_num);
continue;
}
} else if (APP_PIN_GPIO_IN == p->type) {
p->init_state = 0;
if (ERR_OK != iot_gpio_open_as_input(p->pin_num)) {
APP_PRINTF("[ERR] %s Open Gpio %d as input Failed !!",
__FUNCTION__, p->pin_num);
continue;
}
if (ERR_OK != iot_gpio_set_pull_mode(p->pin_num, GPIO_PULL_DOWN)) {
APP_PRINTF("[ERR] %s Set GPIO:%d input pull mode Failed !!",
__FUNCTION__, p->pin_num);
continue;
}
p->init_state = 1;
} else if (APP_PIN_PWM == p->type) {
p->init_state = 0;
if (IOT_PWM_CHANNEL_INVAL == p->pwm_channel) {
ch = app_pwm_get_usable_channel();
if (IOT_PWM_CHANNEL_INVAL != ch) {
p->pwm_channel = ch;
} else {
APP_PRINTF("[ERR] %s Get usable pwm channel Failed !!",
__FUNCTION__);
p->init_state = 0;
continue;
}
}
if (APP_PWM_CTL_REALTIME == p->pwm_ctl_mode) {
set_pwm_state(p, p->state, p->pwm_freq);
} else {
pwm_adjust_state pwm_state;
pwm_state.duration = p->pwm_adjust_time;
pwm_state.current_val = p->state;
pwm_state.end_val = p->state;
pwm_smooth_adjust(p, &pwm_state);
set_pwm_state(p, p->state, p->pwm_freq);
}
p->init_state = 1;
} else {
continue;
}
}
return;
}
Reference in New Issue Copy Permalink