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