/** * \brief Start file downloading via http connection. */ static void start_download(void) { if (!is_state_set(STORAGE_READY)) { printf("start_download: MMC storage not ready.\r\n"); return; } if (!is_state_set(WIFI_CONNECTED)) { printf("start_download: Wi-Fi is not connected.\r\n"); return; } if (is_state_set(GET_REQUESTED)) { printf("start_download: request is sent already.\r\n"); return; } if (is_state_set(DOWNLOADING)) { printf("start_download: running download already.\r\n"); return; } /* Send the HTTP request. */ printf("start_download: send http request.\r\n"); http_client_send_request(&http_client_module_inst, MAIN_HTTP_FILE_URL, HTTP_METHOD_GET, NULL, NULL); }
/** * \brief Callback of the HTTP client. * * \param[in] module_inst Module instance of HTTP client module. * \param[in] type Type of event. * \param[in] data Data structure of the event. \refer http_client_data */ static void http_client_callback(struct http_client_module *module_inst, int type, union http_client_data *data) { switch (type) { case HTTP_CLIENT_CALLBACK_SOCK_CONNECTED: printf("Http client socket connected\r\n"); break; case HTTP_CLIENT_CALLBACK_REQUESTED: printf("Request completed\r\n"); add_state(GET_REQUESTED); break; case HTTP_CLIENT_CALLBACK_RECV_RESPONSE: printf("Received response %u data size %u\r\n", (unsigned int)data->recv_response.response_code, (unsigned int)data->recv_response.content_length); if ((unsigned int)data->recv_response.response_code == 200) { http_file_size = data->recv_response.content_length; received_file_size = 0; } else { add_state(CANCELED); return; } break; case HTTP_CLIENT_CALLBACK_RECV_CHUNKED_DATA: store_file_packet(data->recv_chunked_data.data, data->recv_chunked_data.length); if (data->recv_chunked_data.is_complete) { add_state(COMPLETED); } break; case HTTP_CLIENT_CALLBACK_DISCONNECTED: printf("Disconnected reason:%d\r\n", data->disconnected.reason); /* If disconnect reason is equal to -ECONNRESET(-104), * It means the server has closed the connection (timeout). * This is normal operation. */ if (data->disconnected.reason == -EAGAIN) { /* Server has not responded. Retry immediately. */ if (is_state_set(DOWNLOADING)) { f_close(&file_object); clear_state(DOWNLOADING); } if (is_state_set(GET_REQUESTED)) { clear_state(GET_REQUESTED); } start_download(); } break; } }
/** * \brief Store received packet to file. * \param[in] data Packet data. * \param[in] length Packet data length. */ static void store_file_packet(char *data, uint32_t length) { FRESULT ret; if ((data == NULL) || (length < 1)) { printf("store_file_packet: Empty data.\r\n"); return; } if (!is_state_set(DOWNLOADING)) { char *cp = NULL; save_file_name[0] = LUN_ID_SD_MMC_0_MEM + '0'; save_file_name[1] = ':'; cp = (char *)(MAIN_HTTP_FILE_URL + strlen(MAIN_HTTP_FILE_URL)); while (*cp != '/') { cp--; } if (strlen(cp) > 1) { cp++; strcpy(&save_file_name[2], cp); } else { printf("store_file_packet: File name is invalid. Download canceled.\r\n"); add_state(CANCELED); return; } rename_to_unique(&file_object, save_file_name, MAIN_MAX_FILE_NAME_LENGTH); printf("store_file_packet: Creating to file :%s\r\n", save_file_name); ret = f_open(&file_object, (char const *)save_file_name, FA_CREATE_ALWAYS | FA_WRITE); if (ret != FR_OK) { printf("store_file_packet: File create error! ret:%d\r\n", ret); return; } received_file_size = 0; add_state(DOWNLOADING); } if (data != NULL) { UINT wsize = 0; ret = f_write(&file_object, (const void *)data, length, &wsize); if (ret != FR_OK) { f_close(&file_object); add_state(CANCELED); printf("store_file_packet: File write error. Download canceled.\r\n"); return; } received_file_size += wsize; printf("store_file_packet: received[%lu], file size[%lu]\r\n", (unsigned long)received_file_size, (unsigned long)http_file_size); if (received_file_size >= http_file_size) { f_close(&file_object); printf("store_file_packet: Download completed. location:[%s]\r\n", save_file_name); ioport_set_pin_level(LED_0_PIN, LED_0_ACTIVE); add_state(COMPLETED); return; } } }
/** * \brief Callback to get the Wi-Fi status update. * * \param[in] u8MsgType type of Wi-Fi notification. Possible types are: * - [M2M_WIFI_RESP_CURRENT_RSSI](@ref M2M_WIFI_RESP_CURRENT_RSSI) * - [M2M_WIFI_RESP_CON_STATE_CHANGED](@ref M2M_WIFI_RESP_CON_STATE_CHANGED) * - [M2M_WIFI_RESP_CONNTION_STATE](@ref M2M_WIFI_RESP_CONNTION_STATE) * - [M2M_WIFI_RESP_SCAN_DONE](@ref M2M_WIFI_RESP_SCAN_DONE) * - [M2M_WIFI_RESP_SCAN_RESULT](@ref M2M_WIFI_RESP_SCAN_RESULT) * - [M2M_WIFI_REQ_WPS](@ref M2M_WIFI_REQ_WPS) * - [M2M_WIFI_RESP_IP_CONFIGURED](@ref M2M_WIFI_RESP_IP_CONFIGURED) * - [M2M_WIFI_RESP_IP_CONFLICT](@ref M2M_WIFI_RESP_IP_CONFLICT) * - [M2M_WIFI_RESP_P2P](@ref M2M_WIFI_RESP_P2P) * - [M2M_WIFI_RESP_AP](@ref M2M_WIFI_RESP_AP) * - [M2M_WIFI_RESP_CLIENT_INFO](@ref M2M_WIFI_RESP_CLIENT_INFO) * \param[in] pvMsg A pointer to a buffer containing the notification parameters * (if any). It should be casted to the correct data type corresponding to the * notification type. Existing types are: * - tstrM2mWifiStateChanged * - tstrM2MWPSInfo * - tstrM2MP2pResp * - tstrM2MAPResp * - tstrM2mScanDone * - tstrM2mWifiscanResult */ static void wifi_cb(uint8_t u8MsgType, void *pvMsg) { switch (u8MsgType) { case M2M_WIFI_RESP_CON_STATE_CHANGED: { tstrM2mWifiStateChanged *pstrWifiState = (tstrM2mWifiStateChanged *)pvMsg; if (pstrWifiState->u8CurrState == M2M_WIFI_CONNECTED) { printf("Wi-Fi connected\r\n"); m2m_wifi_request_dhcp_client(); } else if (pstrWifiState->u8CurrState == M2M_WIFI_DISCONNECTED) { printf("Wi-Fi disconnected\r\n"); clear_state(WIFI_CONNECTED); if (is_state_set(DOWNLOADING)) { f_close(&file_object); clear_state(DOWNLOADING); } if (is_state_set(GET_REQUESTED)) { clear_state(GET_REQUESTED); } m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID), MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL); } break; } case M2M_WIFI_REQ_DHCP_CONF: { uint8_t *pu8IPAddress = (uint8_t *)pvMsg; printf("Wi-Fi IP is %u.%u.%u.%u\r\n", pu8IPAddress[0], pu8IPAddress[1], pu8IPAddress[2], pu8IPAddress[3]); add_state(WIFI_CONNECTED); start_download(); break; } default: break; } }
void Player::draw(sf::RenderWindow* window, Point camera) { if (is_state_set(ENTITY_WALKING)) { if (_facing_right) { _walk_right->setPosition(_position.x - camera.x, _position.y - camera.y); window->draw(*_walk_right); } else { _walk_left->setPosition(_position.x - camera.x, _position.y - camera.y); window->draw(*_walk_left); } } else { if (_facing_right) { _stand_right->setPosition(_position.x - camera.x, _position.y - camera.y); window->draw(*_stand_right); } else { _stand_left->setPosition(_position.x - camera.x, _position.y - camera.y); window->draw(*_stand_left); } } }
/** * \brief Main application function. * * Application entry point. * * \return program return value. */ int main(void) { tstrWifiInitParam param; int8_t ret; init_state(); /* Initialize the board. */ sysclk_init(); board_init(); /* Initialize the UART console. */ configure_console(); printf(STRING_HEADER); printf("This example may not work as it requires internet connectivity.\r\n"); /* Initialize the Timer. */ configure_timer(); /* Initialize the HTTP client service. */ configure_http_client(); /* Initialize the BSP. */ nm_bsp_init(); /* Initialize SD/MMC storage. */ init_storage(); /* Initialize Wi-Fi parameters structure. */ memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam)); /* Initialize Wi-Fi driver with data and status callbacks. */ param.pfAppWifiCb = wifi_cb; ret = m2m_wifi_init(¶m); if (M2M_SUCCESS != ret) { printf("main: m2m_wifi_init call error!(%d)\r\n", ret); while (1) { } } /* Initialize socket module. */ socketInit(); /* Register socket callback function. */ registerSocketCallback(socket_cb, resolve_cb); /* Connect to router. */ printf("main: Waiting for Wi-Fi connection. AP:%s\r\n", (char *)MAIN_WLAN_SSID); m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID), MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL); while (!(is_state_set(COMPLETED) || is_state_set(CANCELED))) { /* Handle pending events from network controller. */ m2m_wifi_handle_events(NULL); /* Checks the timer timeout. */ sw_timer_task(&swt_module_inst); } printf("main: Exit program. Please unplug the card.\r\n"); while (1) { } /* Loop forever. */ return 0; }
void Player::jump() { if (!is_state_set(ENTITY_JUMPING)) { apply_movement(0.f, _jump_speed); set_state(ENTITY_JUMPING); } }