ERRORTYPE SensorManager::run() { ERRORTYPE eRet = ET_OK; for(uint8_t u8Loop = 0; u8Loop < m_sConfig.u8SensorCount; ++u8Loop) { eRet = m_sConfig.pSensorList[u8Loop]->run(); if(ET_OK != eRet) { xSemaphoreTake(xConsoleMutex, portMAX_DELAY); xSerialPrint_P(PSTR("/SENSOR MGR/ ")); xSerialPrint_P(m_sConfig.pSensorList[u8Loop]->getMeasDataInfo(0).psMeasDataDescription); xSerialxPrintf_P( &xSerialPort, PSTR(", in state %u, encountered problems.\r\n"),m_sConfig.pSensorList[u8Loop]->getSensorState()); xSemaphoreGive(xConsoleMutex); break; } } if( (ET_OK == eRet) && (pdTRUE == xTaskCheckForTimeOut(&m_sLastResultPrintTimestamp, &m_sPrintResultsTimeout))) { this->printResultsStdOut(); vTaskSetTimeOutState(&m_sLastResultPrintTimestamp); m_sPrintResultsTimeout = m_sConfig.sPrintResultsTimeout; } return eRet; }
ERRORTYPE SensorManager::printResultsStdOut() { ERRORTYPE eRet = ET_OK; //iterate through each sensor for(uint8_t u8SensorNo = 0; u8SensorNo < m_sConfig.u8SensorCount; ++u8SensorNo) { //iterate through each measurment data type which is provided by the sensor for(uint8_t u8MeasDataNo = 0; u8MeasDataNo < m_sConfig.pSensorList[u8SensorNo]->getMeasDataCount(); ++u8MeasDataNo) { ISensor::MeasurementDataInfo eMeasDataInfo = m_sConfig.pSensorList[u8SensorNo]->getMeasDataInfo(u8MeasDataNo); uint32_t u32Result = m_sConfig.pSensorList[u8SensorNo]->getResult(eMeasDataInfo.eMeasDataType); xSemaphoreTake(xConsoleMutex, portMAX_DELAY); xSerialPrint_P(PSTR("|Sensor Mgr| ")); xSerialPrint_P(eMeasDataInfo.psMeasDataDescription); xSerialxPrintf_P( &xSerialPort, PSTR(" = %lu "),u32Result); xSerialPrint_P(eMeasDataInfo.psUnits); xSerialPrint_P(PSTR("\r\n")); xSemaphoreGive(xConsoleMutex); } } return eRet; }
/** * @brief Initialise the socket & buffer for HTTP server */ uint8_t init_httpd_ch(SOCKET s) { uint8_t ret; ret = 0; if( getSn_SR(s) != SOCK_CLOSED ) // Check the preferred socket is available, { s = getSocket(SOCK_CLOSED, 0); // otherwise find free socket, if(s == MAX_SOCK_NUM ) // If there is no free socket? ret = 0; } else { ret = 1; } if(!socket(s, Sn_MR_TCP, IP_PORT_HTTP, 0x00)) // initialise the socket for DHCP service { xSerialPrintf_P(PSTR("HTTPD socket: %d, initialise fail..!\r\n"),s); ret = 0; } #ifdef HTTP_DEBUG else xSerialPrintf_P(PSTR("HTTPD socket: %d, initialise success..!\r\n"),s); #endif if(pHTTPRequest == NULL) // if there is no buffer allocated (pointer is NULL), then allocate request buffer for all HTTP functions. { if( !(pHTTPRequest = (HTTP_REQUEST *) pvPortMalloc( sizeof(HTTP_REQUEST) ))) { xSerialPrint_P(PSTR("HTTP Request Buffer: malloc fail..!\r\n")); ret = 0; } #ifdef HTTP_DEBUG else xSerialPrint_P(PSTR("HTTP Request Buffer: malloc success..!\r\n")); #endif } if(pHTTPResponse == NULL) // if there is no buffer allocated (pointer is NULL), then allocate response buffer for all HTTP functions. { if( !(pHTTPResponse = (uint8_t *) pvPortMalloc( sizeof(uint8_t) * (FILE_BUFFER_SIZE + 1) ))) { xSerialPrint_P(PSTR("HTTP Response Buffer: malloc fail..!\r\n")); vPortFree(pHTTPRequest); ret = 0; } #ifdef HTTP_DEBUG else xSerialPrint_P(PSTR("HTTP Response Buffer: malloc success..!\r\n")); #endif } HTTPD_SOCK = s; return ret; }
/** @brief This Socket function initialise the channel in particular mode, and set the port and wait for W5200/W5100 to complete its state change. @return 1 for success else 0. */ uint8_t socket( SOCKET s, /**< for socket number */ uint8_t protocol, /**< for socket protocol */ uint16_t port, /**< the source port for the socket */ uint8_t flag /**< the option for the socket */ ) { uint8_t ret; #ifdef __DEF_WIZCHIP_DBG__ xSerialPrint_P(PSTR(" socket()\r\n")); #endif if ( (protocol == Sn_MR_TCP) || (protocol == Sn_MR_UDP) || (protocol == Sn_MR_IPRAW) || (protocol == Sn_MR_MACRAW) || (protocol == Sn_MR_PPPOE) ) { close(s); WIZCHIP_write(Sn_MR(s), (protocol | flag) ); if (port != 0) { WIZCHIP_write(Sn_PORT0(s), (uint8_t)((port & 0xff00) >> 8)); WIZCHIP_write(Sn_PORT1(s), (uint8_t)(port & 0x00ff)); } else {
void network_init(void) { extern uip_eth_addr my_eth_addr; // the Ethernet address assigned in the application /*-----------------------------------------------------------*/ /* Network related stuff */ IINCHIP_init(); // reset W5200 - First call to make setSHAR(my_eth_addr.addr); #ifdef portW5200 // TX MEM SIZE: Permissible values: 1:(1024) 2:(2048) 4:(4096) 8:(8192) 16:(16384) // RX MEM SIZE: Total for 8 ports shall equal not more than 16 // Initialised in IINCHIP_init() in w5200.c extern uint8_t txsize[MAX_SOCK_NUM]; extern uint8_t rxsize[MAX_SOCK_NUM]; IINCHIP_sysinit ((uint8_t *)txsize, (uint8_t *)rxsize); // set the Tx and Rx buffers #else IINCHIP_sysinit(0x55, 0x55); #endif if (!socket( MACRAW_PREFERRED_SOCKET, Sn_MR_MACRAW, 0x00, 0x00) ) // Opens the MAC raw mode socket. { #ifdef __DEF_IINCHIP_DBG__ xSerialPrint_P(PSTR("uIP MACRAW socket: 0, initialise fail..!\r\n")); #endif return; } }
/** * This method is called periodically to check for new messages on the USB bus and process them. */ void hid_poll(void) { hid_bootReport message; // Poll the USB layer. usb_poll(); // If no USB device, there's no work for us to be done, so just return. if (hidDevice==NULL) return; // If not connected just return. if (!connected) return; // Check for an incoming HID message. don't wait for incoming packet so set "true" if ( !hid_pollMessage(&message, true) ) {return;} #ifdef DEBUG else { xSerialPrint_P(PSTR("\r\nIN >> ")); hid_printMessage(&message);} #endif // Handle messages if (*theConnection == HID_OPEN ) hid_handleMessage( &message ); else hid_handleOkay( &message ); // we got a character, so set the Connection to OPEN. }
void network_init(void) { /*-----------------------------------------------------------*/ /* Network related stuff */ #if (_WIZCHIP_ == 5100) WIZCHIP_init(); // reset W5200 - First call to make WIZCHIP_sysinit(0x55, 0x55); #else WIZCHIP_init(); // reset W5200/W5500 - First call to make // TX MEM SIZE: Permissible values: 1:(1024) 2:(2048) 4:(4096) 8:(8192) 16:(16384) // RX MEM SIZE: Total for 8 ports shall equal not more than 16 // Initialised in WIZCHIP_init() in wizchip_conf.c extern uint8_t txsize[_WIZCHIP_MAX_SOC_NUM_]; extern uint8_t rxsize[_WIZCHIP_MAX_SOC_NUM_]; WIZCHIP_sysinit ((uint8_t *)txsize, (uint8_t *)rxsize); // set the Tx and Rx buffers #endif #if (_WIZCHIP_ != 5500) // xxx the Wiz550io has its MAC address loaded by the onboard MCU. extern uip_eth_addr my_eth_addr; // the Ethernet address assigned in the application setSHAR(my_eth_addr.addr); #endif if (!socket( MACRAW_SOCKET, Sn_MR_MACRAW, 0x00, 0x00) ) // Opens the MAC raw mode socket. { #ifdef __DEF_WIZCHIP_DBG__ xSerialPrint_P(PSTR("uIP MACRAW socket: 0, initialise fail..!\r\n")); #endif return; } }
/** @brief make response header such as html, gif, jpeg, zip, etc. */ void make_http_response_head( uint8_t * buf, /**< pointer to response header to be made */ uint8_t type, /**< response type */ uint32_t len /**< size of response file / document */ ) { PGM_P head = 0; uint8_t tmp[16]; switch (type) { case PTYPE_HTML : head = RES_HTMLHEAD_OK; break; case PTYPE_GIF : head = RES_GIFHEAD_OK; break; case PTYPE_TEXT : head = RES_TEXTHEAD_OK; break; case PTYPE_JPEG : head = RES_JPEGHEAD_OK; break; case PTYPE_FLASH : head = RES_FLASHHEAD_OK; break; case PTYPE_MPEG : head = RES_MPEGHEAD_OK; break; case PTYPE_PDF : head = RES_PDFHEAD_OK; break; case PTYPE_ZIP : head = RES_ZIPHEAD_OK; break; default: #ifdef HTTP_DEBUG xSerialPrint_P(PSTR("\r\n\r\nHTTP RESPONSE HEADER UNKNOWN-\r\n")); #endif break; } sprintf((char *)tmp,"%ld", len); strcpy_P((char *)buf, head); strcat((char *)buf, (const char *)tmp); strcat_P((char *)buf, PSTR("\r\n\r\n\0")); }
void network_send(void) { if (uip_len > 0) { if( !macraw_send( (uint8_t*)uip_buf, uip_len) ) { #ifdef __DEF_WIZCHIP_DBG__ xSerialPrint_P(PSTR("\r\nuIP MACRAW: Fatal Error(0).")); #endif } } }
void network_send(void) { if (uip_len > 0) { if( !macrawsend( MACRAW_PREFERRED_SOCKET, (uint8_t*)uip_buf, uip_len) ) { #ifdef __DEF_IINCHIP_DBG__ xSerialPrint_P(PSTR("\r\nuIP MACRAW: Fatal Error(0).")); #endif } } }
static void TaskMonitor(void *pvParameters) // Monitor for Serial Interface { (void) pvParameters; uint8_t *ptr; int32_t p1; // create the buffer on the heap (so they can be moved later). if(LineBuffer == NULL) // if there is no Line buffer allocated (pointer is NULL), then allocate buffer. if( !(LineBuffer = (uint8_t *) pvPortMalloc( sizeof(uint8_t) * LINE_SIZE ))) xSerialPrint_P(PSTR("pvPortMalloc for *LineBuffer fail..!\r\n")); while(1) { xSerialPutChar(&xSerialPort, '>'); ptr = LineBuffer; get_line(ptr, (uint8_t)(sizeof(uint8_t)* LINE_SIZE)); //sizeof (Line); switch (*ptr++) { case 'h' : // help xSerialPrint_P( PSTR("rt - reset maximum & minimum temperatures\r\n") ); xSerialPrint_P( PSTR("t - show the time\r\n") ); xSerialPrint_P( PSTR("t - set the time\r\nt [<year yy> <month mm> <date dd> <day: Sun=0> <hour hh> <minute mm> <second ss>]\r\n") ); break; #ifdef portRTC_DEFINED case 't' : /* t [<year yy> <month mm> <date dd> <day: Sun=0> <hour hh> <minute mm> <second ss>] */ if (xatoi(&ptr, &p1)) { SetTimeDate.tm_year = (uint8_t)p1 + 100; // convert to (Gregorian - 1900) xatoi(&ptr, &p1); SetTimeDate.tm_mon = (uint8_t)p1; xatoi(&ptr, &p1); SetTimeDate.tm_mday = (uint8_t)p1; xatoi(&ptr, &p1); SetTimeDate.tm_wday = (uint8_t)p1; xatoi(&ptr, &p1); SetTimeDate.tm_hour = (uint8_t)p1; xatoi(&ptr, &p1); SetTimeDate.tm_min = (uint8_t)p1; if (!xatoi(&ptr, &p1)) break; SetTimeDate.tm_sec = (uint8_t)p1; xSerialPrintf_P(PSTR("Set: %u/%u/%u %2u:%02u:%02u\r\n"), SetTimeDate.tm_year, SetTimeDate.tm_mon, SetTimeDate.tm_mday, SetTimeDate.tm_hour, SetTimeDate.tm_min, SetTimeDate.tm_sec); if (setDateTimeDS1307( &SetTimeDate ) == pdTRUE) xSerialPrint_P( PSTR("Setting successful\r\n") ); } else { if (getDateTimeDS1307( &xCurrentTempTime.DateTime) == pdTRUE) xSerialPrintf_P(PSTR("Current: %u/%u/%u %2u:%02u:%02u\r\n"), xCurrentTempTime.DateTime.tm_year + 1900, xCurrentTempTime.DateTime.tm_mon, xCurrentTempTime.DateTime.tm_mday, xCurrentTempTime.DateTime.tm_hour, xCurrentTempTime.DateTime.tm_min, xCurrentTempTime.DateTime.tm_sec); } break; #endif case 'r' : // reset switch (*ptr++) { case 't' : // temperature xMaximumTempTime = xCurrentTempTime; xMinimumTempTime = xCurrentTempTime; // Now we commit the time and temperature to the EEPROM, forever... eeprom_update_block(&xMaximumTempTime, &xMaximumEverTempTime, sizeof(xRTCTempArray)); eeprom_update_block(&xMinimumTempTime, &xMinimumEverTempTime, sizeof(xRTCTempArray)); break; default : break; } break; default : break; } // xSerialPrintf_P(PSTR("\r\nSerial Monitor: Stack HighWater @ %u"), uxTaskGetStackHighWaterMark(NULL)); // xSerialPrintf_P(PSTR("\r\nFree Heap Size: %u\r\n"), xPortGetMinimumEverFreeHeapSize() ); // needs heap_1, heap_2 or heap_4 for this function to succeed. } }
/** @brief Analyse HTTP request and then services WEB. */ void process_HTTP( SOCKET s, /**< http server socket */ uint8_t * buffer, /**< buffer pointer included http request */ uint16_t length /**< length of http request */ ) { uint8_t * name; uint16_t bytes_read; TickType_t wait_send; FIL source_file; /* File object for the source file */ parse_HTTP_request(pHTTPRequest, buffer); // After analysing request, convert into pHTTPRequest /* method Analyse */ switch (pHTTPRequest->METHOD) { case METHOD_HEAD: case METHOD_GET : case METHOD_POST : name = get_HTTP_URI_name(pHTTPRequest->URI); if (!strcmp((const char *)name, "/")) strcpy((char *)name,"index.htm"); // If URI is "/", respond by index.htm #ifdef WEB_DEBUG if(strlen( (const char *)name) < MAX_INT_STR ) xSerialPrintf_P(PSTR("\r\nPAGE : %s "), name); else xSerialPrint_P(PSTR("\r\nFILENAME TOO LONG")); #endif find_HTTP_URI_type(&pHTTPRequest->TYPE, name); //Check file type (HTML, TEXT, ICO, GIF, JPEG, ZIP are included) // OK now we start to respond to the info we've decoded. /* Open the specified file stored in the SD card FAT32 */ if (f_open(&source_file, (const TCHAR *)name, FA_OPEN_EXISTING | FA_READ)) { // if file open failure memcpy_P( (char *)pHTTPResponse, ERROR_HTML_PAGE, strnlen_P(ERROR_HTML_PAGE, FILE_BUFFER_SIZE) ); #ifdef WEB_DEBUG xSerialPrint_P(PSTR("HTTP Unknown file or page.\r\n")); xSerialPrintf_P(PSTR("HTTP Response...\r\n%s\r\nResponse Size: %u \r\n"), pHTTPResponse, strlen_P(ERROR_HTML_PAGE)); #endif send( s, (const uint8_t*)pHTTPResponse, strlen_P(ERROR_HTML_PAGE)); } else { // if file open success make_HTTP_response_header( pHTTPResponse, pHTTPRequest->TYPE, source_file.fsize); #ifdef WEB_DEBUG xSerialPrintf_P(PSTR("HTTP Opened file: %s Source Size: %u \r\n"), name, source_file.fsize); xSerialPrintf_P(PSTR("HTTP Response Header...\r\n%s\r\nResponse Header Size: %u \r\n"), pHTTPResponse, strlen((char*)pHTTPResponse )); #endif send(s, (const uint8_t*)pHTTPResponse, strlen((char*)pHTTPResponse )); wait_send = xTaskGetTickCount(); while(getSn_TX_FSR(s)!= WIZCHIP_getTxMAX(s)) { if( (xTaskGetTickCount() - wait_send) > (WEBSERVER_SOCKET_TIMEOUT / portTICK_PERIOD_MS) ) // wait up to 1.5 Sec { #ifdef WEB_DEBUG xSerialPrint_P(PSTR("HTTP Response head send fail\r\n")); #endif break; } vTaskDelay( 0 ); // yield until next tick. } for (;;) { if ( f_read(&source_file, pHTTPResponse, (sizeof(uint8_t)*(FILE_BUFFER_SIZE) ), &bytes_read) || bytes_read == 0 ) break; // read error or reached end of file if(pHTTPRequest->TYPE == PTYPE_HTML) // if we've got a html document, there might be some system variables to set { *(pHTTPResponse + bytes_read + 1) = 0; // make the buffer a string, null terminated bytes_read = replace_sys_env_value(pHTTPResponse, bytes_read); // Replace html system environment value to real value } if (send(s, (const uint8_t*)pHTTPResponse, bytes_read) != bytes_read) break; // TCP/IP send error wait_send = xTaskGetTickCount(); while(getSn_TX_FSR(s)!= WIZCHIP_getTxMAX(s)) { if( (xTaskGetTickCount() - wait_send) > (WEBSERVER_SOCKET_TIMEOUT / portTICK_PERIOD_MS) ) // wait up to 1.5 Sec { #ifdef WEB_DEBUG xSerialPrint_P(PSTR("HTTP Response body send fail\r\n")); #endif break; } vTaskDelay( 0 ); // yield until next tick. } } f_close(&source_file); eeprom_busy_wait(); eeprom_update_dword( &pagesServed, eeprom_read_dword(&pagesServed) +1 ); } break; case METHOD_ERR : memcpy_P( (char *)pHTTPResponse, ERROR_REQUEST_PAGE, strnlen_P(ERROR_REQUEST_PAGE, FILE_BUFFER_SIZE) ); #ifdef WEB_DEBUG xSerialPrint_P(PSTR("HTTP Method Error.\r\n")); xSerialPrintf_P(PSTR("HTTP Response...\r\n%s\r\nResponse Size: %u \r\n"), pHTTPResponse, strlen_P(ERROR_REQUEST_PAGE)); #endif send( s, (const uint8_t*)pHTTPResponse, strlen_P(ERROR_REQUEST_PAGE)); break; default : break; } }
static void hid_printMessage(hid_bootReport * message) { xSerialPrint_P(PSTR("HID message\r\n")); hid_put_dump (message->generic, sizeof(hid_bootReport)); }
/** * Handles events from the USB layer. * * @param device USB device that generated the event. * @param event USB event. */ static void hid_usbEventHandler(usb_device * device, usb_eventType event) { hid_usbConfiguration handle; switch (event) { case USB_CONNECT: xSerialPrint_P(PSTR("HID_USB_CONNECT\r\n")); // Check if the newly connected device is an HID device, and initialise it if so. if (hid_isHIDDevice(device, HID_PROTOCOL_KEYBOARD, &handle)) { hid_initUsb(device, &handle); // Success, signal that we are now connected by setting the global device handler to the connected device. hidDevice = device; connected = true; *theConnection = HID_OPEN; // set the device to idle so that it (particularly for a keyboard) only reports when there is an event. hid_setIdle(device); } break; case USB_DISCONNECT: xSerialPrint_P(PSTR("HID_USB_DISCONNECT\r\n")); // Check if the device that was disconnected is the HID device we've been using. if (device == hidDevice) { // Close all open HID connections. hid_closeAll(); // Signal that we're no longer connected by setting the global device handler to NULL; hidDevice = NULL; connected = false; *theConnection = HID_CLOSED; } break; case USB_ADRESSING_ERROR: xSerialPrint_P(PSTR("HID_USB_ADRESSING_ERROR\r\n")); // Check if the device that was disconnected is the HID device we've been using. if (device == hidDevice) { // Close all open HID connections. hid_closeAll(); // Signal that we're no longer connected by setting the global device handler to NULL; hidDevice = NULL; connected = false; *theConnection = HID_ERROR; } break; default: // ignore break; } }
int usb_dispatchPacket(uint8_t token, usb_endpoint * endpoint, unsigned int nakLimit) { // uint32_t timeout = avr_millis() + USB_XFER_TIMEOUT; uint16_t timeout = xTaskGetTickCount() + USB_XFER_TIMEOUT / portTICK_RATE_MS; // XXX from freeRTOS uint8_t tmpdata; uint8_t rcode = 0; unsigned int nak_count = 0; char retry_count = 0; while (timeout > xTaskGetTickCount() ) { // Analyze transfer result. // Launch the transfer. max3421e_write(MAX_REG_HXFR, (token | endpoint->address)); rcode = 0xff; // Wait for interrupt while (timeout > xTaskGetTickCount() ) { tmpdata = max3421e_read(MAX_REG_HIRQ); if (tmpdata & bmHXFRDNIRQ) { // Clear the interrupt. max3421e_write(MAX_REG_HIRQ, bmHXFRDNIRQ); rcode = 0x00; break; } } // Exit if timeout. if (rcode != 0x00) return (rcode); // Wait for HRSL while (timeout > xTaskGetTickCount() ) { rcode = (max3421e_read(MAX_REG_HRSL) & 0x0f); if (rcode != hrBUSY) break; else xSerialPrint_P(PSTR("USB dispatch busy!\r\n")); } switch (rcode) { case hrNAK: nak_count++; if (nak_count == nakLimit) return (rcode); break; case hrTIMEOUT: retry_count++; if (retry_count == USB_RETRY_LIMIT) return (rcode); break; default: return (rcode); } } return (rcode); }
/** @brief Send ping-request to the specified peer and receive ping-reply from the specified peer. @return 1 - success, 0 - fail because free socket is not found or can't be opened. */ uint8_t ping( uint8_t count, /**< Ping request count. */ uint16_t time, /**< wait ping reply time (unit : ms) */ uint8_t* addr, /**< Peer IP Address string in dotted decimal format */ PING_LOG* log /**< result of ping */ ) { PING_MSG* pPingRequest; // pointer for Ping Request PING_MSG* pPingReply; // pointer for Ping Reply uint32_t peerip; // 32 bit Peer IP Address uint32_t tempip; // IP address received from a destination uint16_t port; // port number received from a destination SOCKET s; // socket variable for pinging uint16_t RandomSeqNum; // Ping-Request ID uint16_t len; uint8_t IsReceived; // Received packet = 1, not received packet = 0 portTickType xInitialTick; /* Initialise PingRequest */ if( !(pPingRequest = (PING_MSG *) pvPortMalloc( sizeof(PING_MSG) ))) return 0; if( !(pPingReply = (PING_MSG *) pvPortMalloc( sizeof(PING_MSG) ))) { vPortFree(pPingRequest); return 0; } RandomSeqNum = htons( (uint16_t)rand()); // set ping-request's sequence number to random integer value pPingRequest->type = 0x08; // Ping-Request - ICMP pPingRequest->code = 0x00; // always 0 pPingRequest->checksum = 0; // value of checksum before calculating checksum of ping-request packet pPingRequest->id = htons(PING_ID); // set ping-request ID for(uint16_t i = 0 ; i < PING_OPT_LEN; i++) pPingRequest->OPT[i] = 'a' + i % 23; // fill 'a'~'w' characters into ping-request's data /* Initialise result of ping */ memset((void*)log,0,sizeof(PING_LOG)); /* Verify arguments */ if(!count) count = 4; // set count to default value (4 pings) if(!time) time = 1000; // set response time to default value (1000ms) /* Create a ping socket */ s = getSocket(SOCK_CLOSED,0); if(s == MAX_SOCK_NUM) // if it isn't exist free socket, Error { vPortFree(pPingRequest); vPortFree(pPingReply); return 0; } setSn_PROTO(s,IP_PROTO_ICMP); // Set upper-protocol of IP protocol if( socket( s, Sn_MR_IPRAW, 3000, 0) == 0) // Open IP_RAW Mode , if fail then Error { vPortFree(pPingRequest); vPortFree(pPingReply); return 0; } peerip = htonl( inet_addr(addr)); // convert address string into 32bit address xSerialPrintf_P(PSTR("\r\nPinging %s with %d bytes of data:\r\n"), addr, (sizeof(PING_MSG) - 8)); /* Ping Service */ while( count-- != 0) { IsReceived = 0; pPingRequest->seqNum = htons( RandomSeqNum++); // Increase Sequence number for next ping-request packet pPingRequest->checksum = 0; pPingRequest->checksum = htons( checksum( (uint8_t*)pPingRequest, sizeof(PING_MSG))); // update checksum field (*log).PingRequest++; // Increase PingRequest's value xInitialTick = xTaskGetTickCount(); if( sendto( s, (const uint8_t *)pPingRequest, sizeof(PING_MSG), (uint8_t*)&peerip, 3000)== 0) // Send Ping-Request to the specified peer. If fail, then it is occurred ARP Error. { (*log).ARPErr++; // Increase ARPErr close(s); // close the pinging socket /* Reopen pinging socket */ setSn_PROTO(s,IP_PROTO_ICMP); if(socket( s, Sn_MR_IPRAW, 3000, 0)==0) { vPortFree(pPingRequest); vPortFree(pPingReply); return 0; } continue; } while( xTaskGetTickCount() < (xInitialTick + ( time / portTICK_RATE_MS )) ) // as long as time is remaining { if((len = getSn_RX_RSR(s)) > 0) // Has pinging socket received a packet? { len = recvfrom( s, (uint8_t*)pPingReply, len, (uint8_t*)&tempip, &port); // receive a packet from unknown peer xSerialPrintf_P(PSTR("\r\nReply from %s"), inet_ntoa( ntohl(tempip))); // convert 32 bit unknown peer IP address into string of IP Address. if( checksum((uint8_t*)pPingReply,len) != 0) // if the packet's checksum value is correct { // not correct (*log).CheckSumErr++; // checksum error if(tempip == peerip) IsReceived = 1; xSerialPrint_P(PSTR(": Checksum Error")); } else if(pPingReply->type == 0) // if the received packet is ping-reply { if((pPingReply->id!=pPingRequest->id) || (pPingReply->seqNum!=pPingRequest->seqNum) || (tempip!=peerip)) // verify id,sequence nubmer, and ip address { xSerialPrint_P(PSTR(": Unmatched ID / SeqNum from peer")); // fail to verify (*log).UnknownMSG++; } else // success { IsReceived = 1; xSerialPrintf_P(PSTR(": bytes=%d, time<=%dms"),len-8,(xTaskGetTickCount()-xInitialTick)*portTICK_RATE_MS ); (*log).PingReply++; } } else if( pPingReply->type == 3) // If the packet is unreachable message { IsReceived = 1; xSerialPrint_P(PSTR(": Destination unreachable")); (*log).UnreachableMSG++; } else if( pPingReply->type == 11) // If the packet is time exceeded message { IsReceived = 1; xSerialPrint_P(PSTR(": TTL expired in transit")); (*log).TimeExceedMSG++; } else if( pPingReply->type == 8) // Send ping reply to a peer { xSerialPrint_P(PSTR(": Ping Request message")); SendPingReply(pPingReply,tempip); } else // if the packet is unknown message { xSerialPrintf_P(PSTR(": Unknown message (type = 0x%02X)"), pPingReply->type); (*log).UnknownMSG++; } } else if(getSn_SR(s)==SOCK_CLOSED) // if it is occurred to fail to send arp packet { (*log).ARPErr++; close(s); // close the pinging socket setSn_PROTO( s, IP_PROTO_ICMP); // reopen the pinging socket if(socket( s, Sn_MR_IPRAW, 3000, 0) == 0 ) { vPortFree(pPingRequest); vPortFree(pPingReply); return 0; } break; } if((xTaskGetTickCount() >= (xInitialTick + ( time / portTICK_RATE_MS ))) && (IsReceived == 0)) // If it is not received packet from the specified peer during waiting ping-reply packet. { (*log).Loss++; xSerialPrint_P(PSTR("Request timed out\r\n")); } } } /* Release pinging socket */ setSn_PROTO(s,0); close(s); vPortFree(pPingRequest); vPortFree(pPingReply); return 1; }
/** @brief parse http request from a peer */ void parse_http_request( HTTP_REQUEST *request, /**< request to be returned */ uint8_t *buffer /**< pointer to be parsed */ ) { uint8_t *nexttok; nexttok = (uint8_t *)strtok((char *)buffer," "); if(!nexttok) { request->METHOD = METHOD_ERR; return; } if (!strcmp_P((const char *)nexttok, PSTR("GET")) || !strcmp_P((const char *)nexttok, PSTR("get"))) { request->METHOD = METHOD_GET; nexttok = (uint8_t *)strtok(NULL," "); #ifdef HTTP_DEBUG xSerialPrint_P(PSTR("METHOD_GET ")); #endif } else if (!strcmp_P((const char *)nexttok, PSTR("HEAD")) || !strcmp_P((const char *)nexttok, PSTR("head"))) { request->METHOD = METHOD_HEAD; nexttok = (uint8_t *)strtok(NULL," "); #ifdef HTTP_DEBUG xSerialPrint_P(PSTR("METHOD_HEAD ")); #endif } else if (!strcmp_P((const char *)nexttok, PSTR("POST")) || !strcmp_P((const char *)nexttok, PSTR("post"))) { nexttok = (uint8_t *)strtok((char *)NULL,"\0"); request->METHOD = METHOD_POST; #ifdef HTTP_DEBUG xSerialPrint_P(PSTR("METHOD_POST ")); #endif } else { request->METHOD = METHOD_ERR; #ifdef HTTP_DEBUG xSerialPrint_P(PSTR("METHOD_ERR ")); #endif } if(!nexttok) { request->METHOD = METHOD_ERR; #ifdef HTTP_DEBUG xSerialPrint_P(PSTR("METHOD_ERR ")); #endif return; } strcpy((char *)request->URI,(const char *)nexttok); #ifdef HTTP_DEBUG { uint16_t i; xSerialPrint_P(PSTR("\nhttp_request->URI: ")); for(i=0; i < strlen((const char *)request->URI);i++) xSerialPrintf_P(PSTR("%c"),request->URI[i]); xSerialPrint_P(PSTR("")); } #endif }