Index: yc_adc.h =================================================================== --- /YC3121_SDK/fw/sdk/yc_adc.h (revision 669) +++ /YC3121_SDK/fw/sdk/yc_adc.h (working copy) @@ -1,8 +1,8 @@ /* File Name : yc_adc.h Author : Yichip -Version : V1.0 -Date : 2018/03/27 +Version : V1.1 +Date : 2020/07/14 Description : ADC encapsulation. */ @@ -24,21 +24,21 @@ #define FILT_NUM 20 #define REMOVE_NUM 6 - + #define WAIT_TIME 5000 -/* ADC Channel select */ +/* ADC Channel select */ typedef enum { - ADC_CHANNEL_0 = 0, - ADC_CHANNEL_1, - ADC_CHANNEL_2, - ADC_CHANNEL_3, - ADC_CHANNEL_4, - ADC_CHANNEL_5, - ADC_CHANNEL_6, - ADC_CHANNEL_7, -}ADC_ChxTypeDef; + ADC_CHANNEL_0 = 0, + ADC_CHANNEL_1, + ADC_CHANNEL_2, + ADC_CHANNEL_3, + ADC_CHANNEL_4, + ADC_CHANNEL_5, + ADC_CHANNEL_6, + ADC_CHANNEL_7, +} ADC_ChxTypeDef; #define IS_ADC_CHANNEL(CHANNEL_NUM) (((CHANNEL_NUM) == ADC_CHANNEL_0) || \ ((CHANNEL_NUM) == ADC_CHANNEL_1) || \ @@ -51,23 +51,23 @@ typedef enum { - ADC_GPIO = 0, - ADC_DIFF, - ADC_HVIN, - ADC_VINLPM, -}ADC_ModeTypeDef; + ADC_GPIO = 0, + ADC_DIFF, + ADC_HVIN, + ADC_VINLPM, +} ADC_ModeTypeDef; #define IS_ADC_MODE(MODE) ((MODE == ADC_GPIO)||\ (MODE == ADC_DIFF)||\ (MODE == ADC_HVIN)||\ (MODE == ADC_VINLPM)) -/* ADC Struct Define*/ +/* ADC Struct Define*/ typedef struct _ADC_InitTypeDef { - ADC_ChxTypeDef ADC_Channel; /* ADC Channel select */ - ADC_ModeTypeDef ADC_Mode; -} ADC_InitTypeDef; - + ADC_ChxTypeDef ADC_Channel; /* ADC Channel select */ + ADC_ModeTypeDef ADC_Mode; +} ADC_InitTypeDef; + /** * @brief Initialize adc module * Index: yc_adc.c =================================================================== --- /YC3121_SDK/fw/sdk/yc_adc.c (revision 669) +++ /YC3121_SDK/fw/sdk/yc_adc.c (working copy) @@ -1,8 +1,8 @@ /* File Name : yc_adc.c Author : Yichip -Version : V1.0 -Date : 2019/08/14 +Version : V1.1 +Date : 2020/07/14 Description : ADC encapsulation. */ #include "yc_adc.h" @@ -10,169 +10,172 @@ #define ADC_RESULT (0x7FE&ADC_RDATA) extern Boolean ipc_inited; -static int calculate_voltage(int result, int vol_high_ref,int vol_low_ref , int vol_high, int vol_low); +static int calculate_voltage(int result, int vol_high_ref, int vol_low_ref, int vol_high, int vol_low); void ADC_Init(ADC_InitTypeDef *ADC_InitStruct) { - _ASSERT(IS_ADC_CHANNEL(ADC_InitStruct->ADC_Channel)); - _ASSERT(IS_ADC_MODE(ADC_InitStruct->ADC_Mode)); - /****************open dpll*******************/ -// *(volatile uint8_t*)0xC40c3 = 0x00; -// *(volatile uint8_t*)0xC40c4 = 0x4f; -// *(volatile uint8_t*)0xC4f00 = 0xff; - IpcInit(); - - /****************config adc******************* */ - ADC_CTRL1 = 0x8f|((ADC_InitStruct->ADC_Mode)<<4); - //ADC_ENBLE |= 0x7c; - ADC_CTRL0 = 0x7f; - ADC_CTRL2 = 0xaa; - ADC_CTRL3 = 0x30|ADC_InitStruct->ADC_Channel; + _ASSERT(IS_ADC_CHANNEL(ADC_InitStruct->ADC_Channel)); + _ASSERT(IS_ADC_MODE(ADC_InitStruct->ADC_Mode)); + /****************open dpll*******************/ + IpcInit(); + + /****************config adc******************* */ + ADC_CTRL1 = 0x8f | ((ADC_InitStruct->ADC_Mode) << 4); +#if (VERSIONS == NO_BT) + ADC_ENBLE = 0x7c; +#endif + ADC_CTRL0 = 0x7f; + ADC_CTRL2 = 0xaa; + ADC_CTRL3 = 0x30 | ADC_InitStruct->ADC_Channel; } uint16_t ADC_GetResult(ADC_ChxTypeDef ADC_Channel) { - if(ipc_inited==FALSE) return 0; - int nop = WAIT_TIME; - //ADC_ENBLE |= 0x7c; - ADC_CTRL0 = 0x7f; - ADC_CTRL2 = 0xaa; - ADC_CTRL3 = 0x30|ADC_Channel; - while(nop--); - return ADC_RESULT; + if (ipc_inited == FALSE) return 0; + int nop = WAIT_TIME; +#if (VERSIONS == NO_BT) + ADC_ENBLE = 0x7c; +#endif + ADC_CTRL0 = 0x7f; + ADC_CTRL2 = 0xaa; + ADC_CTRL3 = 0x30 | ADC_Channel; + while (nop--); + return ADC_RESULT; } int ADC_Filt(ADC_ChxTypeDef ADC_Channel) { - int8_t i,j; - uint16_t ADC_Buffer[FILT_NUM],tmp; - int nop = WAIT_TIME; - int cnt = 200; - if(ipc_inited==FALSE) return -1; - //ADC_ENBLE |= 0x7c; - ADC_CTRL0 = 0x7f; - ADC_CTRL2 = 0xaa; - ADC_CTRL3 = 0x30|ADC_Channel; - - while (nop--){}; - - if (REMOVE_NUM * 2 >= FILT_NUM) - { - return -1; - } - - for (i = 0; i < FILT_NUM; i++) - { - ADC_Buffer[i] = ADC_RESULT; - if (ADC_Buffer[i] != 0) - { - continue; - } - else - { - i--; - if(0 == cnt--) - return -1; - } - #ifdef SDK_DEBUG - MyPrintf("ADC_result,%d ",ADC_RESULT); - #endif - } - for (j = 1; j < FILT_NUM; j++) - { - tmp = ADC_Buffer[j]; - i = j - 1; - while (i >= 0 && ADC_Buffer[i] > tmp) - { - ADC_Buffer[i + 1] = ADC_Buffer[i]; - i--; - } - ADC_Buffer[i + 1] = tmp; - } - - for (tmp = 0, i = REMOVE_NUM; i < FILT_NUM - REMOVE_NUM; i++) - { - tmp += ADC_Buffer[i]; - } + int8_t i, j; + uint16_t ADC_Buffer[FILT_NUM], tmp; + int nop = WAIT_TIME; + int cnt = 200; + if (ipc_inited == FALSE) return -1; +#if (VERSIONS == NO_BT) + ADC_ENBLE = 0x7c; +#endif + ADC_CTRL0 = 0x7f; + ADC_CTRL2 = 0xaa; + ADC_CTRL3 = 0x30 | ADC_Channel; + + while (nop--) {}; + + if (REMOVE_NUM * 2 >= FILT_NUM) + { + return -1; + } + + for (i = 0; i < FILT_NUM; i++) + { + ADC_Buffer[i] = ADC_RESULT; + if (ADC_Buffer[i] != 0) + { + continue; + } + else + { + i--; + if (0 == cnt--) + return -1; + } +#ifdef SDK_DEBUG + MyPrintf("ADC_result,%d ", ADC_RESULT); +#endif + } + for (j = 1; j < FILT_NUM; j++) + { + tmp = ADC_Buffer[j]; + i = j - 1; + while (i >= 0 && ADC_Buffer[i] > tmp) + { + ADC_Buffer[i + 1] = ADC_Buffer[i]; + i--; + } + ADC_Buffer[i + 1] = tmp; + } + + for (tmp = 0, i = REMOVE_NUM; i < FILT_NUM - REMOVE_NUM; i++) + { + tmp += ADC_Buffer[i]; + } - return tmp / (FILT_NUM - 2 * REMOVE_NUM); + return tmp / (FILT_NUM - 2 * REMOVE_NUM); } int ADC_GetVoltage(ADC_ChxTypeDef ADC_Channel) { - int result = 0; - int i = 0,j = 0; - int voltage_low = 2800; - int voltage_high = 5000; - int reg_voltage_low = 640*1000; - int ref_voltage_high = 744*1000; - int adc_result_buf[FILT_NUM] = {0}; - - uint8_t getmode = (ADC_CTRL1 & 0x70) >> 4; - uint8_t data[16] = {0}; - - if(ipc_inited==FALSE) return -1; - - //read otp reference - read_otp(ADC_REF_OTP_ADDR, data, 16); - - switch(getmode) - { - case ADC_GPIO: - reg_voltage_low = ((data[3]<<8) | data[2])*1000; - ref_voltage_high = ((data[9]<<8)| data[8])*1000; - voltage_low = IO_LOW_VOLTAGE_REF; - voltage_high = IO_HIHG_VOLTAGE_REF; - break; - - case ADC_HVIN: - reg_voltage_low = ((data[5]<<8) | data[4])*1000;//OTP中3.3v校准值 - ref_voltage_high = ((data[11]<<8)| data[10])*1000;//OTP中5.0V校准值 - voltage_low = HVIN_LOW_VOLTAGE_REF; - voltage_high = HVIN_HIHG_VOLTAGE_REF; - break; - - case ADC_VINLPM: - reg_voltage_low = ((data[5]<<8) | data[4])*1000; - ref_voltage_high = ((data[11]<<8)| data[10])*1000; - voltage_low = VINLPM_LOW_VOLTAGE_REF; - voltage_high = VINLPM_HIHG_VOLTAGE_REF; - break; - default: - return -1; - } - - if (reg_voltage_low == 0 || ref_voltage_high == 0) - return -1; - - while (i < FILT_NUM)//get FFILT_NUM result - { - result = ADC_GetResult(ADC_Channel); - if (result >0) - { - adc_result_buf[i++] = calculate_voltage(result, ref_voltage_high, reg_voltage_low, voltage_high, voltage_low); - } - if (++j>FILT_NUM+10) - return -1; //debug whiel(1) - } - - for (j = 1; j < FILT_NUM; j++) - { - result = adc_result_buf[j]; - i = j - 1; - while(i >= 0 && adc_result_buf[i] > result) - { - adc_result_buf[i + 1] = adc_result_buf[i]; - i--; - } - adc_result_buf[i + 1] = result; - } - - for (result = 0, i = REMOVE_NUM; i < FILT_NUM - REMOVE_NUM; i++) - { - result += adc_result_buf[i]; - } - return result / (FILT_NUM - 2 * REMOVE_NUM); + int result = 0; + int i = 0, j = 0; + int voltage_low = 2800; + int voltage_high = 5000; + int reg_voltage_low = 640 * 1000; + int ref_voltage_high = 744 * 1000; + int adc_result_buf[FILT_NUM] = {0}; + + uint8_t getmode = (ADC_CTRL1 & 0x70) >> 4; + uint8_t data[16] = {0}; + + if (ipc_inited == FALSE) return -1; + + //read otp reference + read_otp(ADC_REF_OTP_ADDR, data, 16); + + switch (getmode) + { + case ADC_GPIO: + reg_voltage_low = ((data[3] << 8) | data[2]) * 1000; + ref_voltage_high = ((data[9] << 8) | data[8]) * 1000; + voltage_low = IO_LOW_VOLTAGE_REF; + voltage_high = IO_HIHG_VOLTAGE_REF; + break; + + case ADC_HVIN: + reg_voltage_low = ((data[5] << 8) | data[4]) * 1000; //OTP中3.3v校准值 + ref_voltage_high = ((data[11] << 8) | data[10]) * 1000; //OTP中5.0V校准值 + voltage_low = HVIN_LOW_VOLTAGE_REF; + voltage_high = HVIN_HIHG_VOLTAGE_REF; + break; + + case ADC_VINLPM: + reg_voltage_low = ((data[5] << 8) | data[4]) * 1000; + ref_voltage_high = ((data[11] << 8) | data[10]) * 1000; + voltage_low = VINLPM_LOW_VOLTAGE_REF; + voltage_high = VINLPM_HIHG_VOLTAGE_REF; + break; + default: + return -1; + } + + if (reg_voltage_low == 0 || ref_voltage_high == 0) + return -1; + + while (i < FILT_NUM)//get FFILT_NUM result + { + result = ADC_GetResult(ADC_Channel); + if (result > 0) + { + adc_result_buf[i++] = calculate_voltage(result, ref_voltage_high, reg_voltage_low, voltage_high, voltage_low); + } + if (++j > FILT_NUM + 10) + return -1; //debug whiel(1) + } + + for (j = 1; j < FILT_NUM; j++) + { + result = adc_result_buf[j]; + i = j - 1; + while (i >= 0 && adc_result_buf[i] > result) + { + adc_result_buf[i + 1] = adc_result_buf[i]; + i--; + } + adc_result_buf[i + 1] = result; + } + + for (result = 0, i = REMOVE_NUM; i < FILT_NUM - REMOVE_NUM; i++) + { + result += adc_result_buf[i]; + } + return result / (FILT_NUM - 2 * REMOVE_NUM); } /** @@ -181,14 +184,14 @@ * vol_high_ref : high voltage reference value * vol_low_ref : low voltage reference value * vol_high : high reference voltage (mV) - * vol_low : low reference voltage + * vol_low : low reference voltage * @retval voltage (mV) */ -static int calculate_voltage(int result, int vol_high_ref,int vol_low_ref , int vol_high, int vol_low) +static int calculate_voltage(int result, int vol_high_ref, int vol_low_ref, int vol_high, int vol_low) { - int rega = result*1000 - vol_low_ref; - int regb = vol_high_ref - vol_low_ref; - int regc = vol_high - vol_low; - int temp = (rega *regc)/regb +vol_low; - return temp; + int rega = result * 1000 - vol_low_ref; + int regb = vol_high_ref - vol_low_ref; + int regc = vol_high - vol_low; + int temp = (rega * regc) / regb + vol_low; + return temp; } Index: yc_exti.h =================================================================== --- /YC3121_SDK/fw/sdk/yc_exti.h (revision 669) +++ /YC3121_SDK/fw/sdk/yc_exti.h (working copy) @@ -5,23 +5,23 @@ Date : 2019/12/04 Description : exit encapsulation. */ - + #ifndef __YC_EXTI_H__ #define __YC_EXTI_H__ - + #include "yc3121.h" #include "yc_gpio.h" -/** - * @brief EXTI Trigger enumeration +/** + * @brief EXTI Trigger enumeration */ typedef enum { - EXTI_Trigger_Off = 0, - EXTI_Trigger_Rising = 1, - EXTI_Trigger_Falling = 2, - EXTI_Trigger_Rising_Falling = 3 -}EXTI_TriggerTypeDef; + EXTI_Trigger_Off = 0, + EXTI_Trigger_Rising = 1, + EXTI_Trigger_Falling = 2, + EXTI_Trigger_Rising_Falling = 3 +} EXTI_TriggerTypeDef; #define EXTI_Line0 ((uint32_t)0x0000) /*!< External interrupt line 0 */ #define EXTI_Line1 ((uint32_t)0x0001) /*!< External interrupt line 1 */ Index: yc_exti.c =================================================================== --- /YC3121_SDK/fw/sdk/yc_exti.c (revision 669) +++ /YC3121_SDK/fw/sdk/yc_exti.c (working copy) @@ -11,180 +11,180 @@ void EXTI_ClearITPendingBit(uint32_t EXTI_Line, uint16_t EXTI_PinSource) { - _ASSERT(IS_EXTI_LINE(EXTI_Line)); - _ASSERT(IS_EXTI_PIN_SOURCE(EXTI_PinSource)); + _ASSERT(IS_EXTI_LINE(EXTI_Line)); + _ASSERT(IS_EXTI_PIN_SOURCE(EXTI_PinSource)); - uint16_t GpioTrig = GPIO_TRIG_MODE(EXTI_Line); - - if (GpioTrig & EXTI_PinSource) - { - GpioTrig &= ~EXTI_PinSource; - } - else - { - GpioTrig |= EXTI_PinSource; - } - GPIO_TRIG_MODE(EXTI_Line) = GpioTrig; - ExtiStatus[EXTI_Line] &= ~EXTI_PinSource; + uint16_t GpioTrig = GPIO_TRIG_MODE(EXTI_Line); + + if (GpioTrig & EXTI_PinSource) + { + GpioTrig &= ~EXTI_PinSource; + } + else + { + GpioTrig |= EXTI_PinSource; + } + GPIO_TRIG_MODE(EXTI_Line) = GpioTrig; + ExtiStatus[EXTI_Line] &= ~EXTI_PinSource; } void EXTI_DeInit() { - uint32_t i; - for (i = 0; i < EXIT_Num; i++) - { - ExtiEn[i] = 0; - GPIO_INTR_EN(i) = ExtiEn[i]; - ExtiTrig[i] = 0; - ExtiRisingFallingTrig[i] = 0; - ExtiStatus[i] = 0; - GPIO_TRIG_MODE(i) = ExtiTrig[i]; - } + uint32_t i; + for (i = 0; i < EXIT_Num; i++) + { + ExtiEn[i] = 0; + GPIO_INTR_EN(i) = ExtiEn[i]; + ExtiTrig[i] = 0; + ExtiRisingFallingTrig[i] = 0; + ExtiStatus[i] = 0; + GPIO_TRIG_MODE(i) = ExtiTrig[i]; + } } uint16_t EXTI_GetITLineStatus(uint32_t EXTI_Line) { - return ExtiStatus[EXTI_Line]; + return ExtiStatus[EXTI_Line]; } void EXTI_LineConfig(uint32_t EXTI_Line, uint16_t EXTI_PinSource, EXTI_TriggerTypeDef EXTI_Trigger) { - _ASSERT(IS_EXTI_LINE(EXTI_Line)); - _ASSERT(IS_EXTI_PIN_SOURCE(EXTI_PinSource)); + _ASSERT(IS_EXTI_LINE(EXTI_Line)); + _ASSERT(IS_EXTI_PIN_SOURCE(EXTI_PinSource)); - int i; - uint16_t TempExtiTrig = GPIO_TRIG_MODE(EXTI_Line); + int i; + uint16_t TempExtiTrig = GPIO_TRIG_MODE(EXTI_Line); - for (i = 0; i < EXIT_Num; i++) - { - if (GPIO_INTR_EN(i) == 0x0000) - { - ExtiEn[i] = 0; - ExtiTrig[i] = 0; - ExtiRisingFallingTrig[i] = 0; - ExtiStatus[i] = 0; - } - } - - switch (EXTI_Trigger) - { - case EXTI_Trigger_Off: - ExtiEn[EXTI_Line] &= ~EXTI_PinSource; - GPIO_INTR_EN(EXTI_Line) = ExtiEn[EXTI_Line]; - break; - - case EXTI_Trigger_Rising: - ExtiTrig[EXTI_Line] &= ~EXTI_PinSource; - TempExtiTrig &= ~EXTI_PinSource; - ExtiRisingFallingTrig[EXTI_Line] &= ~EXTI_PinSource; - GPIO_TRIG_MODE(EXTI_Line) = TempExtiTrig; - ExtiEn[EXTI_Line] |= EXTI_PinSource; - GPIO_INTR_EN(EXTI_Line) = ExtiEn[EXTI_Line]; - break; - - case EXTI_Trigger_Falling: - ExtiTrig[EXTI_Line] |= EXTI_PinSource; - TempExtiTrig |= EXTI_PinSource; - ExtiRisingFallingTrig[EXTI_Line] &= ~EXTI_PinSource; - GPIO_TRIG_MODE(EXTI_Line) = TempExtiTrig; - ExtiEn[EXTI_Line] |= EXTI_PinSource; - GPIO_INTR_EN(EXTI_Line) = ExtiEn[EXTI_Line]; - break; - - case EXTI_Trigger_Rising_Falling: - ExtiTrig[EXTI_Line] &= ~EXTI_PinSource; - for (i = 0; i < GPIO_PIN_NUM; i++) - { - if (EXTI_PinSource & 1 << i) - { - if (GPIO_ReadInputDataBit((GPIO_TypeDef)EXTI_Line, 1 << i)) - { - TempExtiTrig |= 1 << i; - } - else - { - TempExtiTrig &= ~(1 << i); - } - } - } - ExtiRisingFallingTrig[EXTI_Line] |= EXTI_PinSource; - GPIO_TRIG_MODE(EXTI_Line) = TempExtiTrig; - ExtiEn[EXTI_Line] |= EXTI_PinSource; - GPIO_INTR_EN(EXTI_Line) = ExtiEn[EXTI_Line]; - break; - - default: - break; - } + for (i = 0; i < EXIT_Num; i++) + { + if (GPIO_INTR_EN(i) == 0x0000) + { + ExtiEn[i] = 0; + ExtiTrig[i] = 0; + ExtiRisingFallingTrig[i] = 0; + ExtiStatus[i] = 0; + } + } + + switch (EXTI_Trigger) + { + case EXTI_Trigger_Off: + ExtiEn[EXTI_Line] &= ~EXTI_PinSource; + GPIO_INTR_EN(EXTI_Line) = ExtiEn[EXTI_Line]; + break; + + case EXTI_Trigger_Rising: + ExtiTrig[EXTI_Line] &= ~EXTI_PinSource; + TempExtiTrig &= ~EXTI_PinSource; + ExtiRisingFallingTrig[EXTI_Line] &= ~EXTI_PinSource; + GPIO_TRIG_MODE(EXTI_Line) = TempExtiTrig; + ExtiEn[EXTI_Line] |= EXTI_PinSource; + GPIO_INTR_EN(EXTI_Line) = ExtiEn[EXTI_Line]; + break; + + case EXTI_Trigger_Falling: + ExtiTrig[EXTI_Line] |= EXTI_PinSource; + TempExtiTrig |= EXTI_PinSource; + ExtiRisingFallingTrig[EXTI_Line] &= ~EXTI_PinSource; + GPIO_TRIG_MODE(EXTI_Line) = TempExtiTrig; + ExtiEn[EXTI_Line] |= EXTI_PinSource; + GPIO_INTR_EN(EXTI_Line) = ExtiEn[EXTI_Line]; + break; + + case EXTI_Trigger_Rising_Falling: + ExtiTrig[EXTI_Line] &= ~EXTI_PinSource; + for (i = 0; i < GPIO_PIN_NUM; i++) + { + if (EXTI_PinSource & 1 << i) + { + if (GPIO_ReadInputDataBit((GPIO_TypeDef)EXTI_Line, 1 << i)) + { + TempExtiTrig |= 1 << i; + } + else + { + TempExtiTrig &= ~(1 << i); + } + } + } + ExtiRisingFallingTrig[EXTI_Line] |= EXTI_PinSource; + GPIO_TRIG_MODE(EXTI_Line) = TempExtiTrig; + ExtiEn[EXTI_Line] |= EXTI_PinSource; + GPIO_INTR_EN(EXTI_Line) = ExtiEn[EXTI_Line]; + break; + + default: + break; + } } -void GPIO_IRQHandler() +void GPIO_IRQHandler() { - disable_intr(INTR_GPIO); + disable_intr(INTR_GPIO); - int i, j; + int i, j; - for (i = 0; i < EXIT_Num; i++) - { - for (j=0; j < EXIT_Pin_Num; j++) - { - if ((ExtiEn[i] & (1 << j)))//Check whether gpio i interrupt are turned on - { - if ((((~(GPIO_TRIG_MODE(i))) & (1 << j)) >> j) == GPIO_ReadInputDataBit((GPIO_TypeDef) i, 1 << j))//Check for interruptions - { - - if(ExtiRisingFallingTrig[i] & (1<> j) == GPIO_ReadInputDataBit((GPIO_TypeDef) i, 1 << j))//Check for interruptions + { + + if (ExtiRisingFallingTrig[i] & (1 << j)) + { + ExtiStatus[i] |= (1 << j); + switch (i) + { + case EXTI_Line0: + EXTI0_IRQHandler(); + break; + + case EXTI_Line1: + EXTI1_IRQHandler(); + break; + + case EXTI_Line2: + EXTI2_IRQHandler(); + break; + + default: + break; + } + EXTI_ClearITPendingBit(i, 1 << j); + } + else + { + if ((ExtiTrig[i] & (1 << j)) == (GPIO_TRIG_MODE(i) & (1 << j))) + { + ExtiStatus[i] |= (1 << j); + switch (i) + { + case EXTI_Line0: + EXTI0_IRQHandler(); + break; + + case EXTI_Line1: + EXTI1_IRQHandler(); + break; + + case EXTI_Line2: + EXTI2_IRQHandler(); + break; + + default: + break; + } + } + EXTI_ClearITPendingBit(i, 1 << j); + } + } + } + } + } + enable_intr(INTR_GPIO); } Index: yc_gpio.h =================================================================== --- /YC3121_SDK/fw/sdk/yc_gpio.h (revision 669) +++ /YC3121_SDK/fw/sdk/yc_gpio.h (working copy) @@ -5,23 +5,23 @@ Date : 2019/12/03 Description : gpio encapsulation. */ - + #ifndef __YC_GPIO_H__ #define __YC_GPIO_H__ - + #include "yc3121.h" -/** - * @brief Configuration Mode enumeration +/** + * @brief Configuration Mode enumeration */ typedef enum -{ - GPIO_Mode_IN_FLOATING = 0x01, - GPIO_Mode_IPU = 0x02, - GPIO_Mode_IPD = 0x03, - GPIO_Mode_AIN = 0x04, - GPIO_Mode_Out_PP = 0x05 /*!< analog signal mode */ -}GPIO_ModeTypeDef; +{ + GPIO_Mode_IN_FLOATING = 0x01, + GPIO_Mode_IPU = 0x02, + GPIO_Mode_IPD = 0x03, + GPIO_Mode_AIN = 0x04, + GPIO_Mode_Out_PP = 0x05 /*!< analog signal mode */ +} GPIO_ModeTypeDef; #define IS_GPIO_MODE(mode) (((mode) == GPIO_Mode_IN_FLOATING)||\ ((mode) == GPIO_Mode_IPU)||\ @@ -29,78 +29,78 @@ ((mode)==GPIO_Mode_Out_PP)||\ ((mode)==GPIO_Mode_AIN)) -/** - * @brief Bit_SET and Bit_RESET enumeration +/** + * @brief Bit_SET and Bit_RESET enumeration */ typedef enum -{ - Bit_RESET = 0, - Bit_SET -}BitAction; +{ + Bit_RESET = 0, + Bit_SET +} BitAction; -/** +/** * @brief gpio output enumeration - */ -typedef enum + */ +typedef enum { - OutputLow = 0, - OutputHigh = 1 -}GPIO_OutputTypeDef; + OutputLow = 0, + OutputHigh = 1 +} GPIO_OutputTypeDef; #define IS_GPIO_WAKE_MODE(MODE) (((MODE) == GPIO_WakeMode_Now) || \ ((MODE) == GPIO_WakeMode_AfterGlitch)) -/** - * @brief GPIO function enumeration +/** + * @brief GPIO function enumeration */ typedef enum { - INPUT = GPCFG_INPUT, - QSPI_NCS = GPCFG_QSPI_NCS, - QSPI_SCK = GPCFG_QSPI_SCK , - QSPI_IO0 = GPCFG_QSPI_IO0, - QSPI_IO1 = GPCFG_QSPI_IO1, - QSPI_IO2 = GPCFG_QSPI_IO2, - QSPI_IO3 = GPCFG_QSPI_IO3, - UART0_TXD = GPCFG_UART0_TXD, - UART0_RXD = GPCFG_UART0_RXD, - UART0_RTS = GPCFG_UART0_RTS, - UART0_CTS = GPCFG_UART0_CTS, - UART1_TXD = GPCFG_UART1_TXD, - UART1_RXD = GPCFG_UART1_RXD, - UART1_RTS = GPCFG_UART1_RTS, - UART1_CTS = GPCFG_UART1_CTS, - PWM_OUT0 = GPCFG_PWM_OUT0, - PWM_OUT1 = GPCFG_PWM_OUT1, - PWM_OUT2 = GPCFG_PWM_OUT2, - PWM_OUT3 = GPCFG_PWM_OUT3, - PWM_OUT4 = GPCFG_PWM_OUT4, - PWM_OUT5 = GPCFG_PWM_OUT5, - SPID0_NCS = GPCFG_SPID0_NCS, - SPID0_SCK = GPCFG_SPID0_SCK, - SPID0_MOSI = GPCFG_SPID0_MOSI, - SPID0_SDIO = GPCFG_SPID0_SDIO, - SPID0_MISO = GPCFG_SPID0_MISO, - SPID0_NCSIN = GPCFG_SPID0_NCSIN, - SPID0_SCKIN = GPCFG_SPID0_SCKIN, - SPID1_NCS = GPCFG_SPID1_NCS, - SPID1_SCK = GPCFG_SPID1_SCK, - SPID1_MOSI = GPCFG_SPID1_MOSI, - SPID1_SDIO = GPCFG_SPID1_SDIO, - SPID1_MISO = GPCFG_SPID1_MISO, - SPID1_NCSIN = GPCFG_SPID1_NCSIN, - SPID1_SCKIN = GPCFG_SPID1_SCKIN, - SCI7816_IO = GPCFG_SCI7816_IO, - IIC_SCL = GPCFG_IIC_SCL, - IIC_SDA = GPCFG_IIC_SDA, - JTAG_SWCLK = GPCFG_JTAG_SWCLK, - JTAG_SWDAT = GPCFG_JTAG_SWDAT, - OUTPUT_LOW = GPCFG_OUTPUT_LOW, - OUTPUT_HIGH = GPCFG_OUTPUT_HIGH, - PULL_UP = GPCFG_PU, - PULL_DOWN = GPCFG_PD, - ANALOG = GPCFG_ANALOG -}GPIO_FunTypeDef; + INPUT = GPCFG_INPUT, + QSPI_NCS = GPCFG_QSPI_NCS, + QSPI_SCK = GPCFG_QSPI_SCK, + QSPI_IO0 = GPCFG_QSPI_IO0, + QSPI_IO1 = GPCFG_QSPI_IO1, + QSPI_IO2 = GPCFG_QSPI_IO2, + QSPI_IO3 = GPCFG_QSPI_IO3, + UART0_TXD = GPCFG_UART0_TXD, + UART0_RXD = GPCFG_UART0_RXD, + UART0_RTS = GPCFG_UART0_RTS, + UART0_CTS = GPCFG_UART0_CTS, + UART1_TXD = GPCFG_UART1_TXD, + UART1_RXD = GPCFG_UART1_RXD, + UART1_RTS = GPCFG_UART1_RTS, + UART1_CTS = GPCFG_UART1_CTS, + PWM_OUT0 = GPCFG_PWM_OUT0, + PWM_OUT1 = GPCFG_PWM_OUT1, + PWM_OUT2 = GPCFG_PWM_OUT2, + PWM_OUT3 = GPCFG_PWM_OUT3, + PWM_OUT4 = GPCFG_PWM_OUT4, + PWM_OUT5 = GPCFG_PWM_OUT5, + SPID0_NCS = GPCFG_SPID0_NCS, + SPID0_SCK = GPCFG_SPID0_SCK, + SPID0_MOSI = GPCFG_SPID0_MOSI, + SPID0_SDIO = GPCFG_SPID0_SDIO, + SPID0_MISO = GPCFG_SPID0_MISO, + SPID0_NCSIN = GPCFG_SPID0_NCSIN, + SPID0_SCKIN = GPCFG_SPID0_SCKIN, + SPID1_NCS = GPCFG_SPID1_NCS, + SPID1_SCK = GPCFG_SPID1_SCK, + SPID1_MOSI = GPCFG_SPID1_MOSI, + SPID1_SDIO = GPCFG_SPID1_SDIO, + SPID1_MISO = GPCFG_SPID1_MISO, + SPID1_NCSIN = GPCFG_SPID1_NCSIN, + SPID1_SCKIN = GPCFG_SPID1_SCKIN, + SCI7816_IO = GPCFG_SCI7816_IO, + IIC_SCL = GPCFG_IIC_SCL, + IIC_SDA = GPCFG_IIC_SDA, + JTAG_SWCLK = GPCFG_JTAG_SWCLK, + JTAG_SWDAT = GPCFG_JTAG_SWDAT, + OUTPUT_LOW = GPCFG_OUTPUT_LOW, + OUTPUT_HIGH = GPCFG_OUTPUT_HIGH, + PULL_UP = GPCFG_PU, + PULL_DOWN = GPCFG_PD, + ANALOG = GPCFG_ANALOG +} GPIO_FunTypeDef; #define GPIO_Pin_0 ((uint16_t)0x0001) /*!< Pin 0 selected */ #define GPIO_Pin_1 ((uint16_t)0x0002) /*!< Pin 1 selected */ @@ -139,26 +139,26 @@ ((PIN) == GPIO_Pin_14) || \ ((PIN) == GPIO_Pin_15)) -/** - * @brief GPIO group enumeration +/** + * @brief GPIO group enumeration */ typedef enum { - GPIOA = 0, - GPIOB, - GPIOC -}GPIO_TypeDef; + GPIOA = 0, + GPIOB, + GPIOC +} GPIO_TypeDef; #define ISGPIOGROUP(groupx) (groupxGPIO_Pin)); - _ASSERT(IS_GPIO_MODE(GPIO_InitStruct->GPIO_Mode)); - - int i; + _ASSERT(ISGPIOGROUP(GPIOx)); + _ASSERT(IS_GPIO_PIN(GPIO_InitStruct->GPIO_Pin)); + _ASSERT(IS_GPIO_MODE(GPIO_InitStruct->GPIO_Mode)); + + int i; if(GPIOx==GPIOC && GPIO_InitStruct->GPIO_Pin==GPIO_Pin_0) { @@ -44,7 +44,7 @@ value &= ~(1<<17); lpm_bt_write(LPMBT_CONTROL1, value); } - + switch (GPIO_InitStruct->GPIO_Mode) { case GPIO_Mode_IN_FLOATING: @@ -55,171 +55,172 @@ } break; - case GPIO_Mode_IPU: - for (i = 0; i < GPIO_PIN_NUM; i++) - { - if (GPIO_InitStruct->GPIO_Pin & 1 << i) - GPIO_CONFIG(GPIOx*GPIO_PIN_NUM + i) = 0x40; - } - break; - - case GPIO_Mode_IPD: - for (i = 0; i < GPIO_PIN_NUM; i++) - { - if (GPIO_InitStruct->GPIO_Pin & 1 << i) - GPIO_CONFIG(GPIOx*GPIO_PIN_NUM + i) = 0x80; - } - break; - - case GPIO_Mode_AIN: - for (i = 0; i < GPIO_PIN_NUM; i++) - { - if (GPIO_InitStruct->GPIO_Pin & 1 << i) - GPIO_CONFIG(GPIOx*GPIO_PIN_NUM + i) = 0xC0; - } - break; - - case GPIO_Mode_Out_PP: - for (i = 0; i < GPIO_PIN_NUM; i++) - { - if (GPIO_InitStruct->GPIO_Pin & 1 << i) - GPIO_CONFIG(GPIOx*GPIO_PIN_NUM + i) = 0x3E; - } - break; - - default: break; - } + case GPIO_Mode_IPU: + for (i = 0; i < GPIO_PIN_NUM; i++) + { + if (GPIO_InitStruct->GPIO_Pin & 1 << i) + GPIO_CONFIG(GPIOx * GPIO_PIN_NUM + i) = 0x40; + } + break; + + case GPIO_Mode_IPD: + for (i = 0; i < GPIO_PIN_NUM; i++) + { + if (GPIO_InitStruct->GPIO_Pin & 1 << i) + GPIO_CONFIG(GPIOx * GPIO_PIN_NUM + i) = 0x80; + } + break; + + case GPIO_Mode_AIN: + for (i = 0; i < GPIO_PIN_NUM; i++) + { + if (GPIO_InitStruct->GPIO_Pin & 1 << i) + GPIO_CONFIG(GPIOx * GPIO_PIN_NUM + i) = 0xC0; + } + break; + + case GPIO_Mode_Out_PP: + for (i = 0; i < GPIO_PIN_NUM; i++) + { + if (GPIO_InitStruct->GPIO_Pin & 1 << i) + GPIO_CONFIG(GPIOx * GPIO_PIN_NUM + i) = 0x3E; + } + break; + + default: + break; + } } void GPIO_PullUpCmd(GPIO_TypeDef GPIOx, uint16_t GPIO_Pin, FunctionalState NewState) { - _ASSERT(ISGPIOGROUP(GPIOx)); - _ASSERT(IS_GET_GPIO_PIN(GPIO_Pin)); - - int i; - - for (i = 0; i < GPIO_PIN_NUM; i++) - { - if (GPIO_Pin & 1 << i) - { - if (NewState == ENABLE) - { - GPIO_CONFIG(GPIOx*GPIO_PIN_NUM + i) |= 1 << 6; - } - else if(NewState==DISABLE) - { - GPIO_CONFIG(GPIOx*GPIO_PIN_NUM + i) &= ~(1 << 6); - } - } - } + _ASSERT(ISGPIOGROUP(GPIOx)); + _ASSERT(IS_GET_GPIO_PIN(GPIO_Pin)); + + int i; + + for (i = 0; i < GPIO_PIN_NUM; i++) + { + if (GPIO_Pin & 1 << i) + { + if (NewState == ENABLE) + { + GPIO_CONFIG(GPIOx * GPIO_PIN_NUM + i) |= 1 << 6; + } + else if (NewState == DISABLE) + { + GPIO_CONFIG(GPIOx * GPIO_PIN_NUM + i) &= ~(1 << 6); + } + } + } } uint16_t GPIO_ReadInputData(GPIO_TypeDef GPIOx) { - _ASSERT(ISGPIOGROUP(GPIOx)); - - return GPIO_IN(GPIOx); + _ASSERT(ISGPIOGROUP(GPIOx)); + + return GPIO_IN(GPIOx); } uint8_t GPIO_ReadInputDataBit(GPIO_TypeDef GPIOx, uint16_t GPIO_Pin) { - _ASSERT(ISGPIOGROUP(GPIOx)); - _ASSERT(IS_GET_GPIO_PIN(GPIO_Pin)); - - if (GPIO_IN(GPIOx) & GPIO_Pin) - { - return (uint8_t)0x01; - } - else - { - return (uint8_t)0x00; - } + _ASSERT(ISGPIOGROUP(GPIOx)); + _ASSERT(IS_GET_GPIO_PIN(GPIO_Pin)); + + if (GPIO_IN(GPIOx) & GPIO_Pin) + { + return (uint8_t)0x01; + } + else + { + return (uint8_t)0x00; + } } uint16_t GPIO_ReadOutputData(GPIO_TypeDef GPIOx) { - _ASSERT(ISGPIOGROUP(GPIOx)); - - return GPIO_IN(GPIOx); + _ASSERT(ISGPIOGROUP(GPIOx)); + + return GPIO_IN(GPIOx); } -uint8_t GPIO_ReadOutputDataBit(GPIO_TypeDef GPIOx,uint16_t GPIO_Pin) +uint8_t GPIO_ReadOutputDataBit(GPIO_TypeDef GPIOx, uint16_t GPIO_Pin) { - _ASSERT(ISGPIOGROUP(GPIOx)); - _ASSERT(IS_GET_GPIO_PIN(GPIO_Pin)); - - if(GPIO_IN(GPIOx) & GPIO_Pin) - { - return (uint8_t)0x01; - } - else - { - return (uint8_t)0x00; - } + _ASSERT(ISGPIOGROUP(GPIOx)); + _ASSERT(IS_GET_GPIO_PIN(GPIO_Pin)); + + if (GPIO_IN(GPIOx) & GPIO_Pin) + { + return (uint8_t)0x01; + } + else + { + return (uint8_t)0x00; + } } void GPIO_ResetBits(GPIO_TypeDef GPIOx, uint16_t GPIO_Pin) { - _ASSERT(ISGPIOGROUP(GPIOx)); - _ASSERT(IS_GET_GPIO_PIN(GPIO_Pin)); - - int i; - uint8_t Temp; - - for(i = 0; i < GPIO_PIN_NUM; i++) - { - if (GPIO_Pin & 1 << i) - { - Temp = GPIO_CONFIG(GPIOx*GPIO_PIN_NUM + i); - Temp |= 0x3F; //00111111 - Temp &= 0xFE; //11111110 - GPIO_CONFIG(GPIOx*GPIO_PIN_NUM + i) = Temp; - } - } + _ASSERT(ISGPIOGROUP(GPIOx)); + _ASSERT(IS_GET_GPIO_PIN(GPIO_Pin)); + + int i; + uint8_t Temp; + + for (i = 0; i < GPIO_PIN_NUM; i++) + { + if (GPIO_Pin & 1 << i) + { + Temp = GPIO_CONFIG(GPIOx * GPIO_PIN_NUM + i); + Temp |= 0x3F; //00111111 + Temp &= 0xFE; //11111110 + GPIO_CONFIG(GPIOx * GPIO_PIN_NUM + i) = Temp; + } + } } void GPIO_SetBits(GPIO_TypeDef GPIOx, uint16_t GPIO_Pin) { - _ASSERT(ISGPIOGROUP(GPIOx)); - _ASSERT(IS_GET_GPIO_PIN(GPIO_Pin)); - - int i; - - for(i = 0; i < GPIO_PIN_NUM; i++) - { - if(GPIO_Pin & 1 << i) - GPIO_CONFIG(GPIOx*GPIO_PIN_NUM + i) |= 0x3F; //00111111 - } + _ASSERT(ISGPIOGROUP(GPIOx)); + _ASSERT(IS_GET_GPIO_PIN(GPIO_Pin)); + + int i; + + for (i = 0; i < GPIO_PIN_NUM; i++) + { + if (GPIO_Pin & 1 << i) + GPIO_CONFIG(GPIOx * GPIO_PIN_NUM + i) |= 0x3F; //00111111 + } } -void GPIO_StructInit(GPIO_InitTypeDef* GPIO_InitStruct) +void GPIO_StructInit(GPIO_InitTypeDef *GPIO_InitStruct) { - GPIO_InitStruct->GPIO_Pin = GPIO_Pin_All; - GPIO_InitStruct->GPIO_Mode = GPIO_Mode_IN_FLOATING; + GPIO_InitStruct->GPIO_Pin = GPIO_Pin_All; + GPIO_InitStruct->GPIO_Mode = GPIO_Mode_IN_FLOATING; } void GPIO_Write(GPIO_TypeDef GPIOx, uint16_t value) { - _ASSERT(ISGPIOGROUP(GPIOx)); - - int i; - - for(i = 0; i < GPIO_PIN_NUM; i++) - { - if (BIT_GET(value, i)) - GPIO_SetBits(GPIOx, 1 << i); - else - GPIO_ResetBits(GPIOx, 1 << i); - } + _ASSERT(ISGPIOGROUP(GPIOx)); + + int i; + + for (i = 0; i < GPIO_PIN_NUM; i++) + { + if (BIT_GET(value, i)) + GPIO_SetBits(GPIOx, 1 << i); + else + GPIO_ResetBits(GPIOx, 1 << i); + } } void GPIO_WriteBit(GPIO_TypeDef GPIOx, uint16_t GPIO_Pin, BitAction BitVal) { - _ASSERT(ISGPIOGROUP(GPIOx)); - _ASSERT(IS_GET_GPIO_PIN(GPIO_Pin)); - - if (BitVal == Bit_SET) - GPIO_SetBits(GPIOx, GPIO_Pin); - else if(BitVal == Bit_RESET) - GPIO_ResetBits(GPIOx, GPIO_Pin); + _ASSERT(ISGPIOGROUP(GPIOx)); + _ASSERT(IS_GET_GPIO_PIN(GPIO_Pin)); + + if (BitVal == Bit_SET) + GPIO_SetBits(GPIOx, GPIO_Pin); + else if (BitVal == Bit_RESET) + GPIO_ResetBits(GPIOx, GPIO_Pin); } Index: yc_iic.h =================================================================== --- /YC3121_SDK/fw/sdk/yc_iic.h (revision 669) +++ /YC3121_SDK/fw/sdk/yc_iic.h (working copy) @@ -11,31 +11,32 @@ #include "yc3121.h" -/** +/** *@brief IIC Core parameters struct */ -typedef struct{ - uint8_t scll; /*!< Specifies the Clock Pulse Width Low. */ - uint8_t sclh; /*!< Specifies the Clock Pulse Width High. */ - uint8_t stsu; /*!< Specifies the Start Setup Time. */ - uint8_t sthd; /*!< Specifies the Start Hold Time. */ - uint8_t sosu; /*!< Specifies the Stop Setup Time. */ - uint8_t dtsu; /*!< Specifies the Data Setup Time. */ - uint8_t dthd; /*!< Specifies the Data Hold Time. */ -}IIC_InitTypeDef; +typedef struct +{ + uint8_t scll; /*!< Specifies the Clock Pulse Width Low. */ + uint8_t sclh; /*!< Specifies the Clock Pulse Width High. */ + uint8_t stsu; /*!< Specifies the Start Setup Time. */ + uint8_t sthd; /*!< Specifies the Start Hold Time. */ + uint8_t sosu; /*!< Specifies the Stop Setup Time. */ + uint8_t dtsu; /*!< Specifies the Data Setup Time. */ + uint8_t dthd; /*!< Specifies the Data Hold Time. */ +} IIC_InitTypeDef; /** * @brief Initializes the IIC peripheral according to the specified * parameters in the IIC_InitTypeDef. * @param IIC_InitStruct: pointer to a IIC_InitTypeDef structure - * that contains the configuration information for the specified IIC + * that contains the configuration information for the specified IIC * peripheral. * @retval None */ -void IIC_Init(IIC_InitTypeDef* IIC_InitStruct); +void IIC_Init(IIC_InitTypeDef *IIC_InitStruct); /** - * @brief Write slave devices. + * @brief Write slave devices. * @param Src: pointer to the buffer that contains the data you want to send. * @param len: the length of send data * @note After writting slave device, must delay a period of time before reading slave device. @@ -44,7 +45,7 @@ void IIC_SendData(uint8_t *Src, uint16_t len); /** - * @brief Read slave devices. + * @brief Read slave devices. * @param Src: pointer to the buffer that contains the data you want to send. * @param len: the length of send data * @param Dest: pointer to the buffer that contains the data received from slaver. Index: yc_iic.c =================================================================== --- /YC3121_SDK/fw/sdk/yc_iic.c (revision 669) +++ /YC3121_SDK/fw/sdk/yc_iic.c (working copy) @@ -17,39 +17,39 @@ #define IIC_DTSU_BIT 8 #define IIC_DTHD_BIT 16 -void IIC_Init(IIC_InitTypeDef* IIC_InitStruct) +void IIC_Init(IIC_InitTypeDef *IIC_InitStruct) { - IICD_DELAY = (IIC_InitStruct->sthd << IIC_STHD_BIT) | (IIC_InitStruct->stsu << IIC_STSU_BIT) | (IIC_InitStruct->sclh << IIC_SCLH_BIT) | (IIC_InitStruct->scll << IIC_SCLL_BIT); - IICD_CTRL = (IIC_InitStruct->dthd << IIC_DTHD_BIT) | (IIC_InitStruct->dtsu << IIC_DTSU_BIT) | (IIC_InitStruct->sosu << IIC_SOSU_BIT); + IICD_DELAY = (IIC_InitStruct->sthd << IIC_STHD_BIT) | (IIC_InitStruct->stsu << IIC_STSU_BIT) | (IIC_InitStruct->sclh << IIC_SCLH_BIT) | (IIC_InitStruct->scll << IIC_SCLL_BIT); + IICD_CTRL = (IIC_InitStruct->dthd << IIC_DTHD_BIT) | (IIC_InitStruct->dtsu << IIC_DTSU_BIT) | (IIC_InitStruct->sosu << IIC_SOSU_BIT); } void IIC_SendData(uint8_t *Src, uint16_t len) { - IICD_CTRL &= ~(1 << IIC_RESTART_BIT); + IICD_CTRL &= ~(1 << IIC_RESTART_BIT); - DMA_START(DMACH_IICD) |= (1 << DMA_RESET_BIT); - DMA_START(DMACH_IICD) &= ~(1 << DMA_RESET_BIT); - DMA_SRC_ADDR(DMACH_IICD) = (int)Src; - DMA_LEN(DMACH_IICD) = len << 16; - DMA_START(DMACH_IICD) = (1 << DMA_START_BIT); - - while(!(DMA_STATUS(DMACH_IICD) & 1)) - { - } + DMA_START(DMACH_IICD) |= (1 << DMA_RESET_BIT); + DMA_START(DMACH_IICD) &= ~(1 << DMA_RESET_BIT); + DMA_SRC_ADDR(DMACH_IICD) = (int)Src; + DMA_LEN(DMACH_IICD) = len << 16; + DMA_START(DMACH_IICD) = (1 << DMA_START_BIT); + + while (!(DMA_STATUS(DMACH_IICD) & 1)) + { + } } void IIC_ReceiveData(uint8_t *Src, uint16_t Srclen, uint8_t *Dest, uint16_t Destlen) { - IICD_CTRL |= 1 << IIC_RESTART_BIT; + IICD_CTRL |= 1 << IIC_RESTART_BIT; - DMA_START(DMACH_IICD) |= (1 << DMA_RESET_BIT); - DMA_START(DMACH_IICD) &= ~(1 << DMA_RESET_BIT); - DMA_SRC_ADDR(DMACH_IICD) = (int)Src; - DMA_DEST_ADDR(DMACH_IICD) = (int)Dest; - DMA_LEN(DMACH_IICD) = Srclen << 16 | Destlen; - DMA_START(DMACH_IICD) = (1 << DMA_START_BIT); - - while(!(DMA_STATUS(DMACH_IICD) & 1)) - { - } + DMA_START(DMACH_IICD) |= (1 << DMA_RESET_BIT); + DMA_START(DMACH_IICD) &= ~(1 << DMA_RESET_BIT); + DMA_SRC_ADDR(DMACH_IICD) = (int)Src; + DMA_DEST_ADDR(DMACH_IICD) = (int)Dest; + DMA_LEN(DMACH_IICD) = Srclen << 16 | Destlen; + DMA_START(DMACH_IICD) = (1 << DMA_START_BIT); + + while (!(DMA_STATUS(DMACH_IICD) & 1)) + { + } } Index: yc_lcd.h =================================================================== --- /YC3121_SDK/fw/sdk/yc_lcd.h (revision 669) +++ /YC3121_SDK/fw/sdk/yc_lcd.h (working copy) @@ -15,30 +15,32 @@ #include "yc_gpio.h" #include "yc_spi.h" #include "yc_timer.h" +#include "board_config.h" #define LCD_RS_CMD 0x00 #define LCD_RS_DATA 0x01 -typedef struct{ - SPIx_TypeDef SPIx; - uint16_t IO_LCD_SDA_PIN; - GPIO_TypeDef IO_LCD_SDA_Port; - uint16_t IO_LCD_SCL_PIN; - GPIO_TypeDef IO_LCD_SCL_Port; - uint16_t IO_LCD_A0_PIN; - GPIO_TypeDef IO_LCD_A0_Port; - uint16_t IO_LCD_RES_PIN; - GPIO_TypeDef IO_LCD_RES_Port; - uint16_t IO_LCD_CS_PIN; - GPIO_TypeDef IO_LCD_CS_Port; - uint16_t IO_LCD_BL_PIN; - GPIO_TypeDef IO_LCD_BL_Port; -}LCD_InitTypedef; +typedef struct +{ + SPIx_TypeDef SPIx; + uint16_t IO_LCD_SDA_PIN; + GPIO_TypeDef IO_LCD_SDA_Port; + uint16_t IO_LCD_SCL_PIN; + GPIO_TypeDef IO_LCD_SCL_Port; + uint16_t IO_LCD_A0_PIN; + GPIO_TypeDef IO_LCD_A0_Port; + uint16_t IO_LCD_RES_PIN; + GPIO_TypeDef IO_LCD_RES_Port; + uint16_t IO_LCD_CS_PIN; + GPIO_TypeDef IO_LCD_CS_Port; + uint16_t IO_LCD_BL_PIN; + GPIO_TypeDef IO_LCD_BL_Port; +} LCD_InitTypedef; /** * @brief lcd io initialize */ - void lcd_io_init(LCD_InitTypedef* LCD_InitStruct); +void lcd_io_init(LCD_InitTypedef *LCD_InitStruct); /** * @brief MCU sends cmd to LCD via SPI @@ -59,7 +61,7 @@ * len: number of content sent * cmd: send type. */ -void write_bytes_lcd(unsigned char* pdata, unsigned char len, unsigned char cmd); +void write_bytes_lcd(unsigned char *pdata, unsigned char len, unsigned char cmd); /** * @brief clear screen Index: yc_lcd.c =================================================================== --- /YC3121_SDK/fw/sdk/yc_lcd.c (revision 669) +++ /YC3121_SDK/fw/sdk/yc_lcd.c (working copy) @@ -7,184 +7,183 @@ */ #include "yc_lcd.h" - -SPIx_TypeDef LCDSPI = SPI0; -uint16_t LCD_SDA_PIN = GPIO_Pin_2; -uint16_t LCD_SCL_PIN = GPIO_Pin_3; -uint16_t LCD_A0_PIN = GPIO_Pin_6; -uint16_t LCD_RES_PIN = GPIO_Pin_5; -uint16_t LCD_CS_PIN = GPIO_Pin_4; - -GPIO_TypeDef LCD_SDA_Port = GPIOA; -GPIO_TypeDef LCD_SCL_Port = GPIOA; -GPIO_TypeDef LCD_A0_Port = GPIOA; -GPIO_TypeDef LCD_RES_Port = GPIOA; -GPIO_TypeDef LCD_CS_Port = GPIOA; +SPIx_TypeDef LCDSPI; +uint16_t LCD_SDA_PIN; +uint16_t LCD_SCL_PIN; +uint16_t LCD_A0_PIN ; +uint16_t LCD_RES_PIN; +uint16_t LCD_CS_PIN ; + +GPIO_TypeDef LCD_SDA_Port; +GPIO_TypeDef LCD_SCL_Port; +GPIO_TypeDef LCD_A0_Port; +GPIO_TypeDef LCD_RES_Port; +GPIO_TypeDef LCD_CS_Port; uint8_t LCD_BL_PIN = GPIO_Pin_7; GPIO_TypeDef LCD_BL_Port = GPIOA; - void lcd_io_init(LCD_InitTypedef* LCD_InitStruct) +void lcd_io_init(LCD_InitTypedef *LCD_InitStruct) { - _ASSERT(NULL != LCD_InitStruct); - - SPI_InitTypeDef SPI_InitStruct; - - LCDSPI = LCD_InitStruct->SPIx; - - LCD_SDA_PIN = LCD_InitStruct->IO_LCD_SDA_PIN; - LCD_SCL_PIN = LCD_InitStruct->IO_LCD_SCL_PIN; - LCD_A0_PIN = LCD_InitStruct->IO_LCD_A0_PIN; - LCD_RES_PIN = LCD_InitStruct->IO_LCD_RES_PIN; - LCD_CS_PIN = LCD_InitStruct->IO_LCD_CS_PIN; - LCD_BL_PIN = LCD_InitStruct->IO_LCD_BL_PIN; - - LCD_SDA_Port = LCD_InitStruct->IO_LCD_SDA_Port; - LCD_SCL_Port = LCD_InitStruct->IO_LCD_SCL_Port; - LCD_A0_Port = LCD_InitStruct->IO_LCD_A0_Port; - LCD_RES_Port = LCD_InitStruct->IO_LCD_RES_Port; - LCD_CS_Port = LCD_InitStruct->IO_LCD_CS_Port; - LCD_BL_Port = LCD_InitStruct->IO_LCD_BL_Port; - - SPI_InitStruct.BaudRatePrescaler = SPI_BaudRatePrescaler_2; - SPI_InitStruct.CPHA = SPI_CPHA_First_Edge; - SPI_InitStruct.CPOL = SPI_CPOL_Low; - SPI_InitStruct.Mode = SPI_Mode_Master; - SPI_InitStruct.RW_Delay = 33; - - GPIO_Config(LCD_SCL_Port, LCD_SCL_PIN, SPID0_SCK); - GPIO_Config(LCD_CS_Port, LCD_CS_PIN, SPID0_NCS); - GPIO_Config(LCD_SDA_Port, LCD_SDA_PIN, SPID0_MOSI); - GPIO_Config(LCD_BL_Port, LCD_BL_PIN, OUTPUT_LOW); - SPI_Init(LCDSPI,&SPI_InitStruct); - - GPIO_Config(LCD_A0_Port, LCD_A0_PIN, OUTPUT_HIGH); - GPIO_Config(LCD_RES_Port, LCD_RES_PIN, OUTPUT_HIGH); - delay_ms(20); - GPIO_Config(LCD_RES_Port, LCD_RES_PIN, OUTPUT_LOW); - delay_ms(100); - GPIO_Config(LCD_RES_Port, LCD_RES_PIN, OUTPUT_HIGH); + _ASSERT(NULL != LCD_InitStruct); + + SPI_InitTypeDef SPI_InitStruct; + + LCDSPI = LCD_InitStruct->SPIx; + + LCD_SDA_PIN = LCD_InitStruct->IO_LCD_SDA_PIN; + LCD_SCL_PIN = LCD_InitStruct->IO_LCD_SCL_PIN; + LCD_A0_PIN = LCD_InitStruct->IO_LCD_A0_PIN; + LCD_RES_PIN = LCD_InitStruct->IO_LCD_RES_PIN; + LCD_CS_PIN = LCD_InitStruct->IO_LCD_CS_PIN; + LCD_BL_PIN = LCD_InitStruct->IO_LCD_BL_PIN; + + LCD_SDA_Port = LCD_InitStruct->IO_LCD_SDA_Port; + LCD_SCL_Port = LCD_InitStruct->IO_LCD_SCL_Port; + LCD_A0_Port = LCD_InitStruct->IO_LCD_A0_Port; + LCD_RES_Port = LCD_InitStruct->IO_LCD_RES_Port; + LCD_CS_Port = LCD_InitStruct->IO_LCD_CS_Port; + LCD_BL_Port = LCD_InitStruct->IO_LCD_BL_Port; + + SPI_InitStruct.BaudRatePrescaler = SPI_BaudRatePrescaler_2; + SPI_InitStruct.CPHA = SPI_CPHA_First_Edge; + SPI_InitStruct.CPOL = SPI_CPOL_Low; + SPI_InitStruct.Mode = SPI_Mode_Master; + SPI_InitStruct.RW_Delay = 33; + + GPIO_Config(LCD_SCL_Port, LCD_SCL_PIN, SPID0_SCK); + GPIO_Config(LCD_CS_Port, LCD_CS_PIN, SPID0_NCS); + GPIO_Config(LCD_SDA_Port, LCD_SDA_PIN, SPID0_MOSI); + GPIO_Config(LCD_BL_Port, LCD_BL_PIN, OUTPUT_LOW); + SPI_Init(LCDSPI, &SPI_InitStruct); + + GPIO_Config(LCD_A0_Port, LCD_A0_PIN, OUTPUT_HIGH); + GPIO_Config(LCD_RES_Port, LCD_RES_PIN, OUTPUT_HIGH); + delay_ms(20); + GPIO_Config(LCD_RES_Port, LCD_RES_PIN, OUTPUT_LOW); + delay_ms(100); + GPIO_Config(LCD_RES_Port, LCD_RES_PIN, OUTPUT_HIGH); } static void clr_a0(void) { - GPIO_Config(LCD_A0_Port, LCD_A0_PIN, OUTPUT_LOW); - GPIO_Config(LCD_A0_Port, LCD_A0_PIN, OUTPUT_LOW); - GPIO_Config(LCD_A0_Port, LCD_A0_PIN, OUTPUT_LOW); + GPIO_Config(LCD_A0_Port, LCD_A0_PIN, OUTPUT_LOW); + GPIO_Config(LCD_A0_Port, LCD_A0_PIN, OUTPUT_LOW); + GPIO_Config(LCD_A0_Port, LCD_A0_PIN, OUTPUT_LOW); } static void set_a0(void) { - GPIO_Config(LCD_A0_Port, LCD_A0_PIN, OUTPUT_HIGH); - GPIO_Config(LCD_A0_Port, LCD_A0_PIN, OUTPUT_HIGH); - GPIO_Config(LCD_A0_Port, LCD_A0_PIN, OUTPUT_HIGH); + GPIO_Config(LCD_A0_Port, LCD_A0_PIN, OUTPUT_HIGH); + GPIO_Config(LCD_A0_Port, LCD_A0_PIN, OUTPUT_HIGH); + GPIO_Config(LCD_A0_Port, LCD_A0_PIN, OUTPUT_HIGH); } static void spi_write_data(unsigned char data) { - set_a0(); - SPI_SendData(LCDSPI,data); + set_a0(); + SPI_SendData(LCDSPI, data); } - void spi_write_cmd(unsigned char cmd) +void spi_write_cmd(unsigned char cmd) { - clr_a0(); - SPI_SendData(LCDSPI,cmd); + clr_a0(); + SPI_SendData(LCDSPI, cmd); } void write_byte_lcd(unsigned char data, unsigned char cmd) { - if (LCD_RS_CMD == cmd ) - { - spi_write_cmd(data); - } - else if (LCD_RS_DATA == cmd ) - { - spi_write_data(data); - } -} - -void write_bytes_lcd(unsigned char* pdata, unsigned char len, unsigned char cmd) -{ - unsigned char m = 0; - - if (LCD_RS_CMD == cmd ) - { - for (m = 0; m < len ; m++) - { - spi_write_cmd(pdata[m]); - } - } - else if (LCD_RS_DATA == cmd ) - { - for (m = 0; m < len ; m++) - { - spi_write_data((int)(pdata[m])); - } - } + if (LCD_RS_CMD == cmd) + { + spi_write_cmd(data); + } + else if (LCD_RS_DATA == cmd) + { + spi_write_data(data); + } +} + +void write_bytes_lcd(unsigned char *pdata, unsigned char len, unsigned char cmd) +{ + unsigned char m = 0; + + if (LCD_RS_CMD == cmd) + { + for (m = 0; m < len ; m++) + { + spi_write_cmd(pdata[m]); + } + } + else if (LCD_RS_DATA == cmd) + { + for (m = 0; m < len ; m++) + { + spi_write_data((int)(pdata[m])); + } + } } void clr_screen(void) { - int i, page; - - for (page = 0; page < 8; page++) - { - spi_write_cmd(0x10); - spi_write_cmd(0x00); - spi_write_cmd(page + 0xb0); - for (i = 0; i < 128; i++) - { - spi_write_data(0); - } - } + int i, page; + + for (page = 0; page < 8; page++) + { + spi_write_cmd(0x10); + spi_write_cmd(0x00); + spi_write_cmd(page + 0xb0); + for (i = 0; i < 128; i++) + { + spi_write_data(0); + } + } } void full_screen(void) { - int i,page; - - for (page = 0; page < 8; page++) - { - spi_write_cmd(0x10); - spi_write_cmd(0x00); - spi_write_cmd(page + 0xb0); - for (i = 0; i < 128; i++) - { - spi_write_data(0xFF); - } - } + int i, page; + + for (page = 0; page < 8; page++) + { + spi_write_cmd(0x10); + spi_write_cmd(0x00); + spi_write_cmd(page + 0xb0); + for (i = 0; i < 128; i++) + { + spi_write_data(0xFF); + } + } } void set_xy(unsigned char column, unsigned char page) { - unsigned char cmd[3]; + unsigned char cmd[3]; - cmd[0] = 0xb0 | page; - cmd[1] = 0x10 | (column >> 4); - cmd[2] = 0x00 | (column & 0x0f); - write_bytes_lcd(cmd, 3, LCD_RS_CMD); + cmd[0] = 0xb0 | page; + cmd[1] = 0x10 | (column >> 4); + cmd[2] = 0x00 | (column & 0x0f); + write_bytes_lcd(cmd, 3, LCD_RS_CMD); } void init_lcd(void) { - delay_ms(10); - spi_write_cmd(0xe2);//reset - delay_ms(10); - spi_write_cmd(0xa0);// SEG Direction - delay_ms(10); - spi_write_cmd(0xc8);//COM Direction - delay_ms(10); - spi_write_cmd(0xa2);//Bias Select - delay_ms(10); - spi_write_cmd(0x2f);//Power Control - delay_ms(10); - spi_write_cmd(0x24);//Regulation Ratio - delay_ms(10); - spi_write_cmd(0x81);//Set EV_1 - delay_ms(10); - spi_write_cmd(0x1e);//Set EV_2 - delay_ms(10); - spi_write_cmd(0xaf);//Display ON - delay_ms(10); + delay_ms(10); + spi_write_cmd(0xe2);//reset + delay_ms(10); + spi_write_cmd(0xa0);// SEG Direction + delay_ms(10); + spi_write_cmd(0xc8);//COM Direction + delay_ms(10); + spi_write_cmd(0xa2);//Bias Select + delay_ms(10); + spi_write_cmd(0x2f);//Power Control + delay_ms(10); + spi_write_cmd(0x24);//Regulation Ratio + delay_ms(10); + spi_write_cmd(0x81);//Set EV_1 + delay_ms(10); + spi_write_cmd(0x1e);//Set EV_2 + delay_ms(10); + spi_write_cmd(0xaf);//Display ON + delay_ms(10); } Index: yc_lpm.h =================================================================== --- /YC3121_SDK/fw/sdk/yc_lpm.h (revision 669) +++ /YC3121_SDK/fw/sdk/yc_lpm.h (working copy) @@ -19,17 +19,17 @@ uint32_t lpm_read(volatile int *addr); -void lpm_write(volatile int *addr,uint32_t value); +void lpm_write(volatile int *addr, uint32_t value); -void lpm_bt_write(uint8_t type,uint32_t val); +void lpm_bt_write(uint8_t type, uint32_t val); uint32_t lpm_bt_read(uint8_t type); void lpm_sleep(void); -void setlpmval(volatile int * addr,uint8_t startbit,uint8_t bitwidth,uint32_t val); +void setlpmval(volatile int *addr, uint8_t startbit, uint8_t bitwidth, uint32_t val); -uint32_t readlpmval(volatile int * addr,uint8_t startbit,uint8_t bitwidth); +uint32_t readlpmval(volatile int *addr, uint8_t startbit, uint8_t bitwidth); /** * @brief Drop down all unused GPIO Index: yc_lpm.c =================================================================== --- /YC3121_SDK/fw/sdk/yc_lpm.c (revision 669) +++ /YC3121_SDK/fw/sdk/yc_lpm.c (working copy) @@ -2,183 +2,187 @@ uint32_t lpm_read(volatile int *addr) { - return ((uint32_t(*)(volatile int *addr))FUNC_LPM_READ_ADDR)(addr); + return ((uint32_t(*)(volatile int *addr))FUNC_LPM_READ_ADDR)(addr); } -void lpm_write(volatile int *addr,uint32_t value) +void lpm_write(volatile int *addr, uint32_t value) { - ((void(*)(volatile int *addr,uint32_t value))FUNC_LPM_WRITE_ADDR)(addr,value); + ((void(*)(volatile int *addr, uint32_t value))FUNC_LPM_WRITE_ADDR)(addr, value); } -void lpm_bt_write(uint8_t type,uint32_t val) +void lpm_bt_write(uint8_t type, uint32_t val) { - // ((void(*)(uint8_t type,uint32_t val))FUNC_LPM_BT_WRITE_ADDR)(type,val); - enable_clock(CLKCLS_BT); - *(volatile uint8_t*)0xc804c = (val & 0x000000ff)>>0; delay(10); - *(volatile uint8_t*)0xc804d = (val & 0x0000ff00)>>8; delay(10); - *(volatile uint8_t*)0xc804e = (val & 0x00ff0000)>>16; delay(10); - *(volatile uint8_t*)0xc804f = (val & 0xff000000)>>24; delay(10); - *(volatile uint8_t*)0xc8005 = 1<> 0; + delay(10); + *(volatile uint8_t *)0xc804d = (val & 0x0000ff00) >> 8; + delay(10); + *(volatile uint8_t *)0xc804e = (val & 0x00ff0000) >> 16; + delay(10); + *(volatile uint8_t *)0xc804f = (val & 0xff000000) >> 24; + delay(10); + *(volatile uint8_t *)0xc8005 = 1 << type; } uint32_t lpm_bt_read(uint8_t type) { - if(type==LPMBT_WKUPLOW || type==LPMBT_WKUPHIGH) - { - return (((uint32_t(*)(uint8_t type))FUNC_LPM_BT_READ_ADDR)(type))>>2; - } - else - { - return (((uint32_t(*)(uint8_t type))FUNC_LPM_BT_READ_ADDR)(type)); - } + if (type == LPMBT_WKUPLOW || type == LPMBT_WKUPHIGH) + { + return (((uint32_t(*)(uint8_t type))FUNC_LPM_BT_READ_ADDR)(type)) >> 2; + } + else + { + return (((uint32_t(*)(uint8_t type))FUNC_LPM_BT_READ_ADDR)(type)); + } } void lpm_sleep(void) { - ((void(*)())FUNC_LPM_SLEEP_ADDR)(); + ((void(*)())FUNC_LPM_SLEEP_ADDR)(); } -void setlpmval(volatile int * addr,uint8_t startbit,uint8_t bitwidth,uint32_t val) +void setlpmval(volatile int *addr, uint8_t startbit, uint8_t bitwidth, uint32_t val) { - ((void(*)(volatile int * addr,uint8_t startbit,uint8_t bitwidth,uint32_t val))FUNC_SETLPMVAL_ADDR)(addr,startbit,bitwidth,val); + ((void(*)(volatile int *addr, uint8_t startbit, uint8_t bitwidth, uint32_t val))FUNC_SETLPMVAL_ADDR)(addr, startbit, bitwidth, val); } -uint32_t readlpmval(volatile int * addr,uint8_t startbit,uint8_t bitwidth) +uint32_t readlpmval(volatile int *addr, uint8_t startbit, uint8_t bitwidth) { - uint32_t tmp = 0; - if(32 == bitwidth) - { - tmp = lpm_read(addr); - return ((tmp>>startbit) & ((1<> startbit) & ((1 << bitwidth) - 1)); + } + else + { + return lpm_read(addr); + } } void GPIO_Unused_Pd(void) { - for (int i = 0; i < 48; i++) - { - if (GPIO_CONFIG(i) == 0 || GPIO_CONFIG(i) == 4 || GPIO_CONFIG(i) == 5) - { - GPIO_CONFIG(i) |= GPCFG_PD; - } - } + for (int i = 0; i < 48; i++) + { + if (GPIO_CONFIG(i) == 0 || GPIO_CONFIG(i) == 4 || GPIO_CONFIG(i) == 5) + { + GPIO_CONFIG(i) |= GPCFG_PD; + } + } } static uint32_t value_rtc_1s = 0; static uint32_t get_otp(void) { - uint32_t time; - - if (value_rtc_1s == 0) - { - read_otp(0x13e,(uint8_t *)&time,2); - time = (time == 0) ? 0x8000:time; - time &= (~((uint32_t)0x1<<31)); - } - else - { - time = value_rtc_1s; - time |= ((uint32_t)0x1<<31); - } - - return time; + uint32_t time; + + if (value_rtc_1s == 0) + { + read_otp(0x13e, (uint8_t *)&time, 2); + time = (time == 0) ? 0x8000 : time; + time &= (~((uint32_t)0x1 << 31)); + } + else + { + time = value_rtc_1s; + time |= ((uint32_t)0x1 << 31); + } + + return time; } void BT_Hibernate(void) { - ipc_inited = FALSE; - - read_otp(0x13e,(uint8_t *)&value_rtc_1s,2); - value_rtc_1s = (value_rtc_1s == 0) ? 0x8000:value_rtc_1s; - - BT_CONFIG &= ~(1 << BT_INIT_FLAG); - - NVIC_DisableIRQ(BT_IRQn); - SYSCTRL_ROM_SWITCH = 0x90; - - HCI_TypeDef IpcRxData; - IpcRxData.type = 1; - IpcRxData.opcode= 0x27; - IpcRxData.DataLen=0; - IPC_TxData(&IpcRxData); - delay(10000); + ipc_inited = FALSE; + + read_otp(0x13e, (uint8_t *)&value_rtc_1s, 2); + value_rtc_1s = (value_rtc_1s == 0) ? 0x8000 : value_rtc_1s; + + BT_CONFIG &= ~(1 << BT_INIT_FLAG); + + NVIC_DisableIRQ(BT_IRQn); + SYSCTRL_ROM_SWITCH = 0x90; + + HCI_TypeDef IpcRxData; + IpcRxData.type = 1; + IpcRxData.opcode = 0x27; + IpcRxData.DataLen = 0; + IPC_TxData(&IpcRxData); + delay(10000); } void Chip_Speedstep(void) { - SYSCTRL_HCLKConfig(SYSCTRL_HCLK_Div8); + SYSCTRL_HCLKConfig(SYSCTRL_HCLK_Div8); } void CM0_Sleep(uint32_t time, GPIO_TypeDef GPIOx, uint16_t GPIO_Pin, uint8_t islow_wakeup, uint8_t is_powerdownbt) { - uint32_t temp; - - SYSCTRL_AHBPeriphClockCmd(SYSCTRL_AHBPeriph_INTR|SYSCTRL_AHBPeriph_SHA|\ - SYSCTRL_AHBPeriph_CRC|SYSCTRL_AHBPeriph_PWM|\ - SYSCTRL_AHBPeriph_WDT|SYSCTRL_AHBPeriph_USB|\ - SYSCTRL_AHBPeriph_SPI|SYSCTRL_AHBPeriph_DES|\ - SYSCTRL_AHBPeriph_RSA|SYSCTRL_AHBPeriph_ASE|\ - SYSCTRL_AHBPeriph_7816|SYSCTRL_AHBPeriph_SM4|\ - SYSCTRL_AHBPeriph_7811|SYSCTRL_AHBPeriph_ADC7811|\ - SYSCTRL_AHBPeriph_CP, DISABLE); - - //DISABLE RTC WAKEUP - setlpmval(LPM_GPIO_WKHI,17,1,0); - - //set gpio wakeup level - setlpmval(LPM_GPIO_WKHI, 18, 1, islow_wakeup ? 1 : 0); - - //set gpio num - if (islow_wakeup) - { - GPIO_Config(GPIOx, GPIO_Pin, PULL_UP); - } - else - { - GPIO_Config(GPIOx, GPIO_Pin, PULL_DOWN); - } - - if (GPIOx == GPIOA) - { - setlpmval(LPM_GPIO_WKUP, 0, 16, GPIO_Pin); - } - else if (GPIOx == GPIOB) - { - setlpmval(LPM_GPIO_WKUP, 16, 16, GPIO_Pin); - } - else if (GPIOx == GPIOC) - { - setlpmval(LPM_GPIO_WKHI, 0, 16, GPIO_Pin); - } - else - { - setlpmval(LPM_GPIO_WKUP, 0, 32, 0); - setlpmval(LPM_GPIO_WKHI, 0, 16, 0); - } - - temp = get_otp(); - - if(time) - { - //SET SECMAX - setlpmval(LPM_SECMAX, 0, 16, temp); - //SET SLEEP CNT - setlpmval(LPM_WKUP_TIMER, 0, 32, time); - //clr RTC CNT - setlpmval(LPM_RTC_CNT, 0, 32, 0); - // ENABLE RTC WAKEUP - setlpmval(LPM_GPIO_WKHI, 17, 1, 1); - } - - if(is_powerdownbt == 1 && (temp >> 31) == 0) - { - BT_Hibernate(); - } + uint32_t temp; + + SYSCTRL_AHBPeriphClockCmd(SYSCTRL_AHBPeriph_INTR | SYSCTRL_AHBPeriph_SHA | \ + SYSCTRL_AHBPeriph_CRC | SYSCTRL_AHBPeriph_PWM | \ + SYSCTRL_AHBPeriph_WDT | SYSCTRL_AHBPeriph_USB | \ + SYSCTRL_AHBPeriph_SPI | SYSCTRL_AHBPeriph_DES | \ + SYSCTRL_AHBPeriph_RSA | SYSCTRL_AHBPeriph_ASE | \ + SYSCTRL_AHBPeriph_7816 | SYSCTRL_AHBPeriph_SM4 | \ + SYSCTRL_AHBPeriph_7811 | SYSCTRL_AHBPeriph_ADC7811 | \ + SYSCTRL_AHBPeriph_CP, DISABLE); + + //DISABLE RTC WAKEUP + setlpmval(LPM_GPIO_WKHI, 17, 1, 0); + + //set gpio wakeup level + setlpmval(LPM_GPIO_WKHI, 18, 1, islow_wakeup ? 1 : 0); + + //set gpio num + if (islow_wakeup) + { + GPIO_Config(GPIOx, GPIO_Pin, PULL_UP); + } + else + { + GPIO_Config(GPIOx, GPIO_Pin, PULL_DOWN); + } + + if (GPIOx == GPIOA) + { + setlpmval(LPM_GPIO_WKUP, 0, 16, GPIO_Pin); + } + else if (GPIOx == GPIOB) + { + setlpmval(LPM_GPIO_WKUP, 16, 16, GPIO_Pin); + } + else if (GPIOx == GPIOC) + { + setlpmval(LPM_GPIO_WKHI, 0, 16, GPIO_Pin); + } + else + { + setlpmval(LPM_GPIO_WKUP, 0, 32, 0); + setlpmval(LPM_GPIO_WKHI, 0, 16, 0); + } + + temp = get_otp(); + + if (time) + { + //SET SECMAX + setlpmval(LPM_SECMAX, 0, 16, temp); + //SET SLEEP CNT + setlpmval(LPM_WKUP_TIMER, 0, 32, time); + //clr RTC CNT + setlpmval(LPM_RTC_CNT, 0, 32, 0); + // ENABLE RTC WAKEUP + setlpmval(LPM_GPIO_WKHI, 17, 1, 1); + } + + if (is_powerdownbt == 1 && (temp >> 31) == 0) + { + BT_Hibernate(); + } - lpm_sleep(); + lpm_sleep(); } Index: yc_otp.h =================================================================== --- /YC3121_SDK/fw/sdk/yc_otp.h (revision 669) +++ /YC3121_SDK/fw/sdk/yc_otp.h (working copy) @@ -33,20 +33,20 @@ /* * @brief:OTP read - * @param:addr + * @param:addr * @param:*data * @param: len * @return: 1-succ 0-fail */ -uint8_t read_otp(uint32_t addr,uint8_t *data,uint32_t len); +uint8_t read_otp(uint32_t addr, uint8_t *data, uint32_t len); /* * @brief:OTP write - * @param:addr + * @param:addr * @param:*data * @param: len * @return: 1-succ 0-fail */ -uint8_t write_otp(uint32_t addr,uint8_t *data,uint32_t len); +uint8_t write_otp(uint32_t addr, uint8_t *data, uint32_t len); #endif Index: yc_otp.c =================================================================== --- /YC3121_SDK/fw/sdk/yc_otp.c (revision 669) +++ /YC3121_SDK/fw/sdk/yc_otp.c (working copy) @@ -7,7 +7,7 @@ */ void deinit_otp(void) { - ((void(*)())FUNC_DEINIT_OTP_ADDR)(); + ((void(*)())FUNC_DEINIT_OTP_ADDR)(); } /* @@ -17,53 +17,53 @@ */ void init_otp(void) { - ((void(*)())FUNC_INIT_OTP_ADDR)(); + ((void(*)())FUNC_INIT_OTP_ADDR)(); } uint32_t read_chip_life(void) { - uint32_t life = 0; - init_otp(); - life = ((uint32_t(*)(void))FUNC_READ_CHIPLF_ADDR)(); - deinit_otp(); - return life; + uint32_t life = 0; + init_otp(); + life = ((uint32_t(*)(void))FUNC_READ_CHIPLF_ADDR)(); + deinit_otp(); + return life; } void read_chipid(uint8_t *id) { - init_otp(); - ((void(*)(uint8_t *id))FUNC_READ_CHIPID_ADDR)(id); - deinit_otp(); + init_otp(); + ((void(*)(uint8_t *id))FUNC_READ_CHIPID_ADDR)(id); + deinit_otp(); } /* * @brief: OTP read - * @param: addr + * @param: addr * @param: *data * @param: len * @return: none */ -uint8_t read_otp(uint32_t addr,uint8_t *data,uint32_t len) +uint8_t read_otp(uint32_t addr, uint8_t *data, uint32_t len) { init_otp(); - ((uint8_t(*)(uint32_t addr,uint8_t *data,uint32_t len))FUNC_READ_OTP_ADDR)(addr,data,len); + ((uint8_t(*)(uint32_t addr, uint8_t *data, uint32_t len))FUNC_READ_OTP_ADDR)(addr, data, len); deinit_otp(); return SUCCESS; } /* * @brief: OTP write - * @param: addr + * @param: addr * @param: *data * @param: len * @return: SUCCESS or ERROR */ uint8_t write_otp(uint32_t addr, uint8_t *data, uint32_t len) { - uint8_t rtn = 0; - - //step2: - rtn = ((uint8_t(*)(uint32_t addr,uint8_t *data,uint32_t len))FUNC_WRITE_OTP_ADDR)(addr,data,len); - - return rtn; + uint8_t rtn = 0; + + //step2: + rtn = ((uint8_t(*)(uint32_t addr, uint8_t *data, uint32_t len))FUNC_WRITE_OTP_ADDR)(addr, data, len); + + return rtn; } Index: yc_rand.c =================================================================== --- /YC3121_SDK/fw/sdk/yc_rand.c (revision 669) +++ /YC3121_SDK/fw/sdk/yc_rand.c (working copy) @@ -1,32 +1,32 @@ #include "yc_rand.h" static uint32_t TRand(void *buf, uint32_t bytes) -{ - uint32_t i; - for(i = 0; i < bytes;i++ ) - { - ((uint8_t*)buf)[i]=GetTRNGData_8bit(); - } - return i; +{ + uint32_t i; + for (i = 0; i < bytes; i++) + { + ((uint8_t *)buf)[i] = GetTRNGData_8bit(); + } + return i; } uint32_t RAND_Rand(void *rand, uint32_t bytes) { - return TRand(rand, bytes); + return TRand(rand, bytes); } uint32_t RAND_RandP(void *rand, uint32_t bytes, void *p_rng) { - return RAND_Rand(rand, bytes); + return RAND_Rand(rand, bytes); } uint32_t RAND_RandCheck(void *rand, uint32_t bytes) { - return 0; + return 0; } uint32_t RAND_Init() { - TRNG_Init(); - return 0; + TRNG_Init(); + return 0; } Index: yc_rtc.c =================================================================== --- /YC3121_SDK/fw/sdk/yc_rtc.c (revision 669) +++ /YC3121_SDK/fw/sdk/yc_rtc.c (working copy) @@ -12,73 +12,73 @@ void RTC_SetRefRegister(uint32_t RefRegValue) { - lpm_write(LPM_RTC_CNT, RefRegValue); + lpm_write(LPM_RTC_CNT, RefRegValue); } uint32_t RTC_GetRefRegister(void) { - return (lpm_read(LPM_RTC_CNT)); + return (lpm_read(LPM_RTC_CNT)); } void RTC_SetWakeUpCounter(uint32_t cnt) { - lpm_write(LPM_WKUP_TIMER, cnt); + lpm_write(LPM_WKUP_TIMER, cnt); } void RTC_Config(FunctionalState NewState) { - uint32_t tmp = 0; - tmp = lpm_read(LPM_GPIO_WKHI); - - if(NewState == ENABLE) - { - tmp|= (1 << RTC_TIMER_ENABLE_BIT); - lpm_write(LPM_GPIO_WKHI,tmp); - } - else - { - tmp&= (~(1 << RTC_TIMER_ENABLE_BIT)); - lpm_write(LPM_GPIO_WKHI,tmp); - } + uint32_t tmp = 0; + tmp = lpm_read(LPM_GPIO_WKHI); + + if (NewState == ENABLE) + { + tmp |= (1 << RTC_TIMER_ENABLE_BIT); + lpm_write(LPM_GPIO_WKHI, tmp); + } + else + { + tmp &= (~(1 << RTC_TIMER_ENABLE_BIT)); + lpm_write(LPM_GPIO_WKHI, tmp); + } } ITStatus RTC_GetITStatus(void) { - uint32_t tmp = lpm_read(LPM_STATUS); - if((tmp>>31)&1) - return SET; - else - return RESET; + uint32_t tmp = lpm_read(LPM_STATUS); + if ((tmp >> 31) & 1) + return SET; + else + return RESET; } void RTC_Set_SecMax(uint16_t secmax) { - (*LPM_SECMAX) = secmax; - while (SYSCTRL_LPM_STATUS & 0x40); + (*LPM_SECMAX) = secmax; + while (SYSCTRL_LPM_STATUS & 0x40); } void RTC_ClearITPendingBit(void) { - RTC_Config(DISABLE); - RTC_Config(ENABLE); - uint32_t temp = lpm_read(LPM_CLR_INTR); - temp&=(~(0xff)); - temp |= 0x6c; - lpm_write(LPM_CLR_INTR,temp); + RTC_Config(DISABLE); + RTC_Config(ENABLE); + uint32_t temp = lpm_read(LPM_CLR_INTR); + temp &= (~(0xff)); + temp |= 0x6c; + lpm_write(LPM_CLR_INTR, temp); } uint16_t RTC_Get_SexMax(void) { - *(volatile byte*)0xc8042 = 0xc4; - *(volatile byte*)0xc800a = 0x80; - delay(10000000); - int mem_810a = *(volatile byte*)0xc810a; - mem_810a += (*(volatile byte*)0xc810b) << 8; - mem_810a += (*(volatile byte*)0xc810c) << 16; - return 49152000000 / mem_810a; + *(volatile byte *)0xc8042 = 0xc4; + *(volatile byte *)0xc800a = 0x80; + delay(10000000); + int mem_810a = *(volatile byte *)0xc810a; + mem_810a += (*(volatile byte *)0xc810b) << 8; + mem_810a += (*(volatile byte *)0xc810c) << 16; + return 49152000000 / mem_810a; } void RTC_Calibration(void) { - RTC_Set_SecMax(RTC_Get_SexMax()); + RTC_Set_SecMax(RTC_Get_SexMax()); } Index: yc_spi.h =================================================================== --- /YC3121_SDK/fw/sdk/yc_spi.h (revision 669) +++ /YC3121_SDK/fw/sdk/yc_spi.h (working copy) @@ -5,7 +5,7 @@ Date : 2018/12/06 Description : SPI encapsulation. */ - + #ifndef __SPI_H__ #define __SPI_H__ @@ -13,12 +13,12 @@ typedef enum { - SPI0 =1, - SPI1 =2 -}SPIx_TypeDef; + SPI0 = 1, + SPI1 = 2 +} SPIx_TypeDef; #define IS_SPIx(SPIx) (SPIx==SPI0 || SPIx== SPI1) -/** @ +/** @ * @defgroup SPI_mode */ #define SPI_Mode_Master ((uint8_t)0<<3) @@ -27,8 +27,8 @@ ((MODE) == SPI_Mode_Slave)) /** @ - * @defgroup SPI_CPOL - */ + * @defgroup SPI_CPOL + */ #define SPI_CPOL_Low ((uint8_t)0<<5) #define SPI_CPOL_High ((uint8_t)1<<5) @@ -36,8 +36,8 @@ ((CPOL) == SPI_CPOL_Low)) /** @ - * @defgroup SPI_CPHA - */ + * @defgroup SPI_CPHA + */ #define SPI_CPHA_First_Edge ((uint8_t)0<<4) #define SPI_CPHA_Second_Edge ((uint8_t)1<<4) @@ -45,8 +45,8 @@ ((CPHA) == SPI_CPHA_Second_Edge)) /** @ - * @defgroup SPI_BaudSpeed - */ + * @defgroup SPI_BaudSpeed + */ #define SPI_BaudRatePrescaler_1 0 #define SPI_BaudRatePrescaler_2 1 #define SPI_BaudRatePrescaler_4 2 @@ -65,72 +65,72 @@ ((PRESCALER) == SPI_BaudRatePrescaler_128) ) /** @ - * @defgroup SPI_BaudSpeed - */ + * @defgroup SPI_BaudSpeed + */ #define IS_SPI_RW_Delay(x) (x>0 && x<127) -/** - * @brief SPI Init structure definition +/** + * @brief SPI Init structure definition */ typedef struct { - uint8_t Mode; /*!< Specifies the SPI operating mode. This parameter + uint8_t Mode; /*!< Specifies the SPI operating mode. This parameter can be a value of @ref SPI_mode */ - - uint8_t CPOL; /*!< Specifies the serial clock steady state. + + uint8_t CPOL; /*!< Specifies the serial clock steady state. This parameter can be a value of @ref SPI_Clock_Polarity */ - uint8_t CPHA; /*!< Specifies the clock active edge for the bit capture. + uint8_t CPHA; /*!< Specifies the clock active edge for the bit capture. This parameter can be a value of @ref SPI_Clock_Phase */ - - uint8_t BaudRatePrescaler; /*!< Specifies the Baud Rate prescaler value which will be + + uint8_t BaudRatePrescaler; /*!< Specifies the Baud Rate prescaler value which will be used to configure the transmit and receive SCK clock. This parameter can be a value of @ref SPI_BaudRate_Prescaler. @note The communication clock is derived from the master clock. The slave clock does not need to be set. */ - uint8_t RW_Delay; /*!< Specifies the Delay time between send and receive data,the + uint8_t RW_Delay; /*!< Specifies the Delay time between send and receive data,the value must be 0 to 127 */ -}SPI_InitTypeDef; +} SPI_InitTypeDef; /** * @brief Initializes the SPIx peripheral according to the specified * parameters in the SPI_InitStruct . - * @param SPIx: Select the SPI peripheral. - * This parameter can be one of the following values: + * @param SPIx: Select the SPI peripheral. + * This parameter can be one of the following values: * SPI0, SPI1 * @param SPI_InitStruct: pointer to a USART_InitTypeDef structure - * that contains the configuration information for the specified SPI + * that contains the configuration information for the specified SPI * peripheral. * @retval None */ -void SPI_Init( SPIx_TypeDef SPIx, SPI_InitTypeDef* SPI_InitStruct); +void SPI_Init(SPIx_TypeDef SPIx, SPI_InitTypeDef *SPI_InitStruct); /** * @brief Transmits one data via SPI DMA. - * @param SPIx: Select the SPI or the SPI peripheral. + * @param SPIx: Select the SPI or the SPI peripheral. * This parameter can be one of the following values: * SPI0, SPI1. * @param data: the data you want transmit. * @retval None */ -void SPI_SendData(SPIx_TypeDef SPIx,uint8_t data); +void SPI_SendData(SPIx_TypeDef SPIx, uint8_t data); /** * @brief Transmits datas via SPI DMA. - * @param SPIx: Select the SPIx or the SPIx peripheral. + * @param SPIx: Select the SPIx or the SPIx peripheral. * This parameter can be one of the following values: * SPI0, SPI1. * @param buf: pointer to a buf that contains the data you want send. * @param len: the buf length * @retval None */ -void SPI_SendBuff(SPIx_TypeDef SPIx,uint8_t *buff,int len); +void SPI_SendBuff(SPIx_TypeDef SPIx, uint8_t *buff, int len); /** * @brief Send data first then recerive data. - * - * @param SPIx: Select the SPI or the SPI peripheral. + * + * @param SPIx: Select the SPI or the SPI peripheral. * This parameter can be one of the following values: * SPI0, SPI1. * @param: TxBuff: pointer to a TxBuff that contains the data you want send. @@ -139,6 +139,6 @@ * @param: RxLen: the length of receive datas * @retval None */ -void SPI_SendAndReceiveData(SPIx_TypeDef SPIx,uint8_t *TxBuff, uint16_t TxLen, uint8_t *RxBuff, uint16_t RxLen); +void SPI_SendAndReceiveData(SPIx_TypeDef SPIx, uint8_t *TxBuff, uint16_t TxLen, uint8_t *RxBuff, uint16_t RxLen); #endif Index: yc_spi.c =================================================================== --- /YC3121_SDK/fw/sdk/yc_spi.c (revision 669) +++ /YC3121_SDK/fw/sdk/yc_spi.c (working copy) @@ -7,63 +7,67 @@ */ #include "yc_spi.h" -void SPI_Init(SPIx_TypeDef SPIx, SPI_InitTypeDef* SPI_InitStruct) +void SPI_Init(SPIx_TypeDef SPIx, SPI_InitTypeDef *SPI_InitStruct) { #define BITDELAY 8 - uint32_t regspictrl = 0; + uint32_t regspictrl = 0; - _ASSERT(IS_SPI_MODE(SPI_InitStruct->Mode)); - _ASSERT(IS_SPI_BAUDRATE_PRESCALER(SPI_InitStruct->BaudRatePrescaler)); - _ASSERT(IS_SPI_CPOL(SPI_InitStruct->CPOL)); - _ASSERT(IS_SPI_CPHA(SPI_InitStruct->CPHA )); - _ASSERT(IS_SPI_RW_Delay(SPI_InitStruct->RW_Delay)); - - regspictrl = SPI_InitStruct->Mode| \ - SPI_InitStruct->BaudRatePrescaler | \ - SPI_InitStruct->CPOL | \ - SPI_InitStruct->CPHA | \ - (SPI_InitStruct->RW_Delay)<Mode)); + _ASSERT(IS_SPI_BAUDRATE_PRESCALER(SPI_InitStruct->BaudRatePrescaler)); + _ASSERT(IS_SPI_CPOL(SPI_InitStruct->CPOL)); + _ASSERT(IS_SPI_CPHA(SPI_InitStruct->CPHA)); + _ASSERT(IS_SPI_RW_Delay(SPI_InitStruct->RW_Delay)); + + regspictrl = SPI_InitStruct->Mode | \ + SPI_InitStruct->BaudRatePrescaler | \ + SPI_InitStruct->CPOL | \ + SPI_InitStruct->CPHA | \ + (SPI_InitStruct->RW_Delay) << BITDELAY; + + switch (SPIx) + { + case SPI0: + SPID0_CTRL = regspictrl; + break; + case SPI1: + SPID1_CTRL = regspictrl; + break; + } } void SPI_SendData(SPIx_TypeDef SPIx, uint8_t data) -{ - static unsigned char pdata; - pdata = data; - DMA_SRC_ADDR(SPIx) = (int)(&pdata); - DMA_LEN(SPIx) = 1 << 16; - DMA_START(SPIx) = (1<TAMPER_Port_mode)); - _ASSERT(IS_TAMPER_PORT_PU(TAMPER_InitStruct->TAMPER_Port_PullUp)); - _ASSERT(IS_TAMPER_PORT(TAMPER_InitStruct->TAMPER_Port_Enable)); - _ASSERT(IS_TAMPER_GLITCH_TIME(TAMPER_InitStruct->TAMPER_GlitchTimes)); - _ASSERT(IS_TAMPER_PUPU_HOLD_TIME(TAMPER_InitStruct->TAMPER_PUPU_HoldTime)); - - uint32_t ssc_temp; - - ssc_temp = lpm_read(LPM_SENSOR); - - ssc_temp &= ~((uint32_t)((uint32_t)0xFF << SHIELDING_PORT_PULLUP_BIT)|\ - (uint32_t)((uint32_t)0xF << SHIELDING_PORT_ENABLE_BIT) |\ - (uint32_t)((uint32_t)0xF << SHIELDING_PORT_MODE_BIT) |\ - (uint32_t)((uint32_t)0x3 << SHIELDING_GLITCHTIME_DEALY_BIT) |\ - (uint32_t)((uint32_t)0x3 << SHIELDING_PU_HOLDTIME_BIT)); - ssc_temp |= TAMPER_InitStruct->TAMPER_Port_mode << SHIELDING_PORT_MODE_BIT; //shielding type - ssc_temp |= TAMPER_InitStruct->TAMPER_Port_PullUp << SHIELDING_PORT_PULLUP_BIT; //pull up - ssc_temp |= TAMPER_InitStruct->TAMPER_Port_Enable << SHIELDING_PORT_ENABLE_BIT; //shielding enable - ssc_temp |= TAMPER_InitStruct->TAMPER_GlitchTimes << SHIELDING_GLITCHTIME_DEALY_BIT; //alarm_delay - ssc_temp |= TAMPER_InitStruct->TAMPER_PUPU_HoldTime << SHIELDING_PU_HOLDTIME_BIT; //pull up delay - - lpm_write(LPM_SENSOR, ssc_temp); + _ASSERT(IS_TAMPER_PORT_ACTIVE(TAMPER_InitStruct->TAMPER_Port_mode)); + _ASSERT(IS_TAMPER_PORT_PU(TAMPER_InitStruct->TAMPER_Port_PullUp)); + _ASSERT(IS_TAMPER_PORT(TAMPER_InitStruct->TAMPER_Port_Enable)); + _ASSERT(IS_TAMPER_GLITCH_TIME(TAMPER_InitStruct->TAMPER_GlitchTimes)); + _ASSERT(IS_TAMPER_PUPU_HOLD_TIME(TAMPER_InitStruct->TAMPER_PUPU_HoldTime)); + + uint32_t ssc_temp; + + ssc_temp = lpm_read(LPM_SENSOR); + + ssc_temp &= ~((uint32_t)((uint32_t)0xFF << SHIELDING_PORT_PULLUP_BIT) | \ + (uint32_t)((uint32_t)0xF << SHIELDING_PORT_ENABLE_BIT) | \ + (uint32_t)((uint32_t)0xF << SHIELDING_PORT_MODE_BIT) | \ + (uint32_t)((uint32_t)0x3 << SHIELDING_GLITCHTIME_DEALY_BIT) | \ + (uint32_t)((uint32_t)0x3 << SHIELDING_PU_HOLDTIME_BIT)); + ssc_temp |= TAMPER_InitStruct->TAMPER_Port_mode << SHIELDING_PORT_MODE_BIT; //shielding type + ssc_temp |= TAMPER_InitStruct->TAMPER_Port_PullUp << SHIELDING_PORT_PULLUP_BIT; //pull up + ssc_temp |= TAMPER_InitStruct->TAMPER_Port_Enable << SHIELDING_PORT_ENABLE_BIT; //shielding enable + ssc_temp |= TAMPER_InitStruct->TAMPER_GlitchTimes << SHIELDING_GLITCHTIME_DEALY_BIT; //alarm_delay + ssc_temp |= TAMPER_InitStruct->TAMPER_PUPU_HoldTime << SHIELDING_PU_HOLDTIME_BIT; //pull up delay + + lpm_write(LPM_SENSOR, ssc_temp); } void SSC_LPMTemperCmd(uint32_t SENSOR_Port, FunctionalState NewState) { - _ASSERT(IS_TAMPER_PORT(SENSOR_Port)); - _ASSERT(IS_FUNCTIONAL_STATE(NewState)); - - uint32_t ssc_temp; - - ssc_temp = lpm_read(LPM_SENSOR); - - if (NewState == ENABLE) - { - ssc_temp |= (uint32_t)SENSOR_Port << SHIELDING_PORT_ENABLE_BIT; - } - else if (NewState == DISABLE) - { - ssc_temp &= ~((uint32_t)SENSOR_Port << SHIELDING_PORT_ENABLE_BIT); - } - - lpm_write(LPM_SENSOR, ssc_temp); + _ASSERT(IS_TAMPER_PORT(SENSOR_Port)); + _ASSERT(IS_FUNCTIONAL_STATE(NewState)); + + uint32_t ssc_temp; + + ssc_temp = lpm_read(LPM_SENSOR); + + if (NewState == ENABLE) + { + ssc_temp |= (uint32_t)SENSOR_Port << SHIELDING_PORT_ENABLE_BIT; + } + else if (NewState == DISABLE) + { + ssc_temp &= ~((uint32_t)SENSOR_Port << SHIELDING_PORT_ENABLE_BIT); + } + + lpm_write(LPM_SENSOR, ssc_temp); } void SSC_SensorDur(uint32_t sensor_dur) { - _ASSERT(IS_SENSOR_DUR(sensor_dur)); - - uint32_t ssc_temp; - - ssc_temp = lpm_read(LPM_GPIO_WKHI); - - ssc_temp |= ((uint32_t)sensor_dur) << SENSOR_DUR_BIT; - - lpm_write(LPM_GPIO_WKHI, ssc_temp); + _ASSERT(IS_SENSOR_DUR(sensor_dur)); + + uint32_t ssc_temp; + + ssc_temp = lpm_read(LPM_GPIO_WKHI); + + ssc_temp |= ((uint32_t)sensor_dur) << SENSOR_DUR_BIT; + + lpm_write(LPM_GPIO_WKHI, ssc_temp); } void SSC_SensorDelay(uint32_t sensor_delay) { - _ASSERT(IS_SENEOR_DELAY(sensor_delay)); - - uint32_t ssc_temp; - - ssc_temp = lpm_read(LPM_SENSOR); - - ssc_temp |= ((uint32_t)sensor_delay) << SENSOR_DEALY_BIT;//sensor delay - - lpm_write(LPM_SENSOR, ssc_temp); + _ASSERT(IS_SENEOR_DELAY(sensor_delay)); + + uint32_t ssc_temp; + + ssc_temp = lpm_read(LPM_SENSOR); + + ssc_temp |= ((uint32_t)sensor_delay) << SENSOR_DEALY_BIT;//sensor delay + + lpm_write(LPM_SENSOR, ssc_temp); } void SSC_LPMSensorCmd(uint32_t sensor, FunctionalState NewState) { - _ASSERT(IS_SENSOR_ENABLE(sensor)); - - uint32_t ssc_temp; - - ssc_temp = lpm_read(LPM_SENSOR); - - if (NewState == ENABLE) - { - ssc_temp |= (uint32_t)sensor; - } - else if (NewState == DISABLE) - { - ssc_temp &= ~(uint32_t)sensor; - } - - lpm_write(LPM_SENSOR, ssc_temp); - - ssc_temp = lpm_read(LPM_CTRL); - - if (NewState == ENABLE) - { - - if (LPM_BAT_VDT12L_ENABLE & sensor) - { - ssc_temp |= ((uint32_t)1 << ANALOG_BAT12L_BIT); - } - if ((LPM_BAT_VDT33H_ENABLE | LPM_BAT_VDT33L_ENABLE) & sensor) - { - ssc_temp |= ((uint32_t)1 << ANALOG_BATV33HL_BIT); - } - if ((LPM_TEMPERATURE_40_ENABLE | LPM_TEMPERATURE_120_ENABLE) & sensor) - { - ssc_temp |= ((uint32_t)1 << ANALOG_TEMPRATURE_BIT); - } - } - else if (NewState == DISABLE) - { - if (LPM_BAT_VDT12L_ENABLE & sensor) - { - ssc_temp &= ~((uint32_t)1 << ANALOG_BAT12L_BIT); - } - if ((LPM_BAT_VDT33H_ENABLE |LPM_BAT_VDT33L_ENABLE) & sensor) - { - ssc_temp &= ~((uint32_t)1 << ANALOG_BATV33HL_BIT); - } - if ((LPM_TEMPERATURE_40_ENABLE|LPM_TEMPERATURE_120_ENABLE) & sensor) - { - ssc_temp &= ~((uint32_t)1 << ANALOG_TEMPRATURE_BIT); - } - } + _ASSERT(IS_SENSOR_ENABLE(sensor)); + + uint32_t ssc_temp; + + ssc_temp = lpm_read(LPM_SENSOR); + + if (NewState == ENABLE) + { + ssc_temp |= (uint32_t)sensor; + } + else if (NewState == DISABLE) + { + ssc_temp &= ~(uint32_t)sensor; + } + + lpm_write(LPM_SENSOR, ssc_temp); + + ssc_temp = lpm_read(LPM_CTRL); + + if (NewState == ENABLE) + { + + if (LPM_BAT_VDT12L_ENABLE & sensor) + { + ssc_temp |= ((uint32_t)1 << ANALOG_BAT12L_BIT); + } + if ((LPM_BAT_VDT33H_ENABLE | LPM_BAT_VDT33L_ENABLE) & sensor) + { + ssc_temp |= ((uint32_t)1 << ANALOG_BATV33HL_BIT); + } + if ((LPM_TEMPERATURE_40_ENABLE | LPM_TEMPERATURE_120_ENABLE) & sensor) + { + ssc_temp |= ((uint32_t)1 << ANALOG_TEMPRATURE_BIT); + } + } + else if (NewState == DISABLE) + { + if (LPM_BAT_VDT12L_ENABLE & sensor) + { + ssc_temp &= ~((uint32_t)1 << ANALOG_BAT12L_BIT); + } + if ((LPM_BAT_VDT33H_ENABLE | LPM_BAT_VDT33L_ENABLE) & sensor) + { + ssc_temp &= ~((uint32_t)1 << ANALOG_BATV33HL_BIT); + } + if ((LPM_TEMPERATURE_40_ENABLE | LPM_TEMPERATURE_120_ENABLE) & sensor) + { + ssc_temp &= ~((uint32_t)1 << ANALOG_TEMPRATURE_BIT); + } + } - lpm_write(LPM_CTRL, ssc_temp); + lpm_write(LPM_CTRL, ssc_temp); } void SSC_LPMKeyRead(uint32_t *buf, uint8_t len, uint8_t offset) { - _ASSERT(IS_BPK_LEN(len, offset)); - - uint8_t i, k; - - for (i = 0; i < len; i++) - { - k = i + offset; - buf[i] = lpm_read(LPM_KEY(k)); - } + _ASSERT(IS_BPK_LEN(len, offset)); + + uint8_t i, k; + + for (i = 0; i < len; i++) + { + k = i + offset; + buf[i] = lpm_read(LPM_KEY(k)); + } } void SSC_LPMKeyWrite(uint32_t *buf, uint32_t len, uint8_t offset) { - _ASSERT(IS_BPK_LEN(len, offset)); - - uint8_t i, k; - - SSC_ClearKeyCMD(DISABLE); - - for (i = 0; i < len; i++) - { - k = i + offset; - lpm_write(LPM_KEY(k), buf[i]); - } - - SSC_ClearKeyCMD(ENABLE); + _ASSERT(IS_BPK_LEN(len, offset)); + + uint8_t i, k; + + SSC_ClearKeyCMD(DISABLE); + + for (i = 0; i < len; i++) + { + k = i + offset; + lpm_write(LPM_KEY(k), buf[i]); + } + + SSC_ClearKeyCMD(ENABLE); } void SSC_LPMLock(void) { - uint32_t ssc_temp; - - ssc_temp = lpm_read(LPM_SENSOR); - - ssc_temp |= ((uint32_t)1) << LPM_SHIELDING_LOCK_BIT; - - lpm_write(LPM_SENSOR, ssc_temp); + uint32_t ssc_temp; + + ssc_temp = lpm_read(LPM_SENSOR); + + ssc_temp |= ((uint32_t)1) << LPM_SHIELDING_LOCK_BIT; + + lpm_write(LPM_SENSOR, ssc_temp); } int16_t SSC_GetLPMStatusReg(void) { - uint16_t ssc_inq; - - ssc_inq = (lpm_read(LPM_STATUS) >> 16); + uint16_t ssc_inq; + + ssc_inq = (lpm_read(LPM_STATUS) >> 16); - return ssc_inq; + return ssc_inq; } void SSC_LPMClearStatusBit(void) { - uint32_t ssc_temp; - ssc_temp = lpm_read(LPM_SENSOR); - SSC_LPMSheildingAlarmEnable(DISABLE); - lpm_write(LPM_CLR_INTR,0x6c); - if(ssc_temp & (((uint32_t)1) << SHIELDING_ALARM_EN_BIT)) - { - SSC_LPMSheildingAlarmEnable(ENABLE); - } + uint32_t ssc_temp; + ssc_temp = lpm_read(LPM_SENSOR); + SSC_LPMSheildingAlarmEnable(DISABLE); + lpm_write(LPM_CLR_INTR, 0x6c); + if (ssc_temp & (((uint32_t)1) << SHIELDING_ALARM_EN_BIT)) + { + SSC_LPMSheildingAlarmEnable(ENABLE); + } } void SSC_SecureCmd(uint32_t SSC_secsure, FunctionalState NewState) { - _ASSERT(IS_SSC_SEC_ENABLE(SSC_secsure)); - - uint32_t ssc_temp; - - ssc_temp = SECURE_CTRL; - - if (NewState == ENABLE) - { - ssc_temp |= SSC_secsure; - } - else if (NewState == DISABLE) - { - ssc_temp &= ~SSC_secsure; - } - - ssc_temp|= ((uint32_t)7) << SENSOR_ALARM_CONTINUE_LIMIT_BIT; - - SECURE_CTRL = ssc_temp; + _ASSERT(IS_SSC_SEC_ENABLE(SSC_secsure)); + + uint32_t ssc_temp; + + ssc_temp = SECURE_CTRL; + + if (NewState == ENABLE) + { + ssc_temp |= SSC_secsure; + } + else if (NewState == DISABLE) + { + ssc_temp &= ~SSC_secsure; + } + + ssc_temp |= ((uint32_t)7) << SENSOR_ALARM_CONTINUE_LIMIT_BIT; + + SECURE_CTRL = ssc_temp; } uint8_t SSC_GetSecureStatus(void) { - uint8_t ssc_inq; - - ssc_inq = (SECURE_STATUS >> 1); + uint8_t ssc_inq; + + ssc_inq = (SECURE_STATUS >> 1); - return ssc_inq; + return ssc_inq; } Index: yc_sysctrl.h =================================================================== --- /YC3121_SDK/fw/sdk/yc_sysctrl.h (revision 669) +++ /YC3121_SDK/fw/sdk/yc_sysctrl.h (working copy) @@ -38,18 +38,18 @@ { // SleepMode_IDLE = 0x01, SleepMode_STOP = 0x02 -}SleepMode_TypeDef; -#define IS_ALL_SLEEP_MODE(MODE) ((MODE) == SleepMode_STOP) +} SleepMode_TypeDef; +#define IS_ALL_SLEEP_MODE(MODE) ((MODE) == SleepMode_STOP) typedef struct { - uint32_t HCLK_Frequency; /*!< returns HCLK frequency expressed in Hz */ -}SYSCTRL_ClocksTypeDef; - + uint32_t HCLK_Frequency; /*!< returns HCLK frequency expressed in Hz */ +} SYSCTRL_ClocksTypeDef; + /** * @brief Enables or disables the APB peripheral clock. * @param SYSCTRL_APBPeriph: specifies the APB peripheral to gates its clock. - * + * * For @b this parameter can be any combination * of the enum SYSCTRL_AHB_PERIPH. * @param NewState: new state of the specified peripheral clock. @@ -59,14 +59,14 @@ void SYSCTRL_AHBPeriphClockCmd(uint32_t SYSCTRL_AHBPeriph, FunctionalState NewState); /** - * @brief Config CPU Enter sleep mode + * @brief Config CPU Enter sleep mode * @param SleepMode_TypeDef: Select SleepMode. * @retval None */ void SYSCTRL_EnterSleep(SleepMode_TypeDef SleepMode); /** - * @brief Config HCLK + * @brief Config HCLK * @param HCLK_Div:Div value * @retval None */ @@ -77,7 +77,7 @@ * @param SYSCTRL_Clocks:The pointer point to the memmory preserve clocks value * @retval None */ -void SYSCTRL_GetClocksFreq(SYSCTRL_ClocksTypeDef* SYSCTRL_Clocks); +void SYSCTRL_GetClocksFreq(SYSCTRL_ClocksTypeDef *SYSCTRL_Clocks); /** * @brief enable dpll clock(Accurate clock,Available for UART and USB) @@ -86,4 +86,4 @@ */ void SYSCTRL_EnableDpllClk(void); -#endif /*__SYSCTRL_H*/ +#endif /*__SYSCTRL_H*/ Index: yc_sysctrl.c =================================================================== --- /YC3121_SDK/fw/sdk/yc_sysctrl.c (revision 669) +++ /YC3121_SDK/fw/sdk/yc_sysctrl.c (working copy) @@ -2,64 +2,64 @@ void SYSCTRL_AHBPeriphClockCmd(uint32_t SYSCTRL_AHBPeriph, FunctionalState NewState) { - _ASSERT(IS_SYSCTRL_AHB_PERIPH(SYSCTRL_AHBPeriph)); - if(NewState == DISABLE) - { - SYSCTRL_CLK_CLS |= SYSCTRL_AHBPeriph; - } - else - { - SYSCTRL_CLK_CLS &= ~SYSCTRL_AHBPeriph; - } + _ASSERT(IS_SYSCTRL_AHB_PERIPH(SYSCTRL_AHBPeriph)); + if (NewState == DISABLE) + { + SYSCTRL_CLK_CLS |= SYSCTRL_AHBPeriph; + } + else + { + SYSCTRL_CLK_CLS &= ~SYSCTRL_AHBPeriph; + } } void SYSCTRL_EnterSleep(SleepMode_TypeDef SleepMode) { - _ASSERT(IS_ALL_SLEEP_MODE(SleepMode)); - *LPM_SLEEP = 0x5a; + _ASSERT(IS_ALL_SLEEP_MODE(SleepMode)); + *LPM_SLEEP = 0x5a; } void noinline HCLKConfig_Div_None(uint32_t HCLK_Div) { - QSPI_CTRL |= (0x80); - int temp = (SYSCTRL_HCLK_CON&(~SYSCTRL_HCLK_COFG_REGBIT))|HCLK_Div; - SYSCTRL_HCLK_CON = temp; + QSPI_CTRL |= (0x80); + int temp = (SYSCTRL_HCLK_CON & (~SYSCTRL_HCLK_COFG_REGBIT)) | HCLK_Div; + SYSCTRL_HCLK_CON = temp; } void SYSCTRL_HCLKConfig(uint32_t HCLK_Div) { - _ASSERT(IS_GET_SYSCTRL_HCLK_DIV(HCLK_Div)); - if (HCLK_Div==SYSCTRL_HCLK_Div_None) - { - uint32_t HCLKConfig_Div_None_addr=(uint32_t)HCLKConfig_Div_None; - ((void(*)(void*, void*))FUNC_PREFETCH)(((uint32_t*)HCLKConfig_Div_None_addr),((uint32_t*)(HCLKConfig_Div_None_addr+64))); - HCLKConfig_Div_None(HCLK_Div); - } - else - { - int temp = (SYSCTRL_HCLK_CON&(~SYSCTRL_HCLK_COFG_REGBIT))|HCLK_Div; - SYSCTRL_HCLK_CON = temp; - } - + _ASSERT(IS_GET_SYSCTRL_HCLK_DIV(HCLK_Div)); + if (HCLK_Div == SYSCTRL_HCLK_Div_None) + { + uint32_t HCLKConfig_Div_None_addr = (uint32_t)HCLKConfig_Div_None; + ((void(*)(void *, void *))FUNC_PREFETCH)(((uint32_t *)HCLKConfig_Div_None_addr), ((uint32_t *)(HCLKConfig_Div_None_addr + 64))); + HCLKConfig_Div_None(HCLK_Div); + } + else + { + int temp = (SYSCTRL_HCLK_CON & (~SYSCTRL_HCLK_COFG_REGBIT)) | HCLK_Div; + SYSCTRL_HCLK_CON = temp; + } + } -void SYSCTRL_GetClocksFreq(SYSCTRL_ClocksTypeDef* SYSCTRL_Clocks) +void SYSCTRL_GetClocksFreq(SYSCTRL_ClocksTypeDef *SYSCTRL_Clocks) { - SYSCTRL_Clocks->HCLK_Frequency = CPU_MHZ; + SYSCTRL_Clocks->HCLK_Frequency = CPU_MHZ; } void SYSCTRL_EnableDpllClk(void) { - enable_clock(CLKCLS_BT); - SYSCTRL_ROM_SWITCH= 0x94; - delay(500); - - *(volatile byte*)0xc4ab1=0x7f; - *(volatile byte*)0xc4ab2=0xff; - *(volatile byte*)0xc4ab3=0xff; - - *(volatile byte*)0xc40c3=0xb1; - *(volatile byte*)0xc40c4=0x4a; - - BT_CLKPLL_EN=0xff; + enable_clock(CLKCLS_BT); + SYSCTRL_ROM_SWITCH = 0x94; + delay(500); + + *(volatile byte *)0xc4ab1 = 0x7f; + *(volatile byte *)0xc4ab2 = 0xff; + *(volatile byte *)0xc4ab3 = 0xff; + + *(volatile byte *)0xc40c3 = 0xb1; + *(volatile byte *)0xc40c4 = 0x4a; + + BT_CLKPLL_EN = 0xff; } Index: yc_systick.c =================================================================== --- /YC3121_SDK/fw/sdk/yc_systick.c (revision 669) +++ /YC3121_SDK/fw/sdk/yc_systick.c (working copy) @@ -15,102 +15,102 @@ static void sysTick_delay_ms(uint32_t ms)//MS MAX:0.35s { - _ASSERT(IS_DELAY_MS_VALUE(ms)); - - uint32_t ReloadValue = ms * ONE_MS; - ReloadValue -= 1; - - *SYSTICK_RVR =ReloadValue;//Set the reload value - *SYSTICK_CVR = 0; //clear the current value - *SYSTICK_CSR &= ~(1<< SYSTICK_CSR_TICKINT); - *SYSTICK_CSR |= ((SYSTICK_SYSCLOCK<>16)&0x01); + _ASSERT(IS_DELAY_MS_VALUE(ms)); - *SYSTICK_CSR &= ~SYSTICK_CSR_ENABLE; + uint32_t ReloadValue = ms * ONE_MS; + ReloadValue -= 1; + + *SYSTICK_RVR = ReloadValue; //Set the reload value + *SYSTICK_CVR = 0; //clear the current value + *SYSTICK_CSR &= ~(1 << SYSTICK_CSR_TICKINT); + *SYSTICK_CSR |= ((SYSTICK_SYSCLOCK << SYSTICK_CSR_CLKSOURCE) | \ + (1 << SYSTICK_CSR_ENABLE)); + while (!((*SYSTICK_CSR) >> 16) & 0x01); + + *SYSTICK_CSR &= ~SYSTICK_CSR_ENABLE; } void SysTick_Delay_Ms(uint32_t nms) -{ - uint32_t repeat = nms / 300; - uint32_t remain = nms % 300; - while (repeat) - { - sysTick_delay_ms(300); - repeat--; - } - if (remain) - sysTick_delay_ms(remain); +{ + uint32_t repeat = nms / 300; + uint32_t remain = nms % 300; + while (repeat) + { + sysTick_delay_ms(300); + repeat--; + } + if (remain) + sysTick_delay_ms(remain); } void SysTick_Delay_Us(uint32_t us)//US MAX: 0.35s { - _ASSERT(IS_DELAY_US_VALUE(us)); - - uint32_t ReloadValue=us*ONE_US; - ReloadValue-=1; - - *SYSTICK_RVR =ReloadValue;//Set the reload value - *SYSTICK_CVR = 0; //clear the current value - *SYSTICK_CSR &= ~(1<< SYSTICK_CSR_TICKINT); - *SYSTICK_CSR |= ((SYSTICK_SYSCLOCK<>16)&0x01); + _ASSERT(IS_DELAY_US_VALUE(us)); + + uint32_t ReloadValue = us * ONE_US; + ReloadValue -= 1; + + *SYSTICK_RVR = ReloadValue; //Set the reload value + *SYSTICK_CVR = 0; //clear the current value + *SYSTICK_CSR &= ~(1 << SYSTICK_CSR_TICKINT); + *SYSTICK_CSR |= ((SYSTICK_SYSCLOCK << SYSTICK_CSR_CLKSOURCE) | \ + (1 << SYSTICK_CSR_ENABLE)); + while (!((*SYSTICK_CSR) >> 16) & 0x01); - *SYSTICK_CSR &= ~SYSTICK_CSR_ENABLE; + *SYSTICK_CSR &= ~SYSTICK_CSR_ENABLE; } void SysTick_Config(uint32_t ReloadValue) { - _ASSERT(IS_RELOAD_VALUE(ReloadValue)); - - ReloadValue-=1; - - *SYSTICK_CSR &= ~(((uint32_t)1)<= interval) - { - return TRUE; - } - else - { - return FALSE; - } + start_tick = SysTick_GetTick() - start_tick; + if (start_tick < 0) + start_tick += TICK_MAX_VALUE; + if (((start_tick * (*SYSTICK_RVR)) / (CPU_MHZ / 1000)) >= interval) + { + return TRUE; + } + else + { + return FALSE; + } } uint32_t SysTick_GetRelativeTime(tick start_tick) { - start_tick = SysTick_GetTick() - start_tick; - if (start_tick < 0) - start_tick+=TICK_MAX_VALUE; - return ((start_tick*(*SYSTICK_RVR))/(CPU_MHZ/1000)); + start_tick = SysTick_GetTick() - start_tick; + if (start_tick < 0) + start_tick += TICK_MAX_VALUE; + return ((start_tick * (*SYSTICK_RVR)) / (CPU_MHZ / 1000)); } Index: yc_timer.h =================================================================== --- /YC3121_SDK/fw/sdk/yc_timer.h (revision 669) +++ /YC3121_SDK/fw/sdk/yc_timer.h (working copy) @@ -18,48 +18,48 @@ #include "yc3121.h" #include "yc_gpio.h" -/** - * @brief timer number Structure definition - */ +/** + * @brief timer number Structure definition + */ typedef enum { - TIM0= 0, - TIM1, - TIM2, - TIM3, - TIM4, - TIM5, - TIM6, - TIM7, - TIM8 -}TIM_NumTypeDef; + TIM0 = 0, + TIM1, + TIM2, + TIM3, + TIM4, + TIM5, + TIM6, + TIM7, + TIM8 +} TIM_NumTypeDef; #define ISTIMERNUM(TIMx) (TIMxTIMx)); - - TIM_Cmd(TIM_init_struct->TIMx, DISABLE); - TIM_PCNT(TIM_init_struct->TIMx) = TIM_init_struct->period; - if (TIM_init_struct->TIMx < TIM8) - TIM_CTRL |= (((((uint32_t)1)<TIMx*4); - else - TIM_CTRL1 |= (((((uint32_t)1)<TIMx)); + + TIM_Cmd(TIM_init_struct->TIMx, DISABLE); + TIM_PCNT(TIM_init_struct->TIMx) = TIM_init_struct->period; + if (TIM_init_struct->TIMx < TIM8) + TIM_CTRL |= (((((uint32_t)1) << TIM_CTRL_MODE) | (((uint32_t)1) << TIM_CTRL_AUTO_RELOAD)) << TIM_init_struct->TIMx * 4); + else + TIM_CTRL1 |= (((((uint32_t)1) << TIM_CTRL_MODE) | (((uint32_t)1) << TIM_CTRL_AUTO_RELOAD)) << 0); } void TIM_DeInit() { - disable_clock(CLKCLS_TIM); + disable_clock(CLKCLS_TIM); } void TIM_Cmd(TIM_NumTypeDef TIMx, FunctionalState NewState) { - _ASSERT(ISTIMERNUM(TIMx)); - - if (NewState == ENABLE) - { - if(TIMx < TIM8) - TIM_CTRL |= ((((uint32_t)1)<TIMx)); - - TIM_Cmd(PWM_init_struct->TIMx, DISABLE); - TIM_PCNT(PWM_init_struct->TIMx) = PWM_init_struct->HighLevelPeriod; - TIM_NCNT(PWM_init_struct->TIMx) = PWM_init_struct->LowLevelPeriod; - if (PWM_init_struct->SatrtLevel == OutputHigh) - { - if (PWM_init_struct->TIMx < TIM8) - TIM_CTRL |= ((((uint32_t)1)<TIMx*4); - else - TIM_CTRL1 |= ((((uint32_t)1)<TIMx < TIM8) - TIM_CTRL &= ~((((uint32_t)1)<TIMx*4); - else - TIM_CTRL1 &= ~((((uint32_t)1)<TIMx < TIM8) - TIM_CTRL &= ~((((uint32_t)1)<TIMx*4); - else - TIM_CTRL1 &= ~((((uint32_t)1)<TIMx)); + + TIM_Cmd(PWM_init_struct->TIMx, DISABLE); + TIM_PCNT(PWM_init_struct->TIMx) = PWM_init_struct->HighLevelPeriod; + TIM_NCNT(PWM_init_struct->TIMx) = PWM_init_struct->LowLevelPeriod; + if (PWM_init_struct->SatrtLevel == OutputHigh) + { + if (PWM_init_struct->TIMx < TIM8) + TIM_CTRL |= ((((uint32_t)1) << TIM_CTRL_START_LEVEL) << PWM_init_struct->TIMx * 4); + else + TIM_CTRL1 |= ((((uint32_t)1) << TIM_CTRL_START_LEVEL) << 0); + } + else + { + if (PWM_init_struct->TIMx < TIM8) + TIM_CTRL &= ~((((uint32_t)1) << TIM_CTRL_START_LEVEL) << PWM_init_struct->TIMx * 4); + else + TIM_CTRL1 &= ~((((uint32_t)1) << TIM_CTRL_START_LEVEL) << 0); + } + if (PWM_init_struct->TIMx < TIM8) + TIM_CTRL &= ~((((uint32_t)1) << TIM_CTRL_MODE) << PWM_init_struct->TIMx * 4); + else + TIM_CTRL1 &= ~((((uint32_t)1) << TIM_CTRL_MODE) << 0); } void TIM_SetPWMPeriod(TIM_NumTypeDef TIMx, uint32_t LowLevelPeriod, uint32_t HighLevelPeriod) { - _ASSERT(ISTIMERNUM(TIMx)); - - TIM_PCNT(TIMx) = HighLevelPeriod; - TIM_NCNT(TIMx) = LowLevelPeriod; -} - -void TIM_PWMDifferential(TIM_NumTypeDef TIMx,TIM_NumTypeDef TIMy, uint32_t LowLevelPeriod, uint32_t HighLevelPeriod) -{ - _ASSERT(ISTIMERNUM(TIMx)); - _ASSERT(ISTIMERNUM(TIMy)); - - uint32_t TDifferentialConfig; - - TIM_CTRL &= ~((1<<(TIMy*4))|(1<<(TIMx*4))); - TIM_PCNT(TIMx) = HighLevelPeriod; - TIM_NCNT(TIMx) = LowLevelPeriod; - TIM_PCNT(TIMy) = LowLevelPeriod; - TIM_NCNT(TIMy) = HighLevelPeriod; - TIM_CTRL &= ~(1<<(TIMx*4+1)); - TDifferentialConfig = TIM_CTRL; - TDifferentialConfig |= ((3<<(TIMy*4))|(1<<(TIMx*4))); - TIM_CTRL |= 1 << (TIMy*4+1); - delay((LowLevelPeriod-8)/4); - TIM_CTRL = TDifferentialConfig; + _ASSERT(ISTIMERNUM(TIMx)); + + TIM_PCNT(TIMx) = HighLevelPeriod; + TIM_NCNT(TIMx) = LowLevelPeriod; +} + +void TIM_PWMDifferential(TIM_NumTypeDef TIMx, TIM_NumTypeDef TIMy, uint32_t LowLevelPeriod, uint32_t HighLevelPeriod) +{ + _ASSERT(ISTIMERNUM(TIMx)); + _ASSERT(ISTIMERNUM(TIMy)); + + uint32_t TDifferentialConfig; + + TIM_CTRL &= ~((1 << (TIMy * 4)) | (1 << (TIMx * 4))); + TIM_PCNT(TIMx) = HighLevelPeriod; + TIM_NCNT(TIMx) = LowLevelPeriod; + TIM_PCNT(TIMy) = LowLevelPeriod; + TIM_NCNT(TIMy) = HighLevelPeriod; + TIM_CTRL &= ~(1 << (TIMx * 4 + 1)); + TDifferentialConfig = TIM_CTRL; + TDifferentialConfig |= ((3 << (TIMy * 4)) | (1 << (TIMx * 4))); + TIM_CTRL |= 1 << (TIMy * 4 + 1); + delay((LowLevelPeriod - 8) / 4); + TIM_CTRL = TDifferentialConfig; } Index: yc_trng.h =================================================================== --- /YC3121_SDK/fw/sdk/yc_trng.h (revision 669) +++ /YC3121_SDK/fw/sdk/yc_trng.h (working copy) @@ -4,7 +4,7 @@ #include "yc3121.h" /** - * @brief init TRNG + * @brief init TRNG * * @param none * Index: yc_trng.c =================================================================== --- /YC3121_SDK/fw/sdk/yc_trng.c (revision 669) +++ /YC3121_SDK/fw/sdk/yc_trng.c (working copy) @@ -9,14 +9,14 @@ */ void TRNG_Init(void) { - disable_intr(INTR_TRNG); - *(volatile int*)(0xf8524) = 0x87878787; - SYSCTRL_RNG_CTRL = 0x36077; //rng generation enable - while ((SYSCTRL_RNG_CTRL & (1<<28)) == 0) - { - } - SYSCTRL_RNG_CTRL = 0x36077; - SYSCTRL_RNG_CTRL = 0x16017; + disable_intr(INTR_TRNG); + *(volatile int *)(0xf8524) = 0x87878787; + SYSCTRL_RNG_CTRL = 0x36077; //rng generation enable + while ((SYSCTRL_RNG_CTRL & (1 << 28)) == 0) + { + } + SYSCTRL_RNG_CTRL = 0x36077; + SYSCTRL_RNG_CTRL = 0x16017; // enable_intr(INTR_TRNG); } @@ -29,34 +29,34 @@ */ void TRNG_Get(volatile unsigned long *rand) { - rand[0] = SYSCTRL_RNG_DATA(0); - rand[1] = SYSCTRL_RNG_DATA(1); - rand[2] = SYSCTRL_RNG_DATA(2); - rand[3] = SYSCTRL_RNG_DATA(3); + rand[0] = SYSCTRL_RNG_DATA(0); + rand[1] = SYSCTRL_RNG_DATA(1); + rand[2] = SYSCTRL_RNG_DATA(2); + rand[3] = SYSCTRL_RNG_DATA(3); } uint8_t GetTRNGData_8bit(void) { - return GetTRNGData(); + return GetTRNGData(); } int GetTRNGData(void) { - static uint32_t old_rng_data = 0; - uint32_t tmp = 0; - while (1) - { - tmp = SYSCTRL_RNG_DATA(0); - if ((tmp != old_rng_data) && (tmp != 0) && (tmp != 0xffffffff)) - { - old_rng_data = tmp; - break; - } - } - return tmp; + static uint32_t old_rng_data = 0; + uint32_t tmp = 0; + while (1) + { + tmp = SYSCTRL_RNG_DATA(0); + if ((tmp != old_rng_data) && (tmp != 0) && (tmp != 0xffffffff)) + { + old_rng_data = tmp; + break; + } + } + return tmp; } void Disable_Trng(void) { - SYSCTRL_HWCTRL(11) = 0; + SYSCTRL_HWCTRL(11) = 0; } Index: yc_uart.h =================================================================== --- /YC3121_SDK/fw/sdk/yc_uart.h (revision 669) +++ /YC3121_SDK/fw/sdk/yc_uart.h (working copy) @@ -12,23 +12,23 @@ /** @def time of UART receive data time out intterrupt. real time = regvalue*48 * @{ - */ + */ #define TIME_IT_TIMEOUT (uint16_t)0x01 -/** @defgroup USART_Mode +/** @defgroup USART_Mode * @{ - */ + */ #define Mode_Single_Line (1<<6) #define Mode_duplex (0<<6) #define IS_MODE(MODE) (((MODE) == Mode_Single_Line) ||\ ((MODE) == Mode_duplex)) /** * @} - */ + */ /** @ - * @defgroup USART_DataBits - */ + * @defgroup USART_DataBits + */ #define Databits_8b (0<<2) #define Databits_9b (1<<2) @@ -36,22 +36,22 @@ ((LENGTH) == Databits_9b)) /** * @} - */ + */ -/** @defgroup USART_Stop_Bits +/** @defgroup USART_Stop_Bits * @{ - */ + */ #define StopBits_1 (0<<3) #define StopBits_2 (1<<3) #define IS_USART_STOPBITS(STOPBITS) (((STOPBITS) == StopBits_1) || \ ((STOPBITS) == StopBits_2) ) /** * @} - */ + */ -/** @defgroup USART_Hardware_Flow_Control +/** @defgroup USART_Hardware_Flow_Control * @{ - */ + */ #define FlowCtrl_None (0<<4) #define FlowCtrl_Enable (1<<4) @@ -59,21 +59,21 @@ ((CONTROL) == FlowCtrl_Enable)) /** * @} - */ + */ /** @defgroup UART_Interrupt_Type_definition * @{ */ -#define UART_IT_TX 0x01 +#define UART_IT_TX 0x01 #define UART_IT_RX 0x02 #define IS_UART_IT(x) (x == UART_IT_TX)||(x == UART_IT_RX) /** * @} - */ + */ - /** @defgroup USART_Parity - * @{ - */ +/** @defgroup USART_Parity +* @{ +*/ #define Parity_None (0<<1) #define Parity_Even (0<<1) #define Parity_Odd (1<<1) @@ -83,69 +83,69 @@ /** * @} */ - - /** @defgroup USART_BaudRate - * @{ - */ + +/** @defgroup USART_BaudRate +* @{ +*/ #define IS_BAUDRATE(BAUDRATE) (((BAUDRATE) > 0x5B8) && ((BAUDRATE) < 0x0044AA21)) /** * @} */ - + typedef struct { - uint8_t Mode; /*!< Specifies wether the Receive or Transmit mode is enabled or disabled. + uint8_t Mode; /*!< Specifies wether the Receive or Transmit mode is enabled or disabled. This parameter can be a value of @ref USART_Mode */ - uint32_t BaudRate; /*!< This member configures the USART communication baud rate. */ + uint32_t BaudRate; /*!< This member configures the USART communication baud rate. */ - uint8_t DataBits; /*!< Specifies the number of data bits transmitted or received in a frame. + uint8_t DataBits; /*!< Specifies the number of data bits transmitted or received in a frame. This parameter can be a value of @ref USART_DataBits */ - uint8_t StopBits; /*!< Specifies the number of stop bits transmitted. + uint8_t StopBits; /*!< Specifies the number of stop bits transmitted. This parameter can be a value of @ref USART_Stop_Bits */ - uint8_t Parity; /*!< Specifies the parity mode. + uint8_t Parity; /*!< Specifies the parity mode. This parameter can be a value of @ref USART_Parity @note When parity is enabled, the computed parity is inserted at the MSB position of the transmitted data (9th bit when the word length is set to 9 data bits; 8th bit when the word length is set to 8 data bits). */ - uint8_t FlowCtrl; /*!< Specifies wether the hardware flow control mode is enabled or disabled. + uint8_t FlowCtrl; /*!< Specifies wether the hardware flow control mode is enabled or disabled. This parameter can be a value of @ref USART_Hardware_Flow_Control */ - - int RxBufLen; /*!< Specifies uart DMA Rx buff length */ - -}UART_InitTypeDef; - /** @defgroup UART_TypeDef - * @{ - */ + int RxBufLen; /*!< Specifies uart DMA Rx buff length */ + +} UART_InitTypeDef; + +/** @defgroup UART_TypeDef +* @{ +*/ typedef enum { - UART0 = 0, - UART1, -}UART_TypeDef; + UART0 = 0, + UART1, +} UART_TypeDef; #define IS_UART(UARTx) (UARTx == UART0 ||UARTx == UART1) - /** - * @} - */ +/** + * @} + */ /** - * @brief ENABLE or DISABLE UARTx auto flow control - * @param USARTx: Select the USART or the UART peripheral. + * @brief ENABLE or DISABLE UARTx auto flow control + * @param USARTx: Select the USART or the UART peripheral. * This parameter can be one of the following values: * UART0, UART1. - * @param NewState:ENABLE or DISABLE auto flow control + * @param NewState:ENABLE or DISABLE auto flow control * @retval None */ void UART_AutoFlowCtrlCmd(UART_TypeDef UARTx, FunctionalState NewState); /** * @brief Clear IT - * @param USARTx: Select the USART or the UART peripheral. + * @param USARTx: Select the USART or the UART peripheral. * This parameter can be one of the following values: * UART0, UART1. * @retval None @@ -154,8 +154,8 @@ /** * @brief DeInit UART - * @param UARTx: Select the UART peripheral. - * This parameter can be one of the following values: + * @param UARTx: Select the UART peripheral. + * This parameter can be one of the following values: * UART0, UART1. * @retval None */ @@ -163,18 +163,18 @@ /** * @brief Transmits datas via UART DMA . - * @param USARTx: Select the USART or the UART peripheral. + * @param USARTx: Select the USART or the UART peripheral. * This parameter can be one of the following values: * UART0, UART1. * @param buf: pointer to a buf that contains the data you want transmit. * @param len: the buf length * @retval None */ -void UART_DMASendBuf(UART_TypeDef UARTx,uint8_t* buf,int len); +void UART_DMASendBuf(UART_TypeDef UARTx, uint8_t *buf, int len); /** - * @brief Get IT Identity - * @param UARTx: Select the UART peripheral. + * @brief Get IT Identity + * @param UARTx: Select the UART peripheral. * @retval IT Identity */ uint8_t UART_GetITIdentity(UART_TypeDef UARTx); @@ -182,19 +182,19 @@ /** * @brief Initializes the USARTx peripheral according to the specified * parameters in the USART_InitStruct . - * @param UARTx: Select the UART peripheral. - * This parameter can be one of the following values: + * @param UARTx: Select the UART peripheral. + * This parameter can be one of the following values: * UART0, UART1. * @param USART_InitStruct: pointer to a USART_InitTypeDef structure - * that contains the configuration information for the specified USART + * that contains the configuration information for the specified USART * peripheral. * @retval None */ -void UART_Init(UART_TypeDef UARTx, UART_InitTypeDef* UART_InitStruct); +void UART_Init(UART_TypeDef UARTx, UART_InitTypeDef *UART_InitStruct); /** * @brief Judge Rx fifo full is or not. - * @param UARTx: Select the UART peripheral. + * @param UARTx: Select the UART peripheral. * @retval TRUE:Rx fifo is full. * FALSE:Rx fifo is not full */ @@ -202,7 +202,7 @@ /** * @brief Judge Rx fifo empty is or not. - * @param UARTx: Select the UART peripheral. + * @param UARTx: Select the UART peripheral. * @retval TRUE:Rx fifo is not empty. * FALSE:Rx fifo is empty; */ @@ -210,14 +210,14 @@ /** * @brief Judge UART is Busy or not - * @param UARTx: Select the UART peripheral. + * @param UARTx: Select the UART peripheral. * @retval None */ Boolean UART_IsUARTBusy(UART_TypeDef UARTx); /** * @brief Config Interrupt trigger mode - * @param USARTx: Select the USART or the UART peripheral. + * @param USARTx: Select the USART or the UART peripheral. * This parameter can be one of the following values: * UART0, UART1. * @param UART_IT: Interrupt trigger mode ,this param will the following values, @@ -230,7 +230,7 @@ /** * @brief Receive single data through the USARTx peripheral. - * @param USARTx: Select the USART or the UART peripheral. + * @param USARTx: Select the USART or the UART peripheral. * This parameter can be one of the following values: * UART0, UART1. * @retval None @@ -239,46 +239,46 @@ /** * @brief Receives datas through the UART DMA. - * @param USARTx: Select the USART or the UART peripheral. + * @param USARTx: Select the USART or the UART peripheral. * This parameter can be one of the following values: * UART0, UART1. * @param buf: pointer to a buf that contains the data you want receive. * @param len: the buf length * @retval None */ -int UART_RecvBuf(UART_TypeDef UARTx, uint8_t* buf, int len); +int UART_RecvBuf(UART_TypeDef UARTx, uint8_t *buf, int len); /** * @brief T ransmits datas via UART DMA,the function will return after datas is sent. - * @param USARTx: Select the USART or the UART peripheral. + * @param USARTx: Select the USART or the UART peripheral. * This parameter can be one of the following values: * UART0, UART1. * @param buf: pointer to a buf that contains the data you want transmit. * @param len: the buf length * @retval None */ -void UART_SendBuf(UART_TypeDef UARTx, uint8_t* buf, int len); +void UART_SendBuf(UART_TypeDef UARTx, uint8_t *buf, int len); /** * @brief UART Send One Data - * @param UARTx: Select the UART peripheral. + * @param UARTx: Select the UART peripheral. * @retval None */ void UART_SendData(UART_TypeDef UARTx, uint8_t Data); /** * @brief UART_SetITTimeout - * @param USARTx: Select the USART or the UART peripheral. + * @param USARTx: Select the USART or the UART peripheral. * This parameter can be one of the following values: * UART0, UART1. * timeout: 0x00~0xff * @retval None */ -void UART_SetITTimeout(UART_TypeDef UARTx,uint16_t timeout); +void UART_SetITTimeout(UART_TypeDef UARTx, uint16_t timeout); /** - * @brief Set the number of uart receive data intterupt trigger - * @param UARTx: Select the UART peripheral. + * @brief Set the number of uart receive data intterupt trigger + * @param UARTx: Select the UART peripheral. * This parameter can be one of the following values: * UART0, UART1. * @param Bcnt: if the number of receive datas greater than Bcnt,interrupt trigger @@ -292,7 +292,7 @@ * which will be initialized. * @retval None */ -void UART_StructInit(UART_InitTypeDef* UART_InitStruct); +void UART_StructInit(UART_InitTypeDef *UART_InitStruct); /** * @brief UART_ReceiveDataLen Index: yc_uart.c =================================================================== --- /YC3121_SDK/fw/sdk/yc_uart.c (revision 669) +++ /YC3121_SDK/fw/sdk/yc_uart.c (working copy) @@ -8,8 +8,8 @@ #include "yc_uart.h" #define uart_DMA_buf_len 1024 -uint8_t uart0_DMA_buf[uart_DMA_buf_len]={0}; -uint8_t uart1_DMA_buf[uart_DMA_buf_len]={0}; +uint8_t uart0_DMA_buf[uart_DMA_buf_len] = {0}; +uint8_t uart1_DMA_buf[uart_DMA_buf_len] = {0}; #define RX_ENABLE_BIT 0 #define RX_ENABLE (1 << RX_ENABLE_BIT) @@ -25,409 +25,409 @@ void UART_AutoFlowCtrlCmd(UART_TypeDef UARTx, FunctionalState NewState) { - _ASSERT(IS_UART(UARTx) ); + _ASSERT(IS_UART(UARTx)); - if (NewState == ENABLE) - { - switch(UARTx) - { - case UART0: - UART0_CTRL |= FlowCtrl_Enable; - break; - case UART1: - UART1_CTRL |= FlowCtrl_Enable; - break; - } - } - else - { - switch (UARTx) - { - case UART0: - UART0_CTRL &=(~FlowCtrl_Enable); - break; - case UART1: - UART1_CTRL &=(~FlowCtrl_Enable); - break; - } - } - return; + if (NewState == ENABLE) + { + switch (UARTx) + { + case UART0: + UART0_CTRL |= FlowCtrl_Enable; + break; + case UART1: + UART1_CTRL |= FlowCtrl_Enable; + break; + } + } + else + { + switch (UARTx) + { + case UART0: + UART0_CTRL &= (~FlowCtrl_Enable); + break; + case UART1: + UART1_CTRL &= (~FlowCtrl_Enable); + break; + } + } + return; } void UART_ClearIT(UART_TypeDef UARTx) { - uint8_t ITType = UART_GetITIdentity(UARTx); - UART_ITConfig(UARTx, ITType, DISABLE); + uint8_t ITType = UART_GetITIdentity(UARTx); + UART_ITConfig(UARTx, ITType, DISABLE); } void UART_DeInit(UART_TypeDef UARTx) { - _ASSERT(IS_UART(UARTx) ); + _ASSERT(IS_UART(UARTx)); - switch (UARTx) - { - case UART0: - UART0_CTRL = 0; - break; - case UART1: - UART1_CTRL = 0; - break; - } -} - -void UART_DMASendBuf(UART_TypeDef UARTx,uint8_t* buf, int len) -{ - _ASSERT(IS_UART(UARTx)); - _ASSERT(NULL != buf); - _ASSERT((len<0xffff)); - - if(UARTx==UART0) - { - DMA_SRC_ADDR(DMACH_UART0) = (int)buf; - DMA_LEN(DMACH_UART0) = (DMA_LEN(DMACH_UART0) & 0xffff) | len << 16; - DMA_START(DMACH_UART0)= (1<0)&&((UART0_STATUS>>16)>0)) - { - IT_Mode = UART_IT_RX; - } - else - { - if ((UART0_CTRL&(uint32_t)TX_INTR_ENABLE)) - { - IT_Mode = UART_IT_TX; - } - else - { - IT_Mode = FALSE; - } - } - - } - break; - - case UART1: - { - if (((UART1_CTRL&Set_RxITNum_Mask)>0)&&((UART1_STATUS>>16)>0)) - { - IT_Mode = UART_IT_RX; - } - else - { - if(UART1_CTRL&TX_INTR_ENABLE) - { - IT_Mode = UART_IT_TX; - } - else - { - IT_Mode = FALSE; - } - } - } - break; - } - return IT_Mode; -} - -void UART_Init(UART_TypeDef UARTx, UART_InitTypeDef* UART_InitStruct) -{ - #define RESET_BAUD (1<<7) - #define AUTO_BAUD (0<<7) - uint32_t reg_value = 0; - uint32_t temp_baudrate =0; - - _ASSERT(IS_UART(UARTx) ); - _ASSERT(IS_MODE(UART_InitStruct->Mode) ); - _ASSERT(IS_BAUDRATE(UART_InitStruct->BaudRate) ); - _ASSERT(IS_PARITY(UART_InitStruct->Parity) ); - _ASSERT( IS_FlowCtrl(UART_InitStruct->FlowCtrl) ); - _ASSERT( IS_USART_STOPBITS(UART_InitStruct->StopBits) ); - - temp_baudrate = ((48000000/UART_InitStruct->BaudRate)<<16); - - reg_value = RX_ENABLE | - UART_InitStruct->Parity | \ - UART_InitStruct->DataBits| \ - UART_InitStruct->StopBits| \ - UART_InitStruct->FlowCtrl| \ - UART_InitStruct->Mode | \ - RESET_BAUD | \ - temp_baudrate; - - if (UARTx == UART0 ) - { - UART0_CTRL = 0; - DMA_DEST_ADDR(DMACH_UART0) = (int)uart0_DMA_buf; - DMA_LEN(DMACH_UART0) = uart_DMA_buf_len; - DMA_CONFIG(DMACH_UART0) = 1; - DMA_START(DMACH_UART0) |= (1<<(DMA_RESET_BIT)); - DMA_START(DMACH_UART0) &= ~(1<<(DMA_RESET_BIT)); - UART0_CTRL = 0; - UART0_CTRL = reg_value; - } - else - { - UART1_CTRL = 0; - DMA_DEST_ADDR(DMACH_UART1) = (int)uart1_DMA_buf; - DMA_LEN(DMACH_UART1) = uart_DMA_buf_len; - DMA_CONFIG(DMACH_UART1) = 1; - DMA_START(DMACH_UART1) |= (1<<(DMA_RESET_BIT)); - DMA_START(DMACH_UART1) &= ~(1<<(DMA_RESET_BIT)); - UART1_CTRL = 0; - UART1_CTRL = reg_value; - } - return; + uint8_t IT_Mode = 0; + switch (UARTx) + { + case UART0: + { + if (((UART0_CTRL & Set_RxITNum_Mask) > 0) && ((UART0_STATUS >> 16) > 0)) + { + IT_Mode = UART_IT_RX; + } + else + { + if ((UART0_CTRL & (uint32_t)TX_INTR_ENABLE)) + { + IT_Mode = UART_IT_TX; + } + else + { + IT_Mode = FALSE; + } + } + + } + break; + + case UART1: + { + if (((UART1_CTRL & Set_RxITNum_Mask) > 0) && ((UART1_STATUS >> 16) > 0)) + { + IT_Mode = UART_IT_RX; + } + else + { + if (UART1_CTRL & TX_INTR_ENABLE) + { + IT_Mode = UART_IT_TX; + } + else + { + IT_Mode = FALSE; + } + } + } + break; + } + return IT_Mode; +} + +void UART_Init(UART_TypeDef UARTx, UART_InitTypeDef *UART_InitStruct) +{ +#define RESET_BAUD (1<<7) +#define AUTO_BAUD (0<<7) + uint32_t reg_value = 0; + uint32_t temp_baudrate = 0; + + _ASSERT(IS_UART(UARTx)); + _ASSERT(IS_MODE(UART_InitStruct->Mode)); + _ASSERT(IS_BAUDRATE(UART_InitStruct->BaudRate)); + _ASSERT(IS_PARITY(UART_InitStruct->Parity)); + _ASSERT(IS_FlowCtrl(UART_InitStruct->FlowCtrl)); + _ASSERT(IS_USART_STOPBITS(UART_InitStruct->StopBits)); + + temp_baudrate = ((48000000 / UART_InitStruct->BaudRate) << 16); + + reg_value = RX_ENABLE | + UART_InitStruct->Parity | \ + UART_InitStruct->DataBits | \ + UART_InitStruct->StopBits | \ + UART_InitStruct->FlowCtrl | \ + UART_InitStruct->Mode | \ + RESET_BAUD | \ + temp_baudrate; + + if (UARTx == UART0) + { + UART0_CTRL = 0; + DMA_DEST_ADDR(DMACH_UART0) = (int)uart0_DMA_buf; + DMA_LEN(DMACH_UART0) = uart_DMA_buf_len; + DMA_CONFIG(DMACH_UART0) = 1; + DMA_START(DMACH_UART0) |= (1 << (DMA_RESET_BIT)); + DMA_START(DMACH_UART0) &= ~(1 << (DMA_RESET_BIT)); + UART0_CTRL = 0; + UART0_CTRL = reg_value; + } + else + { + UART1_CTRL = 0; + DMA_DEST_ADDR(DMACH_UART1) = (int)uart1_DMA_buf; + DMA_LEN(DMACH_UART1) = uart_DMA_buf_len; + DMA_CONFIG(DMACH_UART1) = 1; + DMA_START(DMACH_UART1) |= (1 << (DMA_RESET_BIT)); + DMA_START(DMACH_UART1) &= ~(1 << (DMA_RESET_BIT)); + UART1_CTRL = 0; + UART1_CTRL = reg_value; + } + return; } Boolean UART_IsRXFIFOFull(UART_TypeDef UARTx) { #define BITRXFULL 1 - _ASSERT(IS_UART(UARTx) ); + _ASSERT(IS_UART(UARTx)); - if(UART0 == UARTx) - { - return (Boolean)(UART0_STATUS & (1 << BITRXFULL)); - } - else - { - return (Boolean)(UART1_STATUS & (1 << BITRXFULL)); - } + if (UART0 == UARTx) + { + return (Boolean)(UART0_STATUS & (1 << BITRXFULL)); + } + else + { + return (Boolean)(UART1_STATUS & (1 << BITRXFULL)); + } } Boolean UART_IsRXFIFONotEmpty(UART_TypeDef UARTx) { #define BITRXEMPTY 0 - _ASSERT(IS_UART(UARTx) ); + _ASSERT(IS_UART(UARTx)); - if(UART0 == UARTx) - { - return (Boolean)((UART0_STATUS >> 16) ? 1 : 0); - } - else - { - return (Boolean)((UART1_STATUS >> 16) ? 1 : 0); - } + if (UART0 == UARTx) + { + return (Boolean)((UART0_STATUS >> 16) ? 1 : 0); + } + else + { + return (Boolean)((UART1_STATUS >> 16) ? 1 : 0); + } } Boolean UART_IsUARTBusy(UART_TypeDef UARTx) { - _ASSERT(IS_UART(UARTx) ); + _ASSERT(IS_UART(UARTx)); - if(UART0 == UARTx) - { - return (Boolean)(!(DMA_STATUS(DMACH_UART0) & 1)); - } - else - { - return (Boolean)(!(DMA_STATUS(DMACH_UART1) & 1)); - } + if (UART0 == UARTx) + { + return (Boolean)(!(DMA_STATUS(DMACH_UART0) & 1)); + } + else + { + return (Boolean)(!(DMA_STATUS(DMACH_UART1) & 1)); + } } void UART_ITConfig(UART_TypeDef UARTx, uint32_t UART_IT, FunctionalState NewState) { - _ASSERT(IS_UART(UARTx) ); - _ASSERT(IS_UART_IT(UART_IT)); + _ASSERT(IS_UART(UARTx)); + _ASSERT(IS_UART_IT(UART_IT)); - switch (UARTx) - { - case UART0: - { - if (UART_IT == UART_IT_RX ) - { - if (NewState) - { - UART0_CTRL |= ((ENABLE << 8)); - } - else - { - UART0_CTRL &= ~Set_RxITNum_Mask; - } - - } - else if (UART_IT == UART_IT_TX) - { - UART0_CTRL &= (~TX_INTR_ENABLE); - UART0_CTRL |= (NewState << TX_INTR_ENABLE_BIT); - } - } - break; - - case UART1: - { - if (UART_IT == UART_IT_RX) - { - if (NewState) - { - UART1_CTRL |= ((ENABLE<<8)); - } - else - { - UART1_CTRL &= ~Set_RxITNum_Mask; - } - } - else if( UART_IT==UART_IT_TX ) - { - UART1_CTRL &= (uint32_t)~TX_INTR_ENABLE; - UART1_CTRL |= (NewState << TX_INTR_ENABLE_BIT); - } - } - break; - } + switch (UARTx) + { + case UART0: + { + if (UART_IT == UART_IT_RX) + { + if (NewState) + { + UART0_CTRL |= ((ENABLE << 8)); + } + else + { + UART0_CTRL &= ~Set_RxITNum_Mask; + } + + } + else if (UART_IT == UART_IT_TX) + { + UART0_CTRL &= (~TX_INTR_ENABLE); + UART0_CTRL |= (NewState << TX_INTR_ENABLE_BIT); + } + } + break; + + case UART1: + { + if (UART_IT == UART_IT_RX) + { + if (NewState) + { + UART1_CTRL |= ((ENABLE << 8)); + } + else + { + UART1_CTRL &= ~Set_RxITNum_Mask; + } + } + else if (UART_IT == UART_IT_TX) + { + UART1_CTRL &= (uint32_t)~TX_INTR_ENABLE; + UART1_CTRL |= (NewState << TX_INTR_ENABLE_BIT); + } + } + break; + } } uint8_t UART_ReceiveData(UART_TypeDef UARTx) { - _ASSERT(IS_UART(UARTx)); - - if(UART0 == UARTx) - { - return UART0_RDATA; - } - else - { - return UART1_RDATA; - } -} - -int UART_RecvBuf(UART_TypeDef UARTx, uint8_t* buf,int len) -{ - uint32_t length = 0; - volatile int* pstatus = NULL; - volatile unsigned char* pdata = NULL; - _ASSERT(IS_UART(UARTx) ); - _ASSERT(NULL != buf); - - if(UART0 == UARTx) - { - pstatus = &UART0_STATUS; - pdata = &UART0_RDATA; - } - else - { - pstatus = &UART1_STATUS; - pdata = &UART1_RDATA; - } - - while(( *pstatus >> 16) > 0) - { - if(length < len) - { - buf[length++] = *pdata; - } - else - { - break; - } - } - - return length; -} - - -void UART_SendBuf(UART_TypeDef UARTx,uint8_t* buf, int len) -{ - _ASSERT(IS_UART(UARTx)); - _ASSERT(NULL != buf); - _ASSERT((len < 0xffff)); - - if (UARTx == UART0) - { - DMA_SRC_ADDR(DMACH_UART0) = (int)buf; - DMA_LEN(DMACH_UART0) = (DMA_LEN(DMACH_UART0) & 0xffff) | len << 16; - DMA_START(DMACH_UART0) = (1<> 16) > 0) + { + if (length < len) + { + buf[length++] = *pdata; + } + else + { + break; + } + } + + return length; +} + + +void UART_SendBuf(UART_TypeDef UARTx, uint8_t *buf, int len) +{ + _ASSERT(IS_UART(UARTx)); + _ASSERT(NULL != buf); + _ASSERT((len < 0xffff)); + + if (UARTx == UART0) + { + DMA_SRC_ADDR(DMACH_UART0) = (int)buf; + DMA_LEN(DMACH_UART0) = (DMA_LEN(DMACH_UART0) & 0xffff) | len << 16; + DMA_START(DMACH_UART0) = (1 << DMA_START_BIT); + while ((!(DMA_STATUS(DMACH_UART0) & 1))); + } + else + { + DMA_SRC_ADDR(DMACH_UART1) = (int)buf; + DMA_LEN(DMACH_UART1) = (DMA_LEN(DMACH_UART1) & 0xffff) | len << 16; + DMA_START(DMACH_UART1) = (1 << DMA_START_BIT); + while ((!(DMA_STATUS(DMACH_UART1) & 1))); + } } void UART_SendData(UART_TypeDef UARTx, uint8_t Data) { - uint8_t buf[1] = {Data}; - - if (UARTx == UART0) - { - DMA_SRC_ADDR(DMACH_UART0) = (int)buf; - DMA_LEN(DMACH_UART0) = (DMA_LEN(DMACH_UART0) & 0xffff) | 1 << 16; - DMA_START(DMACH_UART0) = (1 << DMA_START_BIT); - while(!(DMA_STATUS(DMACH_UART0) & 1)); - } - else - { - DMA_SRC_ADDR(DMACH_UART1) = (int)buf; - DMA_LEN(DMACH_UART1) = (DMA_LEN(DMACH_UART1) & 0xffff) | 1 << 16; - DMA_START(DMACH_UART1) = (1<BaudRate = 9600; - UART_InitStruct->DataBits = Databits_8b; - UART_InitStruct->FlowCtrl = FlowCtrl_None ; - UART_InitStruct->Mode = Mode_duplex; - UART_InitStruct->StopBits = StopBits_1; - UART_InitStruct->Parity = 0; + _ASSERT(IS_UART(UARTx)); + + if (UART0 == UARTx) + { + UART0_CTRL = (UART0_CTRL & 0xffff00ff) | ((Bcnt & 0xff) << 8); + } + else + { + UART1_CTRL = (UART1_CTRL & 0xffff00ff) | ((Bcnt & 0xff) << 8); + } + +} + +void UART_StructInit(UART_InitTypeDef *UART_InitStruct) +{ + UART_InitStruct->BaudRate = 9600; + UART_InitStruct->DataBits = Databits_8b; + UART_InitStruct->FlowCtrl = FlowCtrl_None ; + UART_InitStruct->Mode = Mode_duplex; + UART_InitStruct->StopBits = StopBits_1; + UART_InitStruct->Parity = 0; } uint16_t UART_ReceiveDataLen(UART_TypeDef UARTx) { - _ASSERT(IS_UART(UARTx) ); + _ASSERT(IS_UART(UARTx)); - if(UART0 == UARTx) - { - return (uint16_t)(UART0_STATUS>>16); - } - else - { - return (uint16_t)(UART1_STATUS>>16); - } + if (UART0 == UARTx) + { + return (uint16_t)(UART0_STATUS >> 16); + } + else + { + return (uint16_t)(UART1_STATUS >> 16); + } } Index: yc_wdt.h =================================================================== --- /YC3121_SDK/fw/sdk/yc_wdt.h (revision 669) +++ /YC3121_SDK/fw/sdk/yc_wdt.h (working copy) @@ -14,19 +14,19 @@ #include "yc3121.h" -/** - * @brief timer number Structure definition - */ +/** + * @brief timer number Structure definition + */ typedef enum { - WDT_CPUReset = 0, - WDT_Interrupt, -}WDT_ModeTypeDef; + WDT_CPUReset = 0, + WDT_Interrupt, +} WDT_ModeTypeDef; #define ISWDTRELOAD(load) (load>0&&load<=0x1f) /** - * @brief Set reload counter + * @brief Set reload counter * @param Reload: Reload counter equal to 2^reload. * @retval none */ @@ -35,7 +35,7 @@ /** * @brief Set WDT mode * @param WDT_Mode : Select the following values : - * WDT_CPUReset + * WDT_CPUReset * WDT_Interrupt. * @retval none * @description If Select WDT_CPUReset Mode,the bit for WDT RESET will be set;if @@ -47,7 +47,7 @@ * @brief Get interrupt Status * @param none * @retval SET:interrupt ocuured. - */ + */ ITStatus WDT_GetITStatus(void); /** @@ -69,6 +69,6 @@ * @param none * @retval none */ - void WDT_ReloadCounter(void); +void WDT_ReloadCounter(void); #endif /*__YC_WDT_H__*/ Index: yc_wdt.c =================================================================== --- /YC3121_SDK/fw/sdk/yc_wdt.c (revision 669) +++ /YC3121_SDK/fw/sdk/yc_wdt.c (working copy) @@ -9,46 +9,46 @@ void WDT_SetReload(uint32_t Reload) { - uint32_t wdt_config = 0; + uint32_t wdt_config = 0; - _ASSERT( ISWDTRELOAD(Reload)); + _ASSERT(ISWDTRELOAD(Reload)); - wdt_config = WD_CONFIG; - wdt_config &= 0xE0; - wdt_config |= Reload; - WD_CONFIG = wdt_config; + wdt_config = WD_CONFIG; + wdt_config &= 0xE0; + wdt_config |= Reload; + WD_CONFIG = wdt_config; } void WDT_ReloadCounter(void) { - WD_KICK = COUNTER_RELOAD_KEY; + WD_KICK = COUNTER_RELOAD_KEY; } void WDT_Enable(void) { - WD_CONFIG |= (1<