void initLCD(unsigned char cursor) { msDelay(100); PMADDR=0; PMDIN1 = 0b00111100;//8bit mode PMADDR = 0x8000; //chip select enable msDelay(30); PMADDR = 0; PMDIN1 = 0b00001111;//cursor on PMADDR = 0x8000; //chip select enable _10usDelay(4); //macro for 40us PMADDR=0; PMDIN1 = 0b00000010; //return home PMADDR = 0x8000; //chip select enable msDelay(2); //macro for 2ms PMADDR=0; PMDIN1 = 0b00000110; //entry mode no shifting PMADDR = 0x8000; //chip select enable _10usDelay(4); //macro for 40us PMADDR = 0; PMDIN1 = 0b00001000 | cursor; }
/************************************************************************* Author: Josiah Snarr Date: April 11, 2015 stepperHome finds the stepper limits on the platform, and centers the stepper at the midpoint between them *************************************************************************/ void stepperHome(void) { unsigned int midpoint; //Delay stops it from going "ttttttzzzhhggggghhghhzzzzzttttt" msDelay(25); //Go fully left while(IS_CLR(STEP_SWI_PORT, SWI_LEFT)) { stepperStep(); msDelay(2); } //All the way left, 0-position, switch direction currStep = 0; SWI_DIR(direction); //Go all the way right while(IS_CLR(STEP_SWI_PORT, SWI_RIGHT)) { stepperStep(); msDelay(2); } //All the way right, number of steps is current step, find midpoint and switch direction numSteps = currStep; midpoint = currStep/2; SWI_DIR(direction); //Move to midpoint while(currStep != midpoint) { stepperStep(); msDelay(2); } }
int main(void) { SystemInit(); /* Enable GPIO clock */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE); /* Enable UART clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); /* Connect PXx to USARTx_Tx*/ GPIO_PinAFConfig(GPIOB, GPIO_PinSource10, GPIO_AF_USART3); /* Connect PXx to USARTx_Rx*/ GPIO_PinAFConfig(GPIOB, GPIO_PinSource11, GPIO_AF_USART3); /* Configure USART Tx as alternate function */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; GPIO_Init(GPIOB, &GPIO_InitStructure); /* Configure USART Rx as alternate function */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_Init(GPIOB, &GPIO_InitStructure); USART_InitStructure.USART_BaudRate = 921600; USART_InitStructure.USART_WordLength = USART_WordLength_8b; USART_InitStructure.USART_StopBits = USART_StopBits_1; USART_InitStructure.USART_Parity = USART_Parity_No; USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; /* USART configuration */ USART_Init(USART3, &USART_InitStructure); /* Enable USART */ USART_Cmd(USART3, ENABLE); while(1) { PrintChar(0x55); msDelay(1000); } }
short uartRead() { // if the head isn't ahead of the tail, we don't have any characters while(rxHead == rxTail) msDelay(500); if (rxHead == rxTail) { return -1; } else { unsigned char c = rxBuffer[rxTail]; rxTail = (unsigned char)(rxTail+1) % SERIAL_BUFFER_SIZE; return c; } }
void flashled(int led) { switch (led) { case 0: led = 0; break; case 1: led = 1; break; case 2: led = 2; break; case 3: led = 3; break; default: led = 6; } dispLedOut(led,1); msDelay(400); dispLedOut(led,0); msDelay(400); }
//------------------------------------------------------------------------ // Milli-sec delay function that also monitors the keypad //------------------------------------------------------------------------ nodebug int key_msDelay(int delay) { auto int loop; for(loop=0; loop < delay; loop++) { msDelay(1); keyProcess (); if(keyGet() != 0) { return(TRUE); } } }
/******************************** MPU6050 Functions ********************************/ void initializeIMU() { //Init Interrupt Output Pin P1REN |= BIT4; P1OUT |= BIT4; P1IFG &= ~BIT4; // P1.4 IFG cleared P1IE |= BIT4; // P1.4 interrupt enabled P4SEL |= BIT1 + BIT2; // P4.1 & P4.2 SDA/SCL Select // Delays do not need to be this long. Delays are present to keep I2C line clear. // This functions can be altered by the user. Check MPU6050.h file by Jeff Rowberg to determine the sensitivty variables. setClockSource(MPU6050_CLOCK_PLL_XGYRO); // Set MPU6050 clock msDelay(100); setFullScaleGyroRange(MPU6050_GYRO_FS_2000); // Gyroscope sensitivity set to 2000 degrees/sec msDelay(100); setFullScaleAccelRange(MPU6050_ACCEL_FS_4); // Accelerometer sensitivity set to 4g msDelay(100); setDLPFConfig(MPU6050_DLPF_BW_5); // Digital Low Pass Filter Configuration setInterruptPin(); setSleepEnabled(0); // Wake up device. msDelay(100); }
unsigned char imposta_stato(unsigned char presa) { unsigned char level,press; y_pos(1,1); lcd_printf("Scegli lo stato"); y_pos(6,2); lcd_printf(" 0 1"); level=presa_read_level(presa); //porta il cursore sullivello del pin if (!level) y_pos(6,2); else y_pos(12,2); lcd_printf(">"); press=0; while(p_status() != P_OK) { press=p_status(); if (press!=0) { if (press==P_LEFT) { y_pos(12,2); lcd_printf(" "); y_pos(6,2); lcd_printf(">"); level=0; while (p_status()==P_LEFT) msDelay(1); } if (press==P_RIGHT) { y_pos(6,2); lcd_printf(" "); y_pos(12,2); lcd_printf(">"); level=1; while (p_status()==P_RIGHT) msDelay(1); } } } printf("restituisco %d",level); return level; }
/** \brief Initialize the LAN8720 PHY. * * This function initializes the LAN8720 PHY. It will block until * complete. This function is called as part of the EMAC driver * initialization. Configuration of the PHY at startup is * controlled by setting up configuration defines in * lpc_emac_config.h. * * \param[in] netif NETIF structure * \param[in] rmii If set, configures the PHY for RMII mode * \return ERR_OK if the setup was successful, otherwise ERR_TIMEOUT */ err_t lpc_phy_init(struct netif *netif, int rmii) { u32_t tmp, tmp1; s32_t i; physts.phy_speed_100mbs = olddphysts.phy_speed_100mbs = 2; physts.phy_full_duplex = olddphysts.phy_full_duplex = 2; physts.phy_link_active = olddphysts.phy_link_active = 2; phyustate = 0; /* Only first read and write are checked for failure */ /* Put the LAN8720 in reset mode and wait for completion */ if (lpc_mii_write(LAN8_BCR_REG, LAN8_RESET) != 0) return ERR_TIMEOUT; i = 400; while (i > 0) { msDelay(1); /* 1 ms */ if (lpc_mii_read(LAN8_BCR_REG, &tmp) != 0) return ERR_TIMEOUT; if (!(tmp & (LAN8_RESET | LAN8_POWER_DOWN))) i = -1; else i--; } /* Timeout? */ if (i == 0) return ERR_TIMEOUT; /* Setup link based on configuration options */ #if PHY_USE_AUTONEG==1 tmp = LAN8_AUTONEG; #else tmp = 0; #endif #if PHY_USE_100MBS==1 tmp |= LAN8_SPEED_SELECT; #endif #if PHY_USE_FULL_DUPLEX==1 tmp |= LAN8_DUPLEX_MODE; #endif lpc_mii_write(LAN8_BCR_REG, tmp); /* The link is not set active at this point, but will be detected later */ return ERR_OK; }
//------------------------------------------------------------------- // Description: // Send a break on the com port for "len" msec // // portnum - number 0 to MAX_PORTNUM-1. This number is provided to // indicate the symbolic port number. // void BreakCOM(int portnum) { // start the reset pulse SetCommBreak(ComID[portnum]); // delay msDelay(2); // clear the reset pulse and return // PROGRAMMER'S NOTE: ClearCommBreak is returning 24:an undefined code ClearCommBreak(ComID[portnum]); // Win3.1 bug, close and then open port CloseCOM(portnum); OpenCOM(portnum,&port[0]); }
uint8_t initMPU(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t source) { uint8_t b = 0; readByte(devAddr, regAddr, &b); msDelay(2); uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1); source <<= (bitStart - length + 1); // shift data into correct position source &= mask; // zero all non-important bits in data b &= ~(mask); // zero all important bits in existing byte b |= source; // combine data with existing byte writeByte(devAddr, regAddr, b); return b; }
int main() { unsigned char Lcd_LINE1[6] = {'\0'}; unsigned char Lcd_LINE2[16] = {'\0'}; unsigned int i; InitCan(); InitQEI(); InitPwm(); // InitInt(); InitAdc(); // InitUart(); //pid unsigned int *pwmOUT; pid_t mypid; float degPOT = 0.0; float degMTR = 0.0; while (1) { if(InData0[1] > 0){ // if(InData0[2] == 1){ // PDC2 = (unsigned int)(InData0[1]* 2 *.5914); // PDC1 = 0; // } // else{ // PDC1 = (unsigned int)(InData0[1]* 2* .5914); // PDC2 = 0; // } pwmOUT = CalcPid(&mypid, degPOT, degMTR); PDC1 = *(pwmOUT + 0); // 16-bit register PDC2 = *(pwmOUT + 1); // 16-bit register } if (InData0[3] == 1) { C1TX0B4 = 2; C1TX0B1 = POSCNT; C1TX0B2 = C1RX0B2; C1TX0B3 = C1RX0B3; C1TX0CONbits.TXREQ = 1; while (C1TX0CONbits.TXREQ != 0); } msDelay(10); } //while } // main
static void handleBootloaderCmd(struct esbPacket_s *packet) { static bool resetInit = false; static struct esbPacket_s txpk; switch (packet->data[2]) { case BOOTLOADER_CMD_RESET_INIT: resetInit = true; txpk.data[0] = 0xff; txpk.data[1] = 0xfe; txpk.data[2] = BOOTLOADER_CMD_RESET_INIT; memcpy(&(txpk.data[3]), (uint32_t*)NRF_FICR->DEVICEADDR, 6); txpk.size = 9; #if BLE bleCrazyfliesSendPacket(&txpk); #endif if (esbCanTxPacket()) { struct esbPacket_s *pk = esbGetTxPacket(); memcpy(pk, &txpk, sizeof(struct esbPacket_s)); esbSendTxPacket(pk); } break; case BOOTLOADER_CMD_RESET: if (resetInit && (packet->size == 4)) { msDelay(100); if (packet->data[3] == 0) { NRF_POWER->GPREGRET |= 0x40; } else { //Set bit 0x20 forces boot to firmware NRF_POWER->GPREGRET |= 0x20U; } #ifdef BLE sd_nvic_SystemReset(); #else NVIC_SystemReset(); #endif } break; default: break; } }
unsigned char scegli_sonda(){ // ritorna 1..7 unsigned char scelta,press,i,sonda; y_pos(1,1); lcd_printf("Scegli la sonda"); y_pos(4,2); lcd_printf(">1 2 3 4 5 6 7"); y_pos(3,3); for (i=0;i<15;i++) lcd_printf(sonde_nomi[0][i]); scelta=4; y_pos(scelta,2); sonda=1; while(p_status() != P_OK){ press=p_status(); if (press!=0) { y_pos(scelta,2); lcd_printf(" "); if (press==P_RIGHT) { scelta+=2; sonda++; if (scelta>17){ scelta=4; sonda=1; } } else if (press==P_LEFT) { scelta-=2; sonda--; if (scelta<4){ scelta=16; sonda=7; } } y_pos(scelta,2); lcd_printf(">"); y_pos(3,3); for (i=0;i<15;i++) lcd_printf(sonde_nomi[sonda-1][i]); while (p_status()!=0) msDelay(1); } } clean_row(2); return sonda; // da1..7 }
void sk_menu_1_1(){ char valore[5]; // int intervalli[6]; // leggi rtc y_pos(0,0); lcd_printf("<< CAMBIA DATA"); y_pos(2,2); //lcd_printf("15:00 25/04/07"); //ora valore[0]=read_hour(); lcd_printf("%02d:",valore[0]); valore[1]=read_min(); lcd_printf("%02d ",valore[1]); //data valore[2]=read_day(); lcd_printf("%02d",valore[2]); valore[3]=read_month(); lcd_printf("/%02d",valore[3]); valore[4]=read_year(); lcd_printf("/%02d",valore[4]); // x,y,partenza,min,max valore[0]=inc_cifra(2,2,valore[0],0,24);// hh valore[1]=inc_cifra(5,2,valore[1],0,59);// mm set_ora(valore[0],valore[1]); valore[2]=inc_cifra(9,2,valore[2],0,31);// gg valore[3]=inc_cifra(12,2,valore[3],0,12);// m valore[4]=inc_cifra(15,2,valore[4],7,20);// aa // verifica data x gg bisestili e gg de mesi set_data(valore[2],valore[3],valore[4]); //se ok salva il valore y_pos(4,3); if (true) lcd_printf("DATA SALVATA"); else lcd_printf("DATA ERRATA"); msDelay(2000); }
//------------------------------------------------------------------------------ int HWDeInit(void) { // Reset PHY (void) HYPHYReset(); // Reset all MAC logic ENETMAC->mac1 = (MAC1_SOFT_RESET | MAC1_SIMULATION_RESET | MAC1_RESET_MCS_TX | MAC1_RESET_TX | MAC1_RESET_MCS_RX | MAC1_RESET_RX); ENETMAC->command = (COMMAND_REG_RESET | COMMAND_TXRESET | COMMAND_RXRESET); msDelay(2); // Disable MAC clocks, but keep MAC interface active #ifdef USE_PHY_RMII CLKPWR->clkpwr_macclk_ctrl = CLKPWR_MACCTRL_USE_RMII_PINS; #else CLKPWR->clkpwr_macclk_ctrl = CLKPWR_MACCTRL_USE_MII_PINS; #endif return 1; }
int main() { unsigned char Lcd_LINE1[6] = {'\0'}; unsigned char Lcd_LINE2[16] = {'\0'}; unsigned int i; InitCan(); InitQEI(); InitPwm(); // InitInt(); InitAdc(); // InitUart(); while (1) { if(InData0[1] > 0){ if(InData0[2] == 1){ PDC2 = (unsigned int)(InData0[1]* 2 *.5914); PDC1 = 0; } else{ PDC1 = (unsigned int)(InData0[1]* 2* .5914); PDC2 = 0; } } if (InData0[3] == 1) { C1TX0B4 = 2; C1TX0B1 = POSCNT; C1TX0B2 = C1RX0B2; C1TX0B3 = C1RX0B3; C1TX0CONbits.TXREQ = 1; while (C1TX0CONbits.TXREQ != 0); } msDelay(10); } //while } // main
main () { auto int channel; auto unsigned int avg_sample; auto char s[80]; auto char display[80]; auto float ad_inputs[ENDCHAN+1]; brdInit(); //initially start up A/D oscillator and charge up cap anaIn(0,SINGLE,GAINSET); DispStr(1, 1, "\t\t<<< Analog input channels 0 - 6: >>>"); DispStr(1, 3, "\t LN0IN\t LN1IN\t LN2IN\t LN3IN\t LN4IN\t LN5IN\t LN6IN"); DispStr(1, 4, "\t------\t------\t------\t------\t------\t------\t------"); for(;;) { for(channel = STARTCHAN; channel <= ENDCHAN; channel++) { // sample each channel avg_sample = sample_ad(channel, NUMSAMPLES); ad_inputs[channel] = convert_volt(channel, avg_sample); } display[0] = '\0'; for(channel = STARTCHAN; channel <= ENDCHAN; channel++) { sprintf(s, "\t%6.3f", ad_inputs[channel]); strcat(display, s); } DispStr(1, 5, display); msDelay(1000); //delay one second for viewing } }
static int phy_get_link_status (void) { unsigned long status; /* Status is read once to clear old link state */ RMII_Read(PHY_BMSR,&status); /* * Wait if the link is up, and autonegotiation is in progress * (ie - we're capable and it's not done) */ status = 0; RMII_Read(PHY_BMSR,&status); if ((status & PHY_BMSR_LS) && (status & PHY_BMSR_AUTN_ABLE) && !(status & PHY_BMSR_AUTN_COMP)) { int i = 0; while (!(status & PHY_BMSR_AUTN_COMP)) { /* Timeout reached */ if (i > 1000) { printf("Timeout\n"); return 1; } i++; msDelay(1); /* 1 ms */ RMII_Read(PHY_BMSR,&status); } return 0; } else { if (status & PHY_BMSR_LS) return 0; else return 1; } return 1; }
/* Write a value via the MII link (blocking) */ err_t lpc_mii_write(u32_t PhyReg, u32_t Value) { u32_t mst = 250; err_t sts = ERR_OK; /* Write value at PHY address and register */ lpc_mii_write_noblock(PhyReg, Value); /* Wait for unbusy status */ while (mst > 0) { sts = LPC_ETHERNET->MAC_MII_ADDR & MAC_MIIA_GB; if (sts == 0) mst = 0; else { mst--; msDelay(1); } } if (sts != 0) sts = ERR_TIMEOUT; return sts; }
//------------------------------------- void DriverFSU() { BYTE i, j, k, send, tmp; int data; //------------------------------------------------ // обновление адреса блока Fsu.Info.bits.Addr =ADDR; if(stStartBlock == FALSE) { if(getTimer(&TimerStartBlock) == 0) { stStartBlock = TRUE; for(i=0; i<6; i++) { ChipSelekt(i, CS_ON); obmen_spi(i/3, 0); // Обнуление всех флагов ошибок ChipSelekt(i, CS_OFF); } msDelay(50); for(i=0; i<6; i++) { ChipSelekt(i, CS_ON); obmen_spi(i/3, 0xFF); // Выключение реле ChipSelekt(i, CS_OFF); } }else { msDelay(10); for(i=0; i<6; i++) { ChipSelekt(i, CS_ON); obmen_spi(i/3, 0xFF); // Выключение реле ChipSelekt(i, CS_OFF); } } } //======================================================== if(stStartBlock == TRUE) { if(getTimer(&TimerStartBlock) == 0) { setTimer(&TimerStartBlock, 10); i = K_1 | (K_2<<1) | (K_3<<2) | (K_4<<3) | (K_5<<4) | (K_6<<5) | (K_7<<6) | (K_8<<7); Fsu.K[0] = ~i; i = K_9 | (K_10<<1)| (K_11<<2)| (K_12<<3)| (K_13<<4)| (K_14<<5)| (K_15<<6)| (K_16<<7); Fsu.K[1] = ~i; i = K_17| (K_18<<1)| (K_19<<2)| (K_20<<3)| (K_21<<4)| (K_22<<5)| (K_23<<6)| (K_24<<7); Fsu.K[2] = ~i; //------------------------------------------------------------------------------------------- for(i=0; i<3; i++) { Fsu.SetData[i] = Fsu.NewData[i]; Fsu.OL[i] = 0; Fsu.Diag[i] = 0; Fsu.DiagSum[i] =0; for(j=0; j<2; j++) { ChipSelekt(2*i+j, CS_ON); // 0x2 - ON 0x3 - OFF send = 0; tmp = Fsu.SetData[i]>>(4*j); for(k=0; k<4; k++) { if(digit(tmp,k) == 0) send|=0x3<<(2*k); else send|=0x2<<(2*k); } data = obmen_spi((i+j)/2, send); if(data >= 0) { tmp = data; for(k=0; k<4; k++) { Fsu.OL[i] |= digit(tmp,1+2*k)<<(4*j+k); Fsu.Diag[i] |= digit(tmp,2*k)<<(4*j+k); } Fsu.DiagSum[i] =Fsu.OL[i]|Fsu.Diag[i]; }else { Fsu.DiagSum[i] =0xFF; } ChipSelekt(2*i+j, CS_OFF); } } } }
void COpenProgDlg::Write18Fx(int dim,int dim2,int wbuf=8,int eraseW1=0x10000,int eraseW2=0x10000,int options=0) // write 16 bit PIC 18Fxxxx // dim=program size dim2=eeprom size wbuf=write buffer size {<=64} // eraseW1=erase word @3C0005 (not used if > 0x10000) // eraseW2=erase word @3C0004 (not used if > 0x10000) // options: // bit [3:0] // 0 = vdd before vpp (12V) // 1 = vdd before vpp (9V) // 2 = low voltage entry with 32 bit key // bit [7:4] // 0 = normal eeprom write algoritm // 1 = with unlock sequence 55 AA // bit [11:8] // 0 = 5ms erase delay, 1ms code write time, 5ms EE write delay, 5ms config write time // 1 = 550ms erase delay, 1.2ms code write time, no config or EEPROM // 2 = 550ms erase delay, 3.4ms code write time, no config or EEPROM { CString str; int size=memCODE.GetSize(),sizeEE=memEE.GetSize(); int k=0,k2,z=0,i,j; int err=0,devID=0; int EEalgo=(options>>4)&0xF,entry=options&0xF,optWrite=(options>>8)&0xF; if(dim>0x1FFFFF||dim<0){ PrintMessage(strings[S_CodeLim]); //"Code size out of limits\r\n" return; } if(dim2>0x800||dim2<0){ PrintMessage(strings[S_EELim]); //"EEPROM size out of limits\r\n" return; } if(wbuf>64){ PrintMessage(strings[S_WbufLim]); //"Write buffer size out of limits\r\n" return; } if(entry==2&&!CheckV33Regulator()){ PrintMessage(strings[S_noV33reg]); //Can't find 3.3V expansion board return; } double vpp=entry<2?(entry==0?12:8.5):-1; if(!StartHVReg(vpp)){ PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n" return; } if(saveLog){ OpenLogFile(); //"log.txt" fprintf(logfile,"Write18F(%d,%d,%d,%d) (0x%X,0x%X,0x%X,0x%X)\n",dim,dim2,wbuf,options,dim,dim2,wbuf,options); } if(dim>size) dim=size; if(dim%wbuf){ //grow to an integer number of rows dim+=wbuf-dim%wbuf; j=size; if(j<dim)memCODE.SetSize(dim); for(;j<dim;j++) memCODE[j]=0xFF; } if(dim2>sizeEE) dim2=sizeEE; if(dim<1){ PrintMessage(strings[S_NoCode]); //"Empty data area\r\n" return; } unsigned int start=GetTickCount(); bufferU[0]=0; j=1; bufferU[j++]=SET_PARAMETER; bufferU[j++]=SET_T1T2; bufferU[j++]=1; //T1=1u bufferU[j++]=100; //T2=100u bufferU[j++]=EN_VPP_VCC; //enter program mode bufferU[j++]=0x0; bufferU[j++]=SET_CK_D; bufferU[j++]=0x0; bufferU[j++]=EN_VPP_VCC; //VDD bufferU[j++]=0x1; bufferU[j++]=EN_VPP_VCC; //VDD+VPP bufferU[j++]=0x5; if(entry==2){ //LV entry with key bufferU[j++]=EN_VPP_VCC; //VDD bufferU[j++]=0x1; bufferU[j++]=WAIT_T3; bufferU[j++]=WAIT_T3; bufferU[j++]=TX16; bufferU[j++]=2; bufferU[j++]=0x4D; bufferU[j++]=0x43; bufferU[j++]=0x48; bufferU[j++]=0x50; bufferU[j++]=EN_VPP_VCC; //VDD+VPP bufferU[j++]=0x5; bufferU[j++]=WAIT_T3; } bufferU[j++]=WAIT_T3; bufferU[j++]=CORE_INS; bufferU[j++]=0x0E; //3F bufferU[j++]=0x3F; bufferU[j++]=CORE_INS; bufferU[j++]=0x6E; //-> TBLPTRU bufferU[j++]=0xF8; bufferU[j++]=CORE_INS; bufferU[j++]=0x0E; //FF bufferU[j++]=0xFF; bufferU[j++]=CORE_INS; bufferU[j++]=0x6E; //-> TBLPTRH bufferU[j++]=0xF7; bufferU[j++]=CORE_INS; bufferU[j++]=0x0E; //FE bufferU[j++]=0xFE; bufferU[j++]=CORE_INS; bufferU[j++]=0x6E; //-> TBLPTRL bufferU[j++]=0xF6; bufferU[j++]=TBLR_INC_N; //DevID1-2 0x3FFFFE-F bufferU[j++]=2; bufferU[j++]=SET_PARAMETER; bufferU[j++]=SET_T3; bufferU[j++]=5100>>8; bufferU[j++]=5100&0xff; bufferU[j++]=FLUSH; for(;j<DIMBUF;j++) bufferU[j]=0x0; write(); msDelay(3); if(entry==2) msDelay(7); read(); if(saveLog)WriteLogIO(); for(z=1;bufferI[z]!=TBLR_INC_N&&z<DIMBUF;z++); if(z<DIMBUF-3){ PrintMessage2(strings[S_DevID2],bufferI[z+3],bufferI[z+2]); //"DevID: 0x%02X%02X\r\n" PIC18_ID(bufferI[z+2]+(bufferI[z+3]<<8)); } j=1; //****************** erase memory ******************** PrintMessage(strings[S_StartErase]); //"Erase ... " bufferU[j++]=CORE_INS; bufferU[j++]=0x0E; //3C bufferU[j++]=0x3C; bufferU[j++]=CORE_INS; bufferU[j++]=0x6E; //-> TBLPTRU bufferU[j++]=0xF8; bufferU[j++]=CORE_INS; bufferU[j++]=0x6A; //TBLPTRH=0 bufferU[j++]=0xF7; if(eraseW1<0x10000){ bufferU[j++]=CORE_INS; bufferU[j++]=0x0E; //05 bufferU[j++]=0x05; bufferU[j++]=CORE_INS; bufferU[j++]=0x6E; //-> TBLPTRL bufferU[j++]=0xF6; bufferU[j++]=TABLE_WRITE; // eraseW1@3C0005 bufferU[j++]=(eraseW1>>8)&0xFF; //0x3F; bufferU[j++]=eraseW1&0xFF; //0x3F; }
main() { auto int i,x,y,z; auto char s[256]; auto int NumPixel; auto int FontWidth, FontHeight; //------------------------------------------------------------------------ // Initialize controller //------------------------------------------------------------------------ brdInit(); // Initialize Controller...Required for controllers!!! glInit(); // Initialize the graphic driver glBackLight(1); glSetContrast(24); glXFontInit(&fi10x16, 10, 16, 32, 127, Font10x16); // Initialize basic font glXFontInit(&fi12x16, 12, 16, 32, 127, Font12x16); // Initialize basic font glXFontInit(&fi17x35, 17, 35, 32, 127, Font17x35); // Initialize basic font while(1) { //------------------------------------------------------------------------ // Text scroll-up example //------------------------------------------------------------------------ glPrintf(0, 0,&fi10x16,"Scroll-up Demo"); msDelay(800); FontWidth = 10; FontHeight = 16; glBuffLock(); glBlankScreen(); for (y = 0, z = 32; y < 240; y += FontHeight) { for (x = 0; x < LCD_XS; x+=FontWidth) { glPrintf(x, y,&fi10x16,"%c",z++); if (z > 64) z = 32; } } glBuffUnlock(); msDelay(750); for(y=0; y<3; y++) { glVScroll(0, 0, LCD_XS, LCD_YS, -FontHeight); for (x = 0; x < LCD_XS; x+=FontWidth) { glPrintf(x, LCD_YS-FontHeight, &fi10x16, "%c",z++); if (z > 126) z = 32; msDelay(5); } msDelay(600); } //------------------------------------------------------------------------ // Text scroll-down example //------------------------------------------------------------------------ glBlankScreen(); glPrintf(0, 0,&fi10x16,"Scroll-Down Demo"); msDelay(800); FontWidth = 10; FontHeight = 16; glBuffLock(); glBlankScreen(); for (y = 0, z=32; y < LCD_XS; y += FontHeight) { for (x = 0; x < LCD_XS; x+=FontWidth) { glPrintf(x, y,&fi10x16,"%c",z++); if (z > 126) z = 32; msDelay(5); } } glBuffUnlock(); msDelay(750); for(y=0; y<4; y++) { glVScroll(0, 0, LCD_XS, LCD_YS, FontHeight); for (x = 0; x < LCD_XS; x+=FontWidth) { glPrintf(x, 0,&fi10x16,"%c",z++); if (z > 64) z = 32; msDelay(5); } msDelay(600); } //------------------------------------------------------------------------ // Text Scrolling left example //------------------------------------------------------------------------ glBlankScreen(); glPrintf(0, 0,&fi10x16,"Scroll-Left Demo"); msDelay(1500); NumPixel = 17; for(y = 0; y < 1; y++) { sprintf(s, "Hello from Z-World....."); i =0; while(s[i] != '\0') { glHScroll(0, 60, LCD_XS, 34, -NumPixel); glPrintf (LCD_XS-NumPixel, 60, &fi17x35, "%c", s[i++]); msDelay(300); } } glBlankScreen(); //------------------------------------------------------------------------ // Text Scrolling right and left example //------------------------------------------------------------------------ glPrintf(0, 0,&fi10x16,"Scroll Right&Left Demo"); msDelay(1200); FontWidth = 10; FontHeight = 16; sprintf(s, "Text to Scroll Right/Left"); glPrintf (0, 40, &fi10x16, "%s", s); msDelay(1000); NumPixel = 4; for(y = 0; y < 3; y++) { for(i=0; i<(LCD_XS -(strlen(s)*FontWidth)); i+=FontWidth) { glHScroll(0, 40, LCD_XS, FontHeight, FontWidth); } msDelay(500); for(i=0; i<(LCD_XS-(strlen(s)*FontWidth)); i+=FontWidth) { glHScroll(0, 40, LCD_XS, FontHeight, -FontWidth); } msDelay(500); } glBlankScreen(); } }
/* Low level output of a packet. Never call this from an interrupt context, as it may block until TX descriptors become available */ static err_t lpc_low_level_output(struct netif *netif, struct pbuf *sendp) { struct lpc_enetdata *lpc_netifdata = netif->state; u32_t idx, fidx, dn; struct pbuf *p = sendp; #if LPC_CHECK_SLOWMEM == 1 struct pbuf *q, *wp; u8_t *dst; int pcopy = 0; /* Check packet address to determine if it's in slow memory and relocate if necessary */ for (q = p; ((q != NULL) && (pcopy == 0)); q = q->next) { fidx = 0; for (idx = 0; idx < sizeof(slmem); idx += sizeof(struct lpc_slowmem_array_t)) { if ((q->payload >= (void *) slmem[fidx].start) && (q->payload <= (void *) slmem[fidx].end)) { /* Needs copy */ pcopy = 1; } } } if (pcopy) { /* Create a new pbuf with the total pbuf size */ wp = pbuf_alloc(PBUF_RAW, (u16_t) EMAC_ETH_MAX_FLEN, PBUF_RAM); if (!wp) { /* Exit with error */ return ERR_MEM; } /* Copy pbuf */ dst = (u8_t *) wp->payload; wp->tot_len = 0; for (q = p; q != NULL; q = q->next) { MEMCPY(dst, (u8_t *) q->payload, q->len); dst += q->len; wp->tot_len += q->len; } wp->len = wp->tot_len; /* LWIP will free original pbuf on exit of function */ p = sendp = wp; } #endif /* Zero-copy TX buffers may be fragmented across mutliple payload chains. Determine the number of descriptors needed for the transfer. The pbuf chaining can be a mess! */ dn = (u32_t) pbuf_clen(p); /* Wait until enough descriptors are available for the transfer. */ /* THIS WILL BLOCK UNTIL THERE ARE ENOUGH DESCRIPTORS AVAILABLE */ while (dn > lpc_tx_ready(netif)) #if NO_SYS == 0 {xSemaphoreTake(lpc_netifdata->xTXDCountSem, 0); } #else {msDelay(1); } #endif /* Get the next free descriptor index */ fidx = idx = lpc_netifdata->tx_fill_idx; #if NO_SYS == 0 /* Get exclusive access */ sys_mutex_lock(&lpc_netifdata->TXLockMutex); #endif /* Fill in the next free descriptor(s) */ while (dn > 0) { dn--; /* Setup packet address and length */ lpc_netifdata->ptdesc[idx].B1ADD = (u32_t) p->payload; lpc_netifdata->ptdesc[idx].BSIZE = (u32_t) TDES_ENH_BS1(p->len); /* Save pointer to pbuf so we can reclain the memory for the pbuf after the buffer has been sent. Only the first pbuf in a chain is saved since the full chain doesn't need to be freed. */ /* For first packet only, first flag */ lpc_netifdata->tx_free_descs--; if (idx == fidx) { lpc_netifdata->ptdesc[idx].CTRLSTAT |= TDES_ENH_FS; #if LPC_CHECK_SLOWMEM == 1 /* If this is a copied pbuf, then avoid getting the extra reference or the TX reclaim will be off by 1 */ if (!pcopy) { pbuf_ref(p); } #else /* Increment reference count on this packet so LWIP doesn't attempt to free it on return from this call */ pbuf_ref(p); #endif } else { lpc_netifdata->ptdesc[idx].CTRLSTAT |= TDES_OWN; } /* Save address of pbuf, but make sure it's associated with the first chained pbuf so it gets freed once all pbuf chains are transferred. */ if (!dn) { lpc_netifdata->txpbufs[idx] = sendp; } else { lpc_netifdata->txpbufs[idx] = NULL; } /* For last packet only, interrupt and last flag */ if (dn == 0) { lpc_netifdata->ptdesc[idx].CTRLSTAT |= TDES_ENH_LS | TDES_ENH_IC; } /* IP checksumming requires full buffering in IP */ lpc_netifdata->ptdesc[idx].CTRLSTAT |= TDES_ENH_CIC(3); LWIP_DEBUGF(EMAC_DEBUG | LWIP_DBG_TRACE, ("lpc_low_level_output: pbuf packet %p sent, chain %d," " size %d, index %d, free %d\n", p, dn, p->len, idx, lpc_netifdata->tx_free_descs)); /* Update next available descriptor */ idx++; if (idx >= LPC_NUM_BUFF_TXDESCS) { idx = 0; } /* Next packet fragment */ p = p->next; } lpc_netifdata->tx_fill_idx = idx; LINK_STATS_INC(link.xmit); /* Give first descriptor to DMA to start transfer */ lpc_netifdata->ptdesc[fidx].CTRLSTAT |= TDES_OWN; /* Tell DMA to poll descriptors to start transfer */ LPC_ETHERNET->DMA_TRANS_POLL_DEMAND = 1; #if NO_SYS == 0 /* Restore access */ sys_mutex_unlock(&lpc_netifdata->TXLockMutex); #endif return ERR_OK; }
//---------------------------------------------------------------------- // Read the temperature of a DS1920/DS1820 // // 'portnum' - number 0 to MAX_PORTNUM-1. This number was provided to // OpenCOM to indicate the port number. // 'SerialNum' - Serial Number of DS1920/DS1820 to read temperature from // 'Temp ' - pointer to variable where that temperature will be // returned // // Returns: TRUE(1) temperature has been read and verified // FALSE(0) could not read the temperature, perhaps device is not // in contact // int ReadTemperature(int portnum, uchar *SerialNum, float *Temp) { int rt=FALSE; uchar send_block[30],lastcrc8; int send_cnt=0, tsht, i, loop=0; float tmp,cr,cpc; setcrc8(portnum,0); // set the device serial number to the counter device owSerialNum(portnum,SerialNum,FALSE); for (loop = 0; rt==FALSE && loop < 2; loop ++) { // access the device if (owAccess(portnum)) { // send the convert temperature command owTouchByte(portnum,0x44); // set the 1-Wire Net to strong pull-up if (owLevel(portnum,MODE_STRONG5) != MODE_STRONG5) return FALSE; // sleep for 1 second msDelay(1000); // turn off the 1-Wire Net strong pull-up if (owLevel(portnum,MODE_NORMAL) != MODE_NORMAL) return FALSE; // access the device if (owAccess(portnum)) { // create a block to send that reads the temperature // read scratchpad command send_block[send_cnt++] = 0xBE; // now add the read bytes for data bytes and crc8 for (i = 0; i < 9; i++) send_block[send_cnt++] = 0xFF; // now send the block if (owBlock(portnum,FALSE,send_block,send_cnt)) { // perform the CRC8 on the last 8 bytes of packet for (i = send_cnt - 9; i < send_cnt; i++) lastcrc8 = docrc8(portnum,send_block[i]); // verify CRC8 is correct if (lastcrc8 == 0x00) { // calculate the high-res temperature tsht = send_block[1]/2; if (send_block[2] & 0x01) tsht |= -128; tmp = (float)(tsht); cr = send_block[7]; cpc = send_block[8]; if (((cpc - cr) == 1) && (loop == 0)) continue; if (cpc == 0) return FALSE; else tmp = tmp - (float)0.25 + (cpc - cr)/cpc; *Temp = tmp; // success rt = TRUE; } } } } } // return the result flag rt return rt; }
//-------------------------------------------------------------------------- // This is the begining of the program that tests the different Channels int main() //short argc, char **argv) { char return_msg[128]; //returned message from 1-wire operations int i,j,k,n; //loop counters short test=0; //info byte data short clear=0; //used to clear the button SwitchProps sw; //used to set Channel A and B uchar SwitchSN[MAXDEVICES][8]; //the serial numbers for the devices int num; //for the number of devices present int ch; //inputed character from user char out[140]; //used for output of the info byte data int portnum=0; //---------------------------------------- // Introduction header printf("\n/---------------------------------------------\n"); printf(" swtest - V2.00\n" " The following is a test to excersize the\n" " different channels on the DS2406.\n"); printf(" Press any CTRL-C to stop this program.\n\n"); // check for required port name if (argc != 2) { printf("1-Wire Net name required on command line!\n" " (example: \"COM1\" (Win32 DS2480),\"/dev/cua0\" " "(Linux DS2480),\"1\" (Win32 TMEX)\n"); exit(1); } // attempt to acquire the 1-Wire Net if (!owAcquire(portnum, argv[1], return_msg)) { printf("%s",return_msg); exit(1); } // success printf("%s",return_msg); // this is to get the number of the devices and the serial numbers num = FindDevices(portnum, &SwitchSN[0], SWITCH_FAMILY, MAXDEVICES); // setting up the first print out for the frist device owSerialNum(portnum, SwitchSN[0], FALSE); j=1; n=0; do { // This is for after the different combinations of channels // have been tested to reset to a different device to be tested. if( ((test & 0x40) && (j==5)) || ((!(test & 0x40)) && (j==3)) ) { printf("\n\n"); for(k=0; k < num; k++) { printf("%d ", k+1); for(i=7; i>=0; i--) { printf("%02X", SwitchSN[k][i]); } printf("\n"); } printf("%d To quit or any other key.\n", k+1); printf("\n"); printf("Pick a device\n"); ch = getkeystroke(); n = 0; n = (10*n + (ch - '0')) - 1; if( (n>num-1) || (n<0) ) { n = 0; //used to finish off the loop break; } owSerialNum(portnum, SwitchSN[n], FALSE); j = 1; } printf("\n"); test = ReadSwitch12(portnum,clear); // This looks at the info byte to determine if it is a // two or one channel device. if(test & 0x40) { switch(j) { case 1: sw.Chan_A = 0; sw.Chan_B = 0; break; case 2: sw.Chan_A = 0; sw.Chan_B = 1; break; case 3: sw.Chan_A = 1; sw.Chan_B = 0; break; case 4: sw.Chan_A = 1; sw.Chan_B = 1; break; default: sw.Chan_A = 1; sw.Chan_B = 1; j=0; break; } } else { switch(j) { case 1: sw.Chan_B = 0; sw.Chan_A = 0; break; case 2: sw.Chan_B = 0; sw.Chan_A = 1; break; default: sw.Chan_B = 0; sw.Chan_A = 1; j = 0; break; } } if(!SetSwitch12(portnum, SwitchSN[n], &sw)) { msDelay(50); if(SetSwitch12(portnum, SwitchSN[n], &sw)) msDelay(50); else printf("Switch not set\n"); } test = ReadSwitch12(portnum,clear); printf("\n"); for(i=7; i>=0; i--) { printf("%02X", SwitchSN[n][i]); } printf("\n"); SwitchStateToString12(test, out); printf("%s", out); j++; } while(1); // release the 1-Wire Net owRelease(portnum,return_msg); printf("%s",return_msg); exit(0); return 0; }
//--------------------------------------------------------------------------- // The main program that performs the operations on switches // int main(int argc, char **argv) { short test; //info byte data short clear=0; //used to clear the button short done; //to tell when the user is done SwitchProps sw; //used to set Channel A and B uchar SwitchSN[MAXDEVICES][8]; //the serial number for the devices int num; //for the number of devices present int i,j,n,count,result; //loop counters and indexes char out[140]; //used for output of the info byte data int portnum=0; long select; //inputed number from user //---------------------------------------- // Introduction header printf("\n/---------------------------------------------\n"); printf(" Switch - V3.00\n" " The following is a test to excersize the \n" " setting of the state in a DS2406.\n"); printf(" Press any CTRL-C to stop this program.\n\n"); // check for required port name if (argc != 2) { printf("1-Wire Net name required on command line!\n" " (example: \"COM1\" (Win32 DS2480),\"/dev/cua0\" " "(Linux DS2480),\"1\" (Win32 TMEX)\n"); exit(1); } // attempt to acquire the 1-Wire Net if ((portnum = owAcquireEx(argv[1])) < 0) { OWERROR_DUMP(stdout); exit(1); } // success printf("Port opened: %s\n",argv[1]); // this is to get the number of the devices and the serial numbers num = FindDevices(portnum, &SwitchSN[0], SWITCH_FAMILY, MAXDEVICES); // setting up the first print out for the frist device owSerialNum(portnum, SwitchSN[0], FALSE); printf("\n"); n=0; if(owAccess(portnum)) { // loop while not done do { test = ReadSwitch12(portnum, clear); for(i=7; i>=0; i--) printf("%02X", SwitchSN[n][i]); printf("\n"); count = SwitchStateToString12(test, out); printf("%s", out); // print menu select = 1; if (!EnterNum("\n\n(1) Display the switch Info\n" "(2) Clear activity Latches\n" "(3) Set Flip Flop(s) on switch\n" "(4) Select different device\n" "(5) Quit\n" "Select a Number", 1, &select, 1, 5)) break; printf("\n\n"); // do something from the menu selection clear = FALSE; switch(select) { case 1: // Display the switch Info done = FALSE; break; case 2: // Clear activity Latches clear = TRUE; done = FALSE; break; case 3: // Set Flip Flop(s) on switch select = 0; if (EnterNum("Channel A Flip Flop (1 set, 0 clear)", 1, &select, 0, 1)) { sw.Chan_A = (uchar)select; if(test & 0x40) { if (EnterNum("Channel B Flip Flop (1 set, 0 clear)", 1, &select, 0, 1)) { sw.Chan_B = (uchar)select; done = FALSE; } } else { sw.Chan_B = 0; done = FALSE; } printf("\n"); } // proceed to setting switch state if not done if (!done) { // loop to attempt to set the switch (try up to 5 times) count = 0; do { result = SetSwitch12(portnum, SwitchSN[n], sw); // if failed then delay to let things settle if (!result) msDelay(50); } while ((count++ < 5) && (result != TRUE)); // if could not set then show error if (!result) printf("Could not set Switch!\n"); } break; case 4: // Switch Devices // print the device list for(j=0; j < num; j++) { printf("%d ", j+1); for(i=7; i>=0; i--) { printf("%02X", SwitchSN[j][i]); } printf("\n"); } printf("\n"); // select the device select = 0; if (EnterNum("Select Device",1, &select, 1, num)) { n = (int)(select - 1); owSerialNum(portnum, SwitchSN[n], FALSE); done = FALSE; } break; case 5: // Done done = TRUE; break; default: break; } } while (!done); } //One Wire Access owRelease(portnum); printf("Closing port %s.\n", argv[1]); exit(0); return 0; }
//-------------------------------------------------------------------------- // Set the 1-Wire Net line level. The values for new_level are // as follows: // // 'portnum' - number 0 to MAX_PORTNUM-1. This number was provided to // OpenCOM to indicate the port number. // 'new_level' - new level defined as // MODE_NORMAL 0x00 // MODE_STRONG5 0x02 // MODE_PROGRAM 0x04 // MODE_BREAK 0x08 (not supported) // // Returns: current 1-Wire Net level // SMALLINT owLevel(int portnum, SMALLINT new_level) { uchar sendpacket[10],readbuffer[10]; uchar sendlen=0; uchar rt=FALSE; // check if need to change level if (new_level != ULevel[portnum]) { // check if just putting back to normal if (new_level == MODE_NORMAL) { // check if correct mode if (UMode[portnum] != MODSEL_COMMAND) { UMode[portnum] = MODSEL_COMMAND; sendpacket[sendlen++] = MODE_COMMAND; } // stop pulse command sendpacket[sendlen++] = MODE_STOP_PULSE; // flush the buffers FlushCOM(portnum); // send the packet if (WriteCOM(portnum,sendlen,sendpacket)) { msDelay(4); // read back the 1 byte response if (ReadCOM(portnum,1,readbuffer) == 1) { // check response byte if ((readbuffer[0] & 0xE0) == 0xE0) { rt = TRUE; ULevel[portnum] = MODE_NORMAL; } } else OWERROR(OWERROR_READCOM_FAILED); } else OWERROR(OWERROR_WRITECOM_FAILED); } // set new level else { // check if correct mode if (UMode[portnum] != MODSEL_COMMAND) { UMode[portnum] = MODSEL_COMMAND; sendpacket[sendlen++] = MODE_COMMAND; } // strong 5 volts if (new_level == MODE_STRONG5) { // set the SPUD time value sendpacket[sendlen++] = CMD_CONFIG | PARMSEL_5VPULSE | PARMSET_infinite; // add the command to begin the pulse sendpacket[sendlen++] = CMD_COMM | FUNCTSEL_CHMOD | SPEEDSEL_PULSE | BITPOL_5V; } // 12 volts else if (new_level == MODE_PROGRAM) { // check if programming voltage available if (!ProgramAvailable[portnum]) return MODE_NORMAL; // set the PPD time value sendpacket[sendlen++] = CMD_CONFIG | PARMSEL_12VPULSE | PARMSET_infinite; // add the command to begin the pulse sendpacket[sendlen++] = CMD_COMM | FUNCTSEL_CHMOD | SPEEDSEL_PULSE | BITPOL_12V; } // flush the buffers FlushCOM(portnum); // send the packet if (WriteCOM(portnum,sendlen,sendpacket)) { // read back the 1 byte response from setting time limit if (ReadCOM(portnum,1,readbuffer) == 1) { // check response byte if ((readbuffer[0] & 0x81) == 0) { ULevel[portnum] = new_level; rt = TRUE; } } else OWERROR(OWERROR_READCOM_FAILED); } else OWERROR(OWERROR_WRITECOM_FAILED); } // if lost communication with DS2480 then reset if (rt != TRUE) DS2480Detect(portnum); } // return the current level return ULevel[portnum]; }
void io_toggle(long delayMs, GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) { HAL_GPIO_WritePin(GPIOx, GPIO_Pin, GPIO_PIN_SET); msDelay(delayMs); HAL_GPIO_WritePin(GPIOx, GPIO_Pin, GPIO_PIN_RESET); }
/* LWIP kickoff and PHY link monitor thread */ static void vSetupIFTask(void *pvParameters) { ip_addr_t ipaddr, netmask, gw; volatile s32_t tcpipdone = 0; uint32_t physts; static int prt_ip = 0; DEBUGSTR("LWIP HTTP Web Server FreeRTOS Demo...\r\n"); /* Wait until the TCP/IP thread is finished before continuing or wierd things may happen */ DEBUGSTR("Waiting for TCPIP thread to initialize...\r\n"); tcpip_init(tcpip_init_done_signal, (void *) &tcpipdone); while (!tcpipdone) { msDelay(1); } DEBUGSTR("Starting LWIP HTTP server...\r\n"); /* Static IP assignment */ #if LWIP_DHCP IP4_ADDR(&gw, 0, 0, 0, 0); IP4_ADDR(&ipaddr, 0, 0, 0, 0); IP4_ADDR(&netmask, 0, 0, 0, 0); #else IP4_ADDR(&gw, 10, 1, 10, 1); IP4_ADDR(&ipaddr, 10, 1, 10, 234); IP4_ADDR(&netmask, 255, 255, 255, 0); #endif /* Add netif interface for lpc17xx_8x */ memset(&lpc_netif, 0, sizeof(lpc_netif)); if (!netif_add(&lpc_netif, &ipaddr, &netmask, &gw, NULL, lpc_enetif_init, tcpip_input)) { DEBUGSTR("Net interface failed to initialize\r\n"); while(1); } netif_set_default(&lpc_netif); netif_set_up(&lpc_netif); /* Enable MAC interrupts only after LWIP is ready */ NVIC_SetPriority(ETHERNET_IRQn, config_ETHERNET_INTERRUPT_PRIORITY); NVIC_EnableIRQ(ETHERNET_IRQn); #if LWIP_DHCP dhcp_start(&lpc_netif); #endif /* Initialize and start application */ http_server_netconn_init(); /* This loop monitors the PHY link and will handle cable events via the PHY driver. */ while (1) { /* Call the PHY status update state machine once in a while to keep the link status up-to-date */ physts = lpcPHYStsPoll(); /* Only check for connection state when the PHY status has changed */ if (physts & PHY_LINK_CHANGED) { if (physts & PHY_LINK_CONNECTED) { Board_LED_Set(0, true); prt_ip = 0; /* Set interface speed and duplex */ if (physts & PHY_LINK_SPEED100) { Chip_ENET_Set100Mbps(LPC_ETHERNET); NETIF_INIT_SNMP(&lpc_netif, snmp_ifType_ethernet_csmacd, 100000000); } else { Chip_ENET_Set10Mbps(LPC_ETHERNET); NETIF_INIT_SNMP(&lpc_netif, snmp_ifType_ethernet_csmacd, 10000000); } if (physts & PHY_LINK_FULLDUPLX) { Chip_ENET_SetFullDuplex(LPC_ETHERNET); } else { Chip_ENET_SetHalfDuplex(LPC_ETHERNET); } tcpip_callback_with_block((tcpip_callback_fn) netif_set_link_up, (void *) &lpc_netif, 1); } else { Board_LED_Set(0, false); tcpip_callback_with_block((tcpip_callback_fn) netif_set_link_down, (void *) &lpc_netif, 1); } /* Delay for link detection (250mS) */ vTaskDelay(configTICK_RATE_HZ / 4); } /* Print IP address info */ if (!prt_ip) { if (lpc_netif.ip_addr.addr) { static char tmp_buff[16]; DEBUGOUT("IP_ADDR : %s\r\n", ipaddr_ntoa_r((const ip_addr_t *) &lpc_netif.ip_addr, tmp_buff, 16)); DEBUGOUT("NET_MASK : %s\r\n", ipaddr_ntoa_r((const ip_addr_t *) &lpc_netif.netmask, tmp_buff, 16)); DEBUGOUT("GATEWAY_IP : %s\r\n", ipaddr_ntoa_r((const ip_addr_t *) &lpc_netif.gw, tmp_buff, 16)); prt_ip = 1; } } } }