/*************************************************************************//** *****************************************************************************/ void SYS_Init(void) { HAL_Init(); SYS_TimerInit(); PHY_Init(); NWK_Init(); }
int main(void){ uint16_t byteCount = 0; char buffer0[32]; HAL_Init(); SYS_TimerInit(); PHY_Init(); NWK_Init(); //SYS_INIT() timer3Init(); uartInit(); sei(); while (1){ SYS_TaskHandler(); byteCount = uartAvailable(); if(byteCount > 0){ HAL_UartBytesReceived(byteCount); sprintf(buffer0, "Bytes to send: %i\n", byteCount); uartPuts(buffer0); } APP_TaskHandler(); } }
/* ************************************************************************************************************************ * SCAN NAND HW * *Description: initial nand flash,request hardware resources; * *Arguments : void. * *Return : = SUCESS initial ok; * = FAIL initial fail. ************************************************************************************************************************ */ __s32 NAND_HWScanStart(boot_nand_para_t *nand_param) { __s32 ret; NAND_Print("NHW : start nand scan\n"); ret = PHY_Init(); if (ret) { NAND_Print("NHW : nand phy init fail\n"); return ret; } ret = SCN_AnalyzeNandSystem(); if (ret) { NAND_Print("NHW : nand scan fail\n"); return ret; } NAND_GetParam(nand_param); //nand_param->good_block_ratio = nand_good_blk_ratio; //nand_good_block_ratio_flag = nand_param->good_block_ratio; NAND_Print("NHW : nand hw scan ok\n"); return(PHY_ChangeMode(1)); }
/* W7500x Board Initialization */ void W7500x_Board_Init(void) { /* PHY Initialization */ PHY_Init(); /* LEDs Initialization */ LED_Init(LED1); LED_Init(LED2); }
/******************************************************************************* * Platform ******************************************************************************/ void samr21RadioInit(void) { sTransmitFrame.mLength = 0; sTransmitFrame.mPsdu = sTransmitPsdu; sReceiveFrame.mLength = 0; sReceiveFrame.mPsdu = NULL; PHY_Init(); }
/** * Eth_PhyInit * This method initializes the Ethernet PHY, with a specific speed/duplex mode/loopback mode * If init OK, returns TRUE; */ bool Eth_PhyInit(PhyConfig config, PhyLoopback loopback) { if (_eth_data.eth_device_data==NULL) { return FALSE; } // PHY initialization if (!PHY_Init(_eth_data.eth_device_data, PHY_ADDR, config, loopback)) { return FALSE; } return TRUE; }
/* ************************************************************************************************************************ * INIT NAND FLASH * *Description: initial nand flash,request hardware resources; * *Arguments : void. * *Return : = SUCESS initial ok; * = FAIL initial fail. ************************************************************************************************************************ */ __s32 NAND_PhyInit(void) { __s32 ret; // __u32 nand_good_blk_ratio; boot_nand_para_t param; // if(!nand_good_block_ratio_flag) // { // if(wBoot_get_para( WBOOT_PARA_NANDFLASH_INFO, (void *)¶m)) // { // NAND_Print("get good block ratio info failed.\n"); // return -1; // } // nand_good_blk_ratio = param.good_block_ratio; // } // else // { // nand_good_blk_ratio = nand_good_block_ratio_flag; // } // NAND_Print("get the good blk ratio from hwscan : %d \n", nand_good_blk_ratio); NAND_Print("NB1 : enter phy init\n"); ret = PHY_Init(); if (ret) { NAND_Print("NB1 : nand phy init fail\n"); return ret; } ret = SCN_AnalyzeNandSystem(); if (ret) { NAND_Print("NB1 : nand scan fail\n"); return ret; } if(!bad_block_scan_flag) { NAND_GetParam((void *)¶m); nand_good_blk_ratio = NAND_BadBlockScan((void *)¶m); NAND_SetValidBlkRatio(nand_good_blk_ratio); NAND_Print("get the good blk ratio from bad block scan : %d \n", nand_good_blk_ratio); bad_block_scan_flag = 1; } else { NAND_Print(" bad blcok has done before,nand good block ratio is : %d \n", nand_good_blk_ratio); NAND_SetValidBlkRatio(nand_good_blk_ratio); } NAND_Print("NB1 : nand phy init ok\n"); return(PHY_ChangeMode(1)); }
/*************************************************************************//** *****************************************************************************/ void SYS_Init(void){ uartPutsP("\n[LwMesh stack init]\n"); HAL_Init(); uartPutsP(">HAL_INIT\n"); SYS_TimerInit(); uartPutsP(">SYS_TIMER_INIT\n"); PHY_Init(); uartPutsP(">PHY_INIT\n"); NWK_Init(); uartPutsP(">NWK_INIT\n>DONE\n\n"); }
int main(void) { OS_CPU_SysTickInit(CLKPWR_GetCLK(CLKPWR_CLKTYPE_CPU) / 1000 - 1); Board_Init(); //KeyInit(); GUI_Init(); Display_Logo(); /* init phy */ PHY_Init(optionSaveStruct.ipConfig.mac); M25P128_SSP_Init(); GT21L16S2W_SSP_Init(); #if FRMB_DEBUG LPC_Uart_Init(1200*(0x01<<optionSaveStruct.uartConfig[2]),1200*(0x01<<optionSaveStruct.uartConfig[3]),1200*(0x01<<optionSaveStruct.uartConfig[4]),1200*(0x01<<optionSaveStruct.uartConfig[5])); #endif System_Time_Init(); /* Init RTC */ OSInit(); OSTaskCreate ( TaskStart,(void *)0,&GstkStart[TASK_START_STK_SIZE-1],TASK_START_PRIO ); /* Initialize the start task */ /* Start OS Schedule */ OSStart(); /* Start uC/OS-II ??uC/OS-II */ return(0); }
/* ************************************************************************************************************************ * INIT NAND FLASH * *Description: initial nand flash,request hardware resources; * *Arguments : void. * *Return : = SUCESS initial ok; * = FAIL initial fail. ************************************************************************************************************************ */ __s32 NFB_PhyInit(void) { __s32 ret; ret = PHY_Init(); if (ret) { eFG_printf("NB0 : nand phy init fail\n"); return ret; } ret = BOOT_AnalyzeNandSystem(); if (ret) { eFG_printf("NB0 : nand scan fail\n"); return ret; } eFG_printf("NB0 : nand phy init ok\n"); return(PHY_ChangeMode(1)); }
/* * ---------------------------------------------------------------------------- * Function Name: MAC_Init * Purpose: initial all registers and variables of MAC. * Params: network_type -0: auto- negotiation * -1: fixed 100 full speed. * -2: fixed 100 half speed. * -3: fixed 10 full speed. * -4: fixed 10 half speed. * Returns: * Note: * ---------------------------------------------------------------------------- */ void MAC_Init(U8_T network_type) { U8_T XDATA temp[3]; /* read MAC address*/ mac_ReadReg(MAC_ADDR_REG, PNetStation->CurrStaAddr, MAC_ADDRESS_LEN); /* use embedded phy */ temp[0] = (PHY_SELECT_EMBEDDED | PHY_INTERNAL_PHY_OPERA_STATE | BIT1); mac_WriteReg(MAC_PHY_CTL_REG, temp, 1); /* phy power up */ PHY_PowerUp(); /* reset embedded phy */ temp[0] = (PHY_SELECT_EMBEDDED | BIT1); mac_WriteReg(MAC_PHY_CTL_REG, temp, 1); DELAY_Ms(2); /* set embedded phy to operating mode */ temp[0] = (PHY_SELECT_EMBEDDED | PHY_INTERNAL_PHY_OPERA_STATE | BIT1); mac_WriteReg(MAC_PHY_CTL_REG, temp, 1); /* stop & reset MAC operation */ mac_StopOperate(); if (network_type != FORCE_EMBEDDED_PHY_10_HALF) { /* phy initialize. */ PHY_Init(network_type); } PBDP->MacInfo.MediumLinkType = MEDIUM_ENABLE_TX_FLOWCTRL; PBDP->MacInfo.FullDuplex = 1; switch (network_type) { default: case AUTO_NEGOTIATION: PBDP->MacInfo.NetworkType = MAC_AUTO_NEGOTIATION; PBDP->MacInfo.MediumLinkType|=(MEDIUM_FULL_DUPLEX_MODE | MEDIUM_MII_100M_MODE | MEDIUM_ENABLE_RX_FLOWCTRL); break; case FIXED_100_FULL: PBDP->MacInfo.NetworkType = (MAC_LINK_100M_SPEED | MAC_LINK_FULL_DUPLEX); PBDP->MacInfo.MediumLinkType|=(MEDIUM_FULL_DUPLEX_MODE | MEDIUM_MII_100M_MODE | MEDIUM_ENABLE_RX_FLOWCTRL); break; case FIXED_100_HALF: PBDP->MacInfo.NetworkType = MAC_LINK_100M_SPEED; PBDP->MacInfo.MediumLinkType |= MEDIUM_MII_100M_MODE; break; case FIXED_10_FULL: PBDP->MacInfo.NetworkType = (MAC_LINK_10M_SPEED | MAC_LINK_FULL_DUPLEX); PBDP->MacInfo.MediumLinkType |= (MEDIUM_FULL_DUPLEX_MODE | MEDIUM_ENABLE_RX_FLOWCTRL); break; case FIXED_10_HALF: PBDP->MacInfo.NetworkType = MAC_LINK_10M_SPEED; break; case FORCE_EMBEDDED_PHY_10_HALF: PBDP->MacInfo.NetworkType = MAC_FORCE_ENBEDDED_PHY_10_HALF; PBDP->MacInfo.MediumLinkType = 0; break; } /* set medium status */ mac_WriteReg(MAC_MEDIUM_STATUS_MODE_REG, &PBDP->MacInfo.MediumLinkType, 1); /* set IPG */ temp[0] = 0x2b; temp[1] = 0x16; temp[2] = 0x95; mac_WriteReg(MAC_IPG_CTL_REG, temp, 3); /* set RX filter. */ temp[0] = BIT6; mac_WriteReg(MAC_RX_CTL_REG, temp, 1); MAC_SetRxFilter(MAC_RCV_BROADCAST); PBDP->MacInfo.LinkSpeed = 0; // Ethernet not linkup. /* decide interrupt mask */ #if (MAC_GET_INTSTATUS_MODE == MAC_INTERRUPT_MODE) PBDP->MacInfo.InterruptMask = PRIMARY_LINK_CHANGE_ENABLE; #endif } /* End of MAC_Init() */
int main(void) { /* USER CODE BEGIN 1 */ osKernelInitialize(); /* USER CODE END 1 */ /* MCU Configuration----------------------------------------------------------*/ /* Reset of all peripherals, Initializes the Flash interface and the Systick. */ HAL_Init(); /* Configure the system clock */ SystemClock_Config(); /* Initialize all configured peripherals */ MX_GPIO_Init(); MX_TIM2_Init(); MX_USART2_UART_Init(); MX_TIM4_Init(); MX_TIM3_Init(); MX_ADC1_Init(); /* USER CODE BEGIN 2 */ //#ifdef USE_FULL_ASSERT #ifndef MAC_COORDINATOR // Board - Serial identification sprintf(Buf, "\x0cNUCLEO-F446 Debug Terminal\r\nVisible Light Communication " "Project\r\n---\r\nDEV_CONFIG=%d\r\n\r\n", DEV_CONFIG); HAL_UART_Transmit(&huart2, (uint8_t *) Buf, strlen(Buf), 0xffff); #endif //#endif // Initialize Optical Driver DRV_Init(); // Initialize PHY layer PHY_Init(); // Initialize MAC APP layer MAC_AppInit(); // Create threads #ifdef MAC_COORDINATOR tid_blinkLED = osThreadCreate (osThread(blinkLED), NULL); #endif //tid_sendSerial = osThreadCreate (osThread(sendSerial), NULL); //tid_checkButton = osThreadCreate (osThread(checkButton), NULL); // Start thread execution osKernelStart(); // Run codes DRV_RX_Start(); /* USER CODE END 2 */ /* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { osDelay(1000); #ifdef MAC_COORDINATOR osSignalSet(tid_blinkLED, 0x0001); #endif } /* USER CODE END WHILE */ /* USER CODE BEGIN 3 */ /* USER CODE END 3 */ }
/** \brief Low level init of the MAC and PHY. * * \param[in] netif Pointer to LWIP netif structure */ static err_t low_level_init(struct netif *netif) { struct k64f_enetdata *k64f_enet = netif->state; uint8_t i; uint32_t sysClock; phy_speed_t phy_speed; phy_duplex_t phy_duplex; uint32_t phyAddr = 0; bool link = false; enet_config_t config; // Allocate RX descriptors rx_desc_start_addr = (uint8_t *)calloc(1, sizeof(enet_rx_bd_struct_t) * ENET_RX_RING_LEN + ENET_BUFF_ALIGNMENT); if(!rx_desc_start_addr) return ERR_MEM; // Allocate TX descriptors tx_desc_start_addr = (uint8_t *)calloc(1, sizeof(enet_tx_bd_struct_t) * ENET_TX_RING_LEN + ENET_BUFF_ALIGNMENT); if(!tx_desc_start_addr) return ERR_MEM; rx_desc_start_addr = (uint8_t *)ENET_ALIGN(rx_desc_start_addr, ENET_BUFF_ALIGNMENT); tx_desc_start_addr = (uint8_t *)ENET_ALIGN(tx_desc_start_addr, ENET_BUFF_ALIGNMENT); /* Create buffers for each receive BD */ for (i = 0; i < ENET_RX_RING_LEN; i++) { rx_buff[i] = pbuf_alloc(PBUF_RAW, ENET_ETH_MAX_FLEN + ENET_BUFF_ALIGNMENT, PBUF_RAM); if (NULL == rx_buff[i]) return ERR_MEM; /* K64F note: the next line ensures that the RX buffer is properly aligned for the K64F RX descriptors (16 bytes alignment). However, by doing so, we're effectively changing a data structure which is internal to lwIP. This might not prove to be a good idea in the long run, but a better fix would probably involve modifying lwIP itself */ rx_buff[i]->payload = (void*)ENET_ALIGN((uint32_t)rx_buff[i]->payload, ENET_BUFF_ALIGNMENT); rx_ptr[i] = rx_buff[i]->payload; } k64f_enet->tx_consume_index = k64f_enet->tx_produce_index = 0; /* prepare the buffer configuration. */ enet_buffer_config_t buffCfg = { ENET_RX_RING_LEN, ENET_TX_RING_LEN, ENET_ALIGN(ENET_ETH_MAX_FLEN, ENET_BUFF_ALIGNMENT), 0, (volatile enet_rx_bd_struct_t *)rx_desc_start_addr, (volatile enet_tx_bd_struct_t *)tx_desc_start_addr, (uint8_t *)&rx_ptr, NULL, }; #if (defined(TARGET_K64F) && (defined(TARGET_FRDM))) k64f_init_eth_hardware(); #endif #if (defined(TARGET_K66F) && (defined(TARGET_FRDM))) k66f_init_eth_hardware(); #endif sysClock = CLOCK_GetFreq(kCLOCK_CoreSysClk); ENET_GetDefaultConfig(&config); PHY_Init(ENET, 0, sysClock); PHY_GetLinkStatus(ENET, phyAddr, &link); if (link) { /* Get link information from PHY */ PHY_GetLinkSpeedDuplex(ENET, phyAddr, &phy_speed, &phy_duplex); /* Change the MII speed and duplex for actual link status. */ config.miiSpeed = (enet_mii_speed_t)phy_speed; config.miiDuplex = (enet_mii_duplex_t)phy_duplex; config.interrupt = kENET_RxFrameInterrupt | kENET_TxFrameInterrupt; } config.rxMaxFrameLen = ENET_ETH_MAX_FLEN; config.macSpecialConfig = kENET_ControlFlowControlEnable; config.txAccelerConfig = kENET_TxAccelIsShift16Enabled; config.rxAccelerConfig = kENET_RxAccelisShift16Enabled | kENET_RxAccelMacCheckEnabled; ENET_Init(ENET, &g_handle, &config, &buffCfg, netif->hwaddr, sysClock); ENET_SetCallback(&g_handle, ethernet_callback, netif); ENET_ActiveRead(ENET); return ERR_OK; }
/** * @brief Main program * @param None * @retval None */ int main() { //uint8_t tx_size[8] = { 2, 2, 2, 2, 2, 2, 2, 2 }; //uint8_t rx_size[8] = { 2, 2, 2, 2, 2, 2, 2, 2 }; uint8_t mac_addr[6] = {0x00, 0x08, 0xDC, 0x01, 0x02, 0x03}; uint8_t src_addr[4] = {192, 168, 0, 9}; uint8_t gw_addr[4] = {192, 168, 0, 1}; uint8_t sub_addr[4] = {255, 255, 255, 0}; //uint8_t dns_server[4] = {8, 8, 8, 8}; // for Example domain name server uint8_t tmp[8]; int32_t ret; uint16_t port=5000, size = 0, sentsize=0; uint8_t destip[4]; uint16_t destport; *(volatile uint32_t *)(0x41001014) = 0x0060100; //clock setting 48MHz /* External Clock */ //CRG_PLL_InputFrequencySelect(CRG_OCLK); /* Set Systme init */ SystemInit(); SSP0_Initialize(); SSP1_Initialize(); GPIO_Initialize(); GPIO_SetBits(GPIOC, GPIO_Pin_8); // LED red off GPIO_SetBits(GPIOC, GPIO_Pin_9); // LED green off GPIO_ResetBits(GPIOC, GPIO_Pin_6); // Test off /* UART Init */ UART_StructInit(&UART_InitStructure); UART_Init(UART1,&UART_InitStructure); /* SysTick_Config */ SysTick_Config((GetSystemClock()/1000)); /* Set WZ_100US Register */ setTIC100US((GetSystemClock()/10000)); //getTIC100US(); //printf(" GetSystemClock: %X, getTIC100US: %X, (%X) \r\n", // GetSystemClock, getTIC100US(), *(uint32_t *)TIC100US); #ifdef __DEF_USED_MDIO__ /* PHY Initialization */ PHY_Init(); /* PHY Link Check via gpio mdio */ while( link() == 0x0 ) { printf("."); delay(500); } printf("PHY is linked. \r\n"); #else delay(1000); delay(1000); #endif /* Network Configuration */ setSHAR(mac_addr); setSIPR(src_addr); setGAR(gw_addr); setSUBR(sub_addr); getSHAR(tmp); printf(" MAC ADDRESS : %.2X:%.2X:%.2X:%.2X:%.2X:%.2X\r\n",tmp[0],tmp[1],tmp[2],tmp[3],tmp[4],tmp[5]); getSIPR(tmp); printf("IP ADDRESS : %d.%d.%d.%d\r\n",tmp[0],tmp[1],tmp[2],tmp[3]); getGAR(tmp); printf("GW ADDRESS : %d.%d.%d.%d\r\n",tmp[0],tmp[1],tmp[2],tmp[3]); getSUBR(tmp); printf("SN MASK: %d.%d.%d.%d\r\n",tmp[0],tmp[1],tmp[2],tmp[3]); /* Set Network Configuration */ //wizchip_init(tx_size, rx_size); printf(" TEST- START \r\n"); while(1) { switch(getSn_SR(SOCK_NUM)) { case SOCK_ESTABLISHED: if(getSn_IR(SOCK_NUM) & Sn_IR_CON) { getSn_DIPR(SOCK_NUM, destip); destport = getSn_DPORT(SOCK_NUM); printf("%d:Connected - %d.%d.%d.%d : %d\r\n",SOCK_NUM, destip[0], destip[1], destip[2], destip[3], destport); setSn_IR(SOCK_NUM,Sn_IR_CON); } if((size = getSn_RX_RSR(SOCK_NUM)) > 0) // Don't need to check SOCKERR_BUSY because it doesn't not occur. { if(size > DATA_BUF_SIZE) size = DATA_BUF_SIZE; ret = recv(SOCK_NUM, test_buf, size); if(ret <= 0) return ret; // check SOCKERR_BUSY & SOCKERR_XXX. For showing the occurrence of SOCKERR_BUSY. /* Send only data to SSP1 */ for (TxIdx=0; TxIdx<size; TxIdx++) { SSP_SendData(SSP0, test_buf[TxIdx]); while( SSP_GetFlagStatus(SSP0, SSP_FLAG_BSY) ); } /* Receive only data from SSP0 */ while(SSP_GetFlagStatus(SSP1, SSP_FLAG_RNE)) { SSP1_Buffer_Rx[RxIdx] = SSP_ReceiveData(SSP1); RxIdx++; } RxIdx=0; sentsize = 0; while(size != sentsize) { ret = send(SOCK_NUM, SSP1_Buffer_Rx+sentsize, size-sentsize); if(ret < 0) { close(SOCK_NUM); return ret; } sentsize += ret; // Don't care SOCKERR_BUSY, because it is zero. } } break; case SOCK_CLOSE_WAIT: printf("%d:CloseWait\r\n",SOCK_NUM); if((ret = disconnect(SOCK_NUM)) != SOCK_OK) return ret; printf("%d:Socket Closed\r\n", SOCK_NUM); break; case SOCK_INIT: printf("%d:Listen, TCP server loopback, port [%d]\r\n", SOCK_NUM, port); if( (ret = listen(SOCK_NUM)) != SOCK_OK) return ret; break; case SOCK_CLOSED: printf("%d:TCP server loopback start\r\n",SOCK_NUM); if((ret = socket(SOCK_NUM, Sn_MR_TCP, port, 0x00)) != SOCK_NUM) return ret; printf("%d:Socket opened\r\n",SOCK_NUM); break; default: break; } } }