void mico_system_delegate_config_success( mico_config_source_t source ) { config_delegate_log_trace(); #ifdef USE_MiCOKit_EXT char oled_show_line[OLED_DISPLAY_MAX_CHAR_PER_ROW+1] = {'\0'}; #endif config_delegate_log( "Wi-Fi configed by: %d", source ); MicoGpioOutputLow((mico_gpio_t)MICO_SYS_LED); #ifdef USE_MiCOKit_EXT memset(oled_show_line, '\0', OLED_DISPLAY_MAX_CHAR_PER_ROW+1); if(CONFIG_BY_AIRKISS == source){ snprintf(oled_show_line, OLED_DISPLAY_MAX_CHAR_PER_ROW+1, "%s", (uint8_t*)"Airkiss success "); }else if(CONFIG_BY_SOFT_AP == source){ snprintf(oled_show_line, OLED_DISPLAY_MAX_CHAR_PER_ROW+1, "%s", (uint8_t*)"SoftAP success "); }else if(CONFIG_BY_WAC == source){ snprintf(oled_show_line, OLED_DISPLAY_MAX_CHAR_PER_ROW+1, "%s", (uint8_t*)"WAC success "); }else if( (CONFIG_BY_EASYLINK_V2 == source) || (CONFIG_BY_EASYLINK_PLUS == source) || (CONFIG_BY_EASYLINK_MINUS == source) ){ snprintf(oled_show_line, OLED_DISPLAY_MAX_CHAR_PER_ROW+1, "%s", (uint8_t*)"Easylink success"); }else{ snprintf(oled_show_line, OLED_DISPLAY_MAX_CHAR_PER_ROW+1, "%s", (uint8_t*)"Unknown "); } OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_2, (uint8_t*)oled_show_line); OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_3, (uint8_t*)" "); OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_4, (uint8_t*)" "); #endif return; }
void init_platform( void ) { MicoGpioInitialize( (mico_gpio_t)MICO_SYS_LED, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( (mico_gpio_t)MICO_SYS_LED ); MicoGpioInitialize( (mico_gpio_t)MICO_RF_LED, OUTPUT_OPEN_DRAIN_NO_PULL ); MicoGpioOutputHigh( (mico_gpio_t)MICO_RF_LED ); // MicoGpioInitialize((mico_gpio_t)BOOT_SEL, INPUT_PULL_UP); //MicoGpioInitialize((mico_gpio_t)MFG_SEL, INPUT_PULL_UP); // Initialise EasyLink buttons MicoGpioInitialize( (mico_gpio_t)EasyLink_BUTTON, INPUT_PULL_UP ); mico_init_timer(&_button_EL_timer, RestoreDefault_TimeOut, _button_EL_Timeout_handler, NULL); MicoGpioEnableIRQ( (mico_gpio_t)EasyLink_BUTTON, IRQ_TRIGGER_BOTH_EDGES, _button_EL_irq_handler, NULL ); //MicoFlashInitialize( MICO_SPI_FLASH ); #ifdef USE_MiCOKit_EXT dc_motor_init( ); dc_motor_set( 0 ); rgb_led_init(); rgb_led_open(0, 0, 0); #endif }
static OSStatus platform_reset_wlan_powersave_clock( void ) { /* Tie the pin to ground */ MicoGpioInitialize( (mico_gpio_t) MICO_GPIO_WLAN_POWERSAVE_CLOCK, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( (mico_gpio_t) MICO_GPIO_WLAN_POWERSAVE_CLOCK ); return kNoErr; }
void init_platform( void ) { button_init_t init; MicoGpioInitialize( (mico_gpio_t)MICO_SYS_LED, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( (mico_gpio_t)MICO_SYS_LED ); MicoGpioInitialize( (mico_gpio_t)MICO_RF_LED, OUTPUT_OPEN_DRAIN_NO_PULL ); MicoGpioOutputHigh( (mico_gpio_t)MICO_RF_LED ); MicoGpioInitialize((mico_gpio_t)BOOT_SEL, INPUT_PULL_UP); MicoGpioInitialize((mico_gpio_t)MFG_SEL, INPUT_PULL_UP); init.gpio = EasyLink_BUTTON; init.pressed_func = PlatformEasyLinkButtonClickedCallback; init.long_pressed_func = PlatformEasyLinkButtonLongPressedCallback; init.long_pressed_timeout = 5000; button_init( IOBUTTON_EASYLINK, init ); #ifdef USE_MiCOKit_EXT dc_motor_init( ); dc_motor_set( 0 ); rgb_led_init(); rgb_led_open(0, 0, 0); #endif }
void setLightState_command(char *property, mico_Context_t * const inContext) { if(0==strcmp(property, "light 0")){ MicoGpioOutputLow( (mico_gpio_t)MICO_SYS_LED ); }else if(0==strcmp(property, "light 1")){ MicoGpioOutputHigh( (mico_gpio_t)MICO_SYS_LED ); } }
void MicoRfLed(bool onoff) { if (onoff) { MicoGpioOutputLow( (mico_gpio_t)MICO_RF_LED ); } else { MicoGpioOutputHigh( (mico_gpio_t)MICO_RF_LED ); } }
void ResetF411(void) { MicoGpioOutputLow(F411_RESET_PIN); mico_thread_msleep(100); MicoGpioOutputHigh(F411_RESET_PIN); mico_thread_msleep(100); AaSysLogPrint(LOGLEVEL_INF, "f411 rest done"); }
void init_platform_bootloader( void ) { MicoGpioInitialize( (mico_gpio_t)MICO_SYS_LED, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( (mico_gpio_t)MICO_SYS_LED ); MicoGpioInitialize( (mico_gpio_t)MICO_RF_LED, OUTPUT_OPEN_DRAIN_NO_PULL ); MicoGpioOutputHigh( (mico_gpio_t)MICO_RF_LED ); MicoGpioInitialize((mico_gpio_t)BOOT_SEL, INPUT_PULL_UP); MicoGpioInitialize((mico_gpio_t)MFG_SEL, INPUT_HIGH_IMPEDANCE); }
void ConfigWillStop( mico_Context_t * const inContext ) { (void)(inContext); config_delegate_log_trace(); mico_stop_timer(&_Led_EL_timer); mico_deinit_timer( &_Led_EL_timer ); MicoGpioOutputLow((mico_gpio_t)MICO_SYS_LED); return; }
void host_platform_reset_wifi( bool reset_asserted ) { if ( reset_asserted == true ) { MicoGpioOutputLow( (mico_gpio_t)WL_RESET ); } else { MicoGpioOutputHigh( (mico_gpio_t)WL_RESET ); } }
void host_platform_power_wifi( bool power_enabled ) { if ( power_enabled == true ) { MicoGpioOutputLow( (mico_gpio_t)WL_REG ); } else { MicoGpioOutputHigh( (mico_gpio_t)WL_REG ); } }
void init_platform_bootloader( void ) { OSStatus err = kNoErr; MicoGpioInitialize( (mico_gpio_t)MICO_SYS_LED, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( (mico_gpio_t)MICO_SYS_LED ); MicoGpioInitialize( (mico_gpio_t)MICO_RF_LED, OUTPUT_OPEN_DRAIN_NO_PULL ); MicoGpioOutputHigh( (mico_gpio_t)MICO_RF_LED ); MicoGpioInitialize((mico_gpio_t)BOOT_SEL, INPUT_PULL_UP); MicoGpioInitialize((mico_gpio_t)MFG_SEL, INPUT_PULL_UP); }
void init_platform( void ) { MicoGpioInitialize( (mico_gpio_t)MICO_SYS_LED, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( (mico_gpio_t)MICO_SYS_LED ); MicoGpioInitialize( (mico_gpio_t)MICO_RF_LED, OUTPUT_OPEN_DRAIN_NO_PULL ); MicoGpioOutputHigh( (mico_gpio_t)MICO_RF_LED ); MicoGpioInitialize((mico_gpio_t)BOOT_SEL, INPUT_PULL_UP); MicoGpioInitialize((mico_gpio_t)MFG_SEL, INPUT_PULL_UP); // Initialise EasyLink buttons MicoGpioInitialize( (mico_gpio_t)EasyLink_BUTTON, INPUT_PULL_UP ); mico_init_timer(&_button_EL_timer, RestoreDefault_TimeOut, _button_EL_Timeout_handler, NULL); MicoGpioEnableIRQ( (mico_gpio_t)EasyLink_BUTTON, IRQ_TRIGGER_BOTH_EDGES, _button_EL_irq_handler, NULL ); }
void init_platform_bootloader( void ) { MicoGpioInitialize( MICO_SYS_LED, OUTPUT_PUSH_PULL ); MicoGpioOutputHigh( MICO_SYS_LED ); MicoGpioInitialize( MICO_RF_LED, OUTPUT_OPEN_DRAIN_NO_PULL ); MicoGpioOutputHigh( MICO_RF_LED ); MicoGpioInitialize(BOOT_SEL, INPUT_PULL_UP); MicoGpioInitialize(MFG_SEL, INPUT_PULL_UP); #ifdef USE_MiCOKit_EXT MicoGpioInitialize( Arduino_D9, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( Arduino_D9 ); #endif }
void init_platform( void ) { MicoGpioInitialize( (mico_gpio_t)MICO_SYS_LED, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( (mico_gpio_t)MICO_SYS_LED ); MicoGpioInitialize( (mico_gpio_t)MICO_RF_LED, OUTPUT_OPEN_DRAIN_NO_PULL ); MicoGpioOutputHigh( (mico_gpio_t)MICO_RF_LED ); // Initialise EasyLink buttons MicoGpioInitialize( (mico_gpio_t)EasyLink_BUTTON, INPUT_HIGH_IMPEDANCE ); mico_init_timer(&_button_EL_timer, RestoreDefault_TimeOut, _button_EL_Timeout_handler, NULL); MicoGpioEnableIRQ( (mico_gpio_t)EasyLink_BUTTON, IRQ_TRIGGER_BOTH_EDGES, _button_EL_irq_handler, NULL ); #ifdef USE_MiCOKit_EXT dc_motor_init( ); dc_motor_set( 0 ); #endif }
void init_platform( void ) { MicoGpioInitialize( (mico_gpio_t)MICO_SYS_LED, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( (mico_gpio_t)MICO_SYS_LED ); MicoGpioInitialize( (mico_gpio_t)MICO_RF_LED, OUTPUT_OPEN_DRAIN_NO_PULL ); MicoGpioOutputHigh( (mico_gpio_t)MICO_RF_LED ); // Initialise EasyLink buttons MicoGpioInitialize( (mico_gpio_t)EasyLink_BUTTON, INPUT_PULL_UP ); mico_init_timer(&_button_EL_timer, RestoreDefault_TimeOut, _button_EL_Timeout_handler, NULL); MicoGpioEnableIRQ( (mico_gpio_t)EasyLink_BUTTON, IRQ_TRIGGER_BOTH_EDGES, _button_EL_irq_handler, NULL ); // Initialise Standby/wakeup switcher MicoGpioInitialize( (mico_gpio_t)Standby_SEL, INPUT_PULL_UP ); MicoGpioEnableIRQ( (mico_gpio_t)Standby_SEL , IRQ_TRIGGER_FALLING_EDGE, _button_STANDBY_irq_handler, NULL); MicoFlashInitialize( MICO_SPI_FLASH ); }
void init_platform_bootloader( void ) { MicoGpioInitialize( (mico_gpio_t)MICO_SYS_LED, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( (mico_gpio_t)MICO_SYS_LED ); MicoGpioInitialize( (mico_gpio_t)MICO_RF_LED, OUTPUT_OPEN_DRAIN_NO_PULL ); MicoGpioOutputHigh( (mico_gpio_t)MICO_RF_LED ); MicoGpioInitialize((mico_gpio_t)BOOT_SEL, INPUT_PULL_UP); MicoGpioInitialize((mico_gpio_t)MFG_SEL, INPUT_HIGH_IMPEDANCE); #ifdef USE_MiCOKit_EXT dc_motor_init( ); dc_motor_set( 0 ); rgb_led_init(); rgb_led_open(0, 0, 0); #endif }
void ConfigWillStop( mico_Context_t * const inContext ) { (void)(inContext); config_delegate_log_trace(); #ifdef USE_MiCOKit_EXT char oled_show_line[OLED_DISPLAY_MAX_CHAR_PER_ROW+1] = {'\0'}; #endif mico_stop_timer(&_Led_EL_timer); mico_deinit_timer( &_Led_EL_timer ); MicoGpioOutputLow((mico_gpio_t)MICO_SYS_LED); #ifdef USE_MiCOKit_EXT memset(oled_show_line, '\0', OLED_DISPLAY_MAX_CHAR_PER_ROW+1); snprintf(oled_show_line, OLED_DISPLAY_MAX_CHAR_PER_ROW+1, "%s", (uint8_t*)"Config "); OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_2, (uint8_t*)oled_show_line); OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_3, " Stop. "); OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_4, " "); #endif return; }
static void _button_EL_irq_handler( void* arg ) { (void)(arg); int interval = -1; mico_start_timer(&_button_EL_timer); if ( MicoGpioInputGet( (mico_gpio_t)EasyLink_BUTTON ) == 0 ) { _default_start_time = mico_get_time()+1; mico_start_timer(&_button_EL_timer); MicoGpioEnableIRQ( (mico_gpio_t)EasyLink_BUTTON, IRQ_TRIGGER_RISING_EDGE, _button_EL_irq_handler, NULL ); } else { interval = mico_get_time() + 1 - _default_start_time; if ( (_default_start_time != 0) && interval > 50 && interval < RestoreDefault_TimeOut){ /* EasyLink button clicked once */ PlatformEasyLinkButtonClickedCallback(); //platform_log("PlatformEasyLinkButtonClickedCallback!"); MicoGpioOutputLow( (mico_gpio_t)MICO_RF_LED ); MicoGpioEnableIRQ( (mico_gpio_t)EasyLink_BUTTON, IRQ_TRIGGER_FALLING_EDGE, _button_EL_irq_handler, NULL ); } mico_stop_timer(&_button_EL_timer); _default_start_time = 0; } }
void init_platform_bootloader( void ) { OSStatus err = kNoErr; MicoGpioInitialize( (mico_gpio_t)MICO_SYS_LED, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( (mico_gpio_t)MICO_SYS_LED ); MicoGpioInitialize( (mico_gpio_t)MICO_RF_LED, OUTPUT_OPEN_DRAIN_NO_PULL ); MicoGpioOutputHigh( (mico_gpio_t)MICO_RF_LED ); MicoGpioInitialize((mico_gpio_t)BOOT_SEL, INPUT_PULL_UP); MicoGpioInitialize((mico_gpio_t)MFG_SEL, INPUT_PULL_UP); /* Specific operations used in EMW3165 production */ #define NEED_RF_DRIVER_COPY_BASE ((uint32_t)0x08008000) #define TEMP_RF_DRIVER_BASE ((uint32_t)0x08040000) #define TEMP_RF_DRIVER_END ((uint32_t)0x0807FFFF) const uint8_t isDriverNeedCopy = *(uint8_t *)(NEED_RF_DRIVER_COPY_BASE); const uint32_t totalLength = ( DRIVER_FLASH_SIZE < 0x40000)? DRIVER_FLASH_SIZE:0x40000; const uint8_t crcResult = *(uint8_t *)(TEMP_RF_DRIVER_END); uint8_t targetCrcResult = 0; uint32_t copyLength; uint32_t destStartAddress_tmp = DRIVER_START_ADDRESS; uint32_t sourceStartAddress_tmp = TEMP_RF_DRIVER_BASE; uint32_t i; if ( isDriverNeedCopy != 0x0 ) return; platform_log( "Bootloader start to copy RF driver..." ); /* Copy RF driver to SPI flash */ err = MicoFlashInitialize( (mico_flash_t)MICO_FLASH_FOR_DRIVER ); require_noerr(err, exit); err = MicoFlashInitialize( (mico_flash_t)MICO_INTERNAL_FLASH ); require_noerr(err, exit); err = MicoFlashErase( MICO_FLASH_FOR_DRIVER, DRIVER_START_ADDRESS, DRIVER_END_ADDRESS ); require_noerr(err, exit); platform_log( "Time: %d", mico_get_time_no_os() ); for(i = 0; i <= totalLength/SizePerRW; i++){ if( i == totalLength/SizePerRW ){ if(totalLength%SizePerRW) copyLength = totalLength%SizePerRW; else break; }else{ copyLength = SizePerRW; } printf("."); err = MicoFlashRead( MICO_INTERNAL_FLASH, &sourceStartAddress_tmp, data , copyLength ); require_noerr( err, exit ); err = MicoFlashWrite( MICO_FLASH_FOR_DRIVER, &destStartAddress_tmp, data, copyLength); require_noerr(err, exit); } printf("\r\n"); /* Check CRC-8 check-sum */ platform_log( "Bootloader start to verify RF driver..." ); sourceStartAddress_tmp = TEMP_RF_DRIVER_BASE; destStartAddress_tmp = DRIVER_START_ADDRESS; for(i = 0; i <= totalLength/SizePerRW; i++){ if( i == totalLength/SizePerRW ){ if(totalLength%SizePerRW) copyLength = totalLength%SizePerRW; else break; }else{ copyLength = SizePerRW; } printf("."); err = MicoFlashRead( MICO_FLASH_FOR_DRIVER, &destStartAddress_tmp, data, copyLength ); require_noerr( err, exit ); targetCrcResult = CRC8_Table(targetCrcResult, data, copyLength); } printf("\r\n"); //require_string( crcResult == targetCrcResult, exit, "Check-sum error" ); if( crcResult != targetCrcResult ){ platform_log("Check-sum error"); while(1); } /* Clear RF driver from temperary storage */ platform_log("Bootloader start to clear RF driver temporary storage..."); err = MicoFlashInitialize( (mico_flash_t)MICO_INTERNAL_FLASH ); require_noerr(err, exit); /* Clear copy tag */ err = MicoFlashErase(MICO_INTERNAL_FLASH, NEED_RF_DRIVER_COPY_BASE, NEED_RF_DRIVER_COPY_BASE); require_noerr(err, exit); exit: MicoFlashFinalize( MICO_INTERNAL_FLASH ); MicoFlashFinalize( MICO_FLASH_FOR_DRIVER ); }
OSStatus host_platform_bus_init( void ) { SPI_InitTypeDef spi_init; DMA_InitTypeDef dma_init_structure; GPIO_InitTypeDef gpio_init_structure; NVIC_InitTypeDef nvic_init_structure; MCU_CLOCKS_NEEDED(); mico_rtos_init_semaphore(&spi_transfer_finished_semaphore, 1); /* Enable SPI_SLAVE DMA clock */ RCC_AHB1PeriphClockCmd( SPIX_DMA_CLK, ENABLE ); /* Enable SPI_SLAVE Periph clock */ SPIX_CLK_FUNCTION( SPIX_CLK, ENABLE ); /* Enable GPIO Bank B & C */ RCC_AHB1PeriphClockCmd( SPI_BUS_CLOCK_BANK_CLK | SPI_BUS_MISO_BANK_CLK | SPI_BUS_MOSI_BANK_CLK | SPI_BUS_CS_BANK_CLK | SPI_IRQ_CLK, ENABLE ); /* Enable SYSCFG. Needed for selecting EXTI interrupt line */ RCC_APB2PeriphClockCmd( RCC_APB2Periph_SYSCFG, ENABLE ); /* Setup the interrupt input for WLAN_IRQ */ gpio_init_structure.GPIO_Mode = GPIO_Mode_IN; gpio_init_structure.GPIO_PuPd = GPIO_PuPd_NOPULL; gpio_init_structure.GPIO_Speed = GPIO_Speed_100MHz; gpio_init_structure.GPIO_Pin = ( 1 << SPI_IRQ_PIN ); GPIO_Init( SPI_IRQ_BANK, &gpio_init_structure ); gpio_irq_enable(SPI_IRQ_BANK, SPI_IRQ_PIN, IRQ_TRIGGER_RISING_EDGE, spi_irq_handler, 0); /* Setup the SPI lines */ /* Setup SPI slave select GPIOs */ gpio_init_structure.GPIO_Mode = GPIO_Mode_AF; gpio_init_structure.GPIO_OType = GPIO_OType_PP; gpio_init_structure.GPIO_Speed = GPIO_Speed_100MHz; gpio_init_structure.GPIO_Pin = ( 1 << SPI_BUS_CLOCK_PIN ) | ( 1 << SPI_BUS_MISO_PIN ) | ( 1 << SPI_BUS_MOSI_PIN ); GPIO_Init( SPI_BUS_CLOCK_BANK, &gpio_init_structure ); GPIO_PinAFConfig( SPI_BUS_CLOCK_BANK, SPI_BUS_CLOCK_PIN, SPIX_AF ); GPIO_PinAFConfig( SPI_BUS_MISO_BANK, SPI_BUS_MISO_PIN, SPIX_AF ); GPIO_PinAFConfig( SPI_BUS_MOSI_BANK, SPI_BUS_MOSI_PIN, SPIX_AF ); /* Setup SPI slave select GPIOs */ gpio_init_structure.GPIO_Mode = GPIO_Mode_OUT; gpio_init_structure.GPIO_OType = GPIO_OType_PP; gpio_init_structure.GPIO_Speed = GPIO_Speed_100MHz; gpio_init_structure.GPIO_Pin = ( 1 << SPI_BUS_CS_PIN ); GPIO_Init( SPI_BUS_CS_BANK, &gpio_init_structure ); GPIO_SetBits( SPI_BUS_CS_BANK, ( 1 << SPI_BUS_CS_PIN ) ); /* Set CS high (disabled) */ /* Set GPIO_B[1:0] to 01 to put WLAN module into gSPI mode */ MicoGpioInitialize( (mico_gpio_t)WL_GPIO0, OUTPUT_PUSH_PULL ); MicoGpioOutputHigh( (mico_gpio_t)WL_GPIO0 ); MicoGpioInitialize( (mico_gpio_t)WL_GPIO1, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( (mico_gpio_t)WL_GPIO1 ); /* Setup DMA for SPIX RX */ DMA_DeInit( SPIX_DMA_RX_STREAM ); dma_init_structure.DMA_Channel = SPIX_DMA_RX_CHANNEL; dma_init_structure.DMA_PeripheralBaseAddr = (uint32_t) &SPIX->DR; dma_init_structure.DMA_Memory0BaseAddr = 0; dma_init_structure.DMA_DIR = DMA_DIR_PeripheralToMemory; dma_init_structure.DMA_BufferSize = 0; dma_init_structure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; dma_init_structure.DMA_MemoryInc = DMA_MemoryInc_Enable; dma_init_structure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; dma_init_structure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; dma_init_structure.DMA_Mode = DMA_Mode_Normal; dma_init_structure.DMA_Priority = DMA_Priority_VeryHigh; dma_init_structure.DMA_FIFOMode = DMA_FIFOMode_Disable; dma_init_structure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full; dma_init_structure.DMA_MemoryBurst = DMA_MemoryBurst_Single; dma_init_structure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; DMA_Init( SPIX_DMA_RX_STREAM, &dma_init_structure ); /* Setup DMA for SPIX TX */ DMA_DeInit( SPIX_DMA_TX_STREAM ); dma_init_structure.DMA_Channel = SPIX_DMA_TX_CHANNEL; dma_init_structure.DMA_PeripheralBaseAddr = (uint32_t) &SPIX->DR; dma_init_structure.DMA_Memory0BaseAddr = 0; dma_init_structure.DMA_DIR = DMA_DIR_MemoryToPeripheral; dma_init_structure.DMA_BufferSize = 0; dma_init_structure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; dma_init_structure.DMA_MemoryInc = DMA_MemoryInc_Enable; dma_init_structure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; dma_init_structure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; dma_init_structure.DMA_Mode = DMA_Mode_Normal; dma_init_structure.DMA_Priority = DMA_Priority_VeryHigh; dma_init_structure.DMA_FIFOMode = DMA_FIFOMode_Disable; dma_init_structure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full; dma_init_structure.DMA_MemoryBurst = DMA_MemoryBurst_Single; dma_init_structure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; DMA_Init( SPIX_DMA_TX_STREAM, &dma_init_structure ); /* Must be lower priority than the value of configMAX_SYSCALL_INTERRUPT_PRIORITY */ /* otherwise FreeRTOS will not be able to mask the interrupt */ /* keep in mind that ARMCM3 interrupt priority logic is inverted, the highest value */ /* is the lowest priority */ nvic_init_structure.NVIC_IRQChannel = SPIX_DMA_RX_IRQ_CHANNEL; nvic_init_structure.NVIC_IRQChannelPreemptionPriority = (uint8_t) 0x3; nvic_init_structure.NVIC_IRQChannelSubPriority = 0x0; nvic_init_structure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init( &nvic_init_structure ); DMA_ITConfig(SPIX_DMA_RX_STREAM, DMA_IT_TC, ENABLE); /* Enable DMA for TX */ SPI_I2S_DMACmd( SPIX, SPI_I2S_DMAReq_Tx | SPI_I2S_DMAReq_Rx, ENABLE ); /* Setup SPI */ spi_init.SPI_Direction = SPI_Direction_2Lines_FullDuplex; spi_init.SPI_Mode = SPI_Mode_Master; spi_init.SPI_DataSize = SPI_DataSize_8b; spi_init.SPI_CPOL = SPI_CPOL_High; spi_init.SPI_CPHA = SPI_CPHA_2Edge; spi_init.SPI_NSS = SPI_NSS_Soft; spi_init.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2; spi_init.SPI_FirstBit = SPI_FirstBit_MSB; spi_init.SPI_CRCPolynomial = (uint16_t) 7; /* Init SPI and enable it */ SPI_Init( SPIX, &spi_init ); SPI_Cmd( SPIX, ENABLE ); MCU_CLOCKS_NOT_NEEDED(); return kNoErr; }
OSStatus host_platform_spi_transfer( bus_transfer_direction_t dir, uint8_t* buffer, uint16_t buffer_length ) { OSStatus result; uint8_t *junk; platform_mcu_powersave_disable(); #ifdef USE_OWN_SPI_DRV pdc_packet_t pdc_spi_packet; pdc_spi_packet.ul_addr = (uint32_t)buffer; pdc_spi_packet.ul_size = buffer_length; pdc_tx_init(spi_m_pdc, &pdc_spi_packet, NULL); if ( dir == BUS_READ ) { pdc_spi_packet.ul_addr = (uint32_t)buffer; pdc_spi_packet.ul_size = buffer_length; } if ( dir == BUS_WRITE ) { junk = malloc(buffer_length); pdc_spi_packet.ul_addr = (uint32_t)junk; pdc_spi_packet.ul_size = buffer_length; } pdc_rx_init(spi_m_pdc, &pdc_spi_packet, NULL); #if 0 if ( dir == BUS_WRITE ) { spi_enable_interrupt(SPI_MASTER_BASE, SPI_IER_ENDTX); NVIC_EnableIRQ(SPI_IRQn); } else { spi_enable_interrupt(SPI_MASTER_BASE, SPI_IER_ENDRX); NVIC_EnableIRQ(SPI_IRQn); } #endif //platform_log("dir = %d, len = %d",dir, buffer_length);//TBD #ifndef HARD_CS_NSS0 MicoGpioOutputLow( MICO_GPIO_15 ); #endif /* Enable the RX and TX PDC transfer requests */ pdc_enable_transfer(spi_m_pdc, PERIPH_PTCR_TXTEN | PERIPH_PTCR_RXTEN);//pdc buffer address increase automatic. //platform_log("pdc status = 0x%x",pdc_read_status(spi_m_pdc)); #ifndef NO_MICO_RTOS result = mico_rtos_get_semaphore( &spi_transfer_finished_semaphore, 100 ); #else /* Waiting transfer done*/ while((spi_read_status(SPI_MASTER_BASE) & SPI_SR_RXBUFF) == 0) { __asm("wfi"); } #endif if ( dir == BUS_WRITE ) { if (junk) free(junk); } /* Disable the RX and TX PDC transfer requests */ pdc_disable_transfer(spi_m_pdc, PERIPH_PTCR_RXTDIS | PERIPH_PTCR_TXTDIS); #ifndef HARD_CS_NSS0 MicoGpioOutputHigh( MICO_GPIO_15 ); #endif #if 1 //clear PDC Perph Status flags pdc_spi_packet.ul_addr = NULL; pdc_spi_packet.ul_size = 3; pdc_tx_init(spi_m_pdc, &pdc_spi_packet, NULL); pdc_rx_init(spi_m_pdc, &pdc_spi_packet, NULL); #endif #else //spi_master_vec : tx_dscr[0].data = buffer; tx_dscr[0].length = buffer_length; tx_dscr[1].data = NULL; tx_dscr[1].length = 0; //if ( dir == BUS_READ ) { rx_dscr[0].data = buffer; rx_dscr[0].length = buffer_length; //} else { // rx_dscr[0].data = &junk; // rx_dscr[0].length = 0; //} rx_dscr[1].data = NULL; rx_dscr[1].length = 0; #ifndef HARD_CS_NSS0 mico_gpio_output_low( MICO_GPIO_15 ); #endif if (spi_master_vec_transceive_buffer_wait(&spi_master, tx_dscr, rx_dscr) != STATUS_OK) { platform_log("STATUS = -1"); return kGeneralErr; } #ifndef HARD_CS_NSS0 mico_gpio_output_high( MICO_GPIO_15 ); #endif #endif /* USE_OWN_SPI_DR */ platform_mcu_powersave_enable(); #ifdef USE_OWN_SPI_DRV return result; #else return 0; #endif }
OSStatus MicoSpiTransfer( const mico_spi_device_t* spi, mico_spi_message_segment_t* segments, uint16_t number_of_segments ) { OSStatus result = kNoErr; uint16_t i; uint32_t count = 0; check_string( (spi != NULL) && (segments != NULL) && (number_of_segments != 0), "Bad args"); MicoMcuPowerSaveConfig(false); /* If the given SPI device is not the current SPI device, initialise */ if ( spi != current_spi_device ) { MicoSpiInitialize( spi ); } /* Activate chip select */ MicoGpioOutputLow(spi->chip_select); for ( i = 0; i < number_of_segments; i++ ) { /* Check if we are using DMA */ if ( spi->mode & SPI_USE_DMA ) { spi_dma_config( spi, &segments[i] ); result = spi_dma_transfer( spi ); if ( result != kNoErr ) { goto cleanup_transfer; } } else { /* in interrupt-less mode */ if ( spi->bits == 8 ) { const uint8_t* send_ptr = ( const uint8_t* )segments[i].tx_buffer; uint8_t* rcv_ptr = ( uint8_t* )segments[i].rx_buffer; count = segments[i].length; while ( count-- ) { uint16_t data; if ( send_ptr != NULL ) { data = *send_ptr; send_ptr++; } else { data = 0xFF; } /* Wait until the transmit buffer is empty */ while ( SPI_I2S_GetFlagStatus( spi_mapping[spi->port].spi_regs, SPI_I2S_FLAG_TXE ) == RESET ) {} /* Send the byte */ SPI_I2S_SendData( spi_mapping[spi->port].spi_regs, data ); /* Wait until a data is received */ while ( SPI_I2S_GetFlagStatus( spi_mapping[spi->port].spi_regs, SPI_I2S_FLAG_RXNE ) == RESET ) {} /* Get the received data */ data = SPI_I2S_ReceiveData( spi_mapping[spi->port].spi_regs ); if ( rcv_ptr != NULL ) { *rcv_ptr++ = (uint8_t)data; } } } else if ( spi->bits == 16 ) { const uint16_t* send_ptr = (const uint16_t *) segments[i].tx_buffer; uint16_t* rcv_ptr = (uint16_t *) segments[i].rx_buffer; /* Check that the message length is a multiple of 2 */ if ( ( count % 2 ) == 0 ) { result = kGeneralErr; goto cleanup_transfer; } while ( count != 0) { uint16_t data = 0xFFFF; count -= 2; if ( send_ptr != NULL ) { data = *send_ptr++; } /* Wait until the transmit buffer is empty */ while ( SPI_I2S_GetFlagStatus( spi_mapping[spi->port].spi_regs, SPI_I2S_FLAG_TXE ) == RESET ) {} /* Send the byte */ SPI_I2S_SendData( spi_mapping[spi->port].spi_regs, data ); /* Wait until a data is received */ while ( SPI_I2S_GetFlagStatus( spi_mapping[spi->port].spi_regs, SPI_I2S_FLAG_RXNE ) == RESET ) {} /* Get the received data */ data = SPI_I2S_ReceiveData( spi_mapping[spi->port].spi_regs ); if ( rcv_ptr != NULL ) { *rcv_ptr++ = data; } } } } } cleanup_transfer: MicoGpioOutputHigh(spi->chip_select); MicoMcuPowerSaveConfig(true); return result; }
void init_platform_bootloader( void ) { CRC8_Context crc; OSStatus err = kNoErr; mico_logic_partition_t *rf_partition = MicoFlashGetInfo( MICO_PARTITION_RF_FIRMWARE ); MicoGpioInitialize( (mico_gpio_t)MICO_SYS_LED, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( (mico_gpio_t)MICO_SYS_LED ); MicoGpioInitialize( (mico_gpio_t)MICO_RF_LED, OUTPUT_OPEN_DRAIN_NO_PULL ); MicoGpioOutputHigh( (mico_gpio_t)MICO_RF_LED ); MicoGpioInitialize((mico_gpio_t)BOOT_SEL, INPUT_PULL_UP); MicoGpioInitialize((mico_gpio_t)MFG_SEL, INPUT_PULL_UP); #ifdef USE_MiCOKit_EXT dc_motor_init( ); dc_motor_set( 0 ); rgb_led_init(); rgb_led_open(0, 0, 0); #endif /* Specific operations used in EMW3165 production */ #define NEED_RF_DRIVER_COPY_BASE ((uint32_t)0x08008000) #define TEMP_RF_DRIVER_BASE ((uint32_t)0x08040000) #define TEMP_RF_DRIVER_END ((uint32_t)0x0807FFFF) const uint8_t isDriverNeedCopy = *(uint8_t *)(NEED_RF_DRIVER_COPY_BASE); const uint32_t totalLength = rf_partition->partition_length; const uint8_t crcResult = *(uint8_t *)(TEMP_RF_DRIVER_END); uint8_t targetCrcResult = 0; uint32_t copyLength; uint32_t destStartAddress_tmp = rf_partition->partition_start_addr; uint32_t sourceStartAddress_tmp = TEMP_RF_DRIVER_BASE; uint32_t i; if ( isDriverNeedCopy != 0x0 ) return; platform_log( "Bootloader start to copy RF driver..." ); /* Copy RF driver to SPI flash */ err = platform_flash_init( &platform_flash_peripherals[ MICO_FLASH_SPI ] ); require_noerr(err, exit); err = platform_flash_init( &platform_flash_peripherals[ MICO_FLASH_EMBEDDED ] ); require_noerr(err, exit); err = platform_flash_erase( &platform_flash_peripherals[ MICO_FLASH_SPI ], rf_partition->partition_start_addr, rf_partition->partition_start_addr + rf_partition->partition_length - 1 ); require_noerr(err, exit); platform_log( "Time: %d", mico_get_time_no_os() ); for(i = 0; i <= totalLength/SizePerRW; i++){ if( i == totalLength/SizePerRW ){ if(totalLength%SizePerRW) copyLength = totalLength%SizePerRW; else break; }else{ copyLength = SizePerRW; } printf("."); err = platform_flash_read( &platform_flash_peripherals[ MICO_FLASH_EMBEDDED ], &sourceStartAddress_tmp, data , copyLength ); require_noerr( err, exit ); err = platform_flash_write( &platform_flash_peripherals[ MICO_FLASH_SPI ], &destStartAddress_tmp, data, copyLength ); require_noerr(err, exit); } printf("\r\n"); /* Check CRC-8 check-sum */ platform_log( "Bootloader start to verify RF driver..." ); sourceStartAddress_tmp = TEMP_RF_DRIVER_BASE; destStartAddress_tmp = rf_partition->partition_start_addr; CRC8_Init( &crc ); for(i = 0; i <= totalLength/SizePerRW; i++){ if( i == totalLength/SizePerRW ){ if(totalLength%SizePerRW) copyLength = totalLength%SizePerRW; else break; }else{ copyLength = SizePerRW; } printf("."); err = platform_flash_read( &platform_flash_peripherals[ MICO_FLASH_SPI ], &destStartAddress_tmp, data, copyLength ); require_noerr( err, exit ); CRC8_Update( &crc, data, copyLength); } CRC8_Final( &crc, &targetCrcResult ); printf("\r\n"); //require_string( crcResult == targetCrcResult, exit, "Check-sum error" ); if( crcResult != targetCrcResult ){ platform_log("Check-sum error"); while(1); } /* Clear RF driver from temperary storage */ platform_log("Bootloader start to clear RF driver temporary storage..."); /* Clear copy tag */ err = platform_flash_erase( &platform_flash_peripherals[ MICO_FLASH_EMBEDDED ], NEED_RF_DRIVER_COPY_BASE, NEED_RF_DRIVER_COPY_BASE); require_noerr(err, exit); exit: return; }