/*************************************************************************//**
*****************************************************************************/
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;
}
}
}
