/**
* Start the animation on the current tile.
*
* Stack: *none*.
*
* @param script The script engine to operate on.
* @return The value 1. Always.
*/
uint16 Script_Unit_StartAnimation(ScriptEngine *script)
{
Unit *u;
uint16 animationUnitID;
uint16 position;
VARIABLE_NOT_USED(script);
u = g_scriptCurrentUnit;
position = Tile_PackTile(Tile_Center(u->o.position));
Animation_Stop_ByTile(position);
animationUnitID = g_table_landscapeInfo[Map_GetLandscapeType(Tile_PackTile(u->o.position))].isSand ? 0 : 1;
if (u->o.script.variables[1] == 1) animationUnitID += 2;
g_map[position].houseID = Unit_GetHouseID(u);
assert(animationUnitID < 4);
if (g_table_unitInfo[u->o.type].displayMode == 3) {
Animation_Start(g_table_animation_unitScript1[animationUnitID], u->o.position, 0, Unit_GetHouseID(u), 4);
} else {
Animation_Start(g_table_animation_unitScript2[animationUnitID], u->o.position, 0, Unit_GetHouseID(u), 4);
}
return 1;
}
/**
* Set the animation of a Explosion.
* @param e The Explosion to change.
* @param animationMapID The animation map to use.
*/
static void Explosion_Func_SetAnimation(Explosion *e, uint16 animationMapID)
{
uint16 packed;
packed = Tile_PackTile(e->position);
if (Structure_Get_ByPackedTile(packed) != NULL) return;
animationMapID += Tools_Random_256() & 0x1;
animationMapID += g_table_landscapeInfo[Map_GetLandscapeType(packed)].isSand ? 0 : 2;
assert(animationMapID < 16);
Animation_Start(g_table_animation_map[animationMapID], e->position, 0, e->houseID, 3);
}
int main (void) {
//
// Variables
//
char TCP_USER_i = 0;
TCP_USER_INFO *TCP_USER;
BOOL TCP_Connected = FALSE;
int a = 0, b = 0;
int RESET_VALUE_SEC = 0;
//
// Init
//
Init();
// Play saved animation
if (ANIMATION_PLAY) {
Animation_Start();
}
//
// While
//
while (1) {
main_TcpNet();
DHCP_Check();
if (ftpFileClose == __TRUE && ftpFileWrite == __TRUE) {
ftpFileClose = __FALSE;
ftpFileWrite = __FALSE;
if (strstr((char *)ftpFileOpen, "device.settings")) {
Delay_ms(2000);
NVIC_SystemReset();
}
}
/*****************************************************************************
** 1 ms timer
*****************************************************************************/
if (TICK_1MS == __TRUE) {
TICK_1MS = __FALSE;
if (ANIMATION_PLAY) {
if (DelayValue >= ((currentEffect.delay+1) * getDelayUnitValue(currentEffect.delayUnit))) {
DelayValue = 0;
if (CurrentAnimationEffect >= AnimationEffectsCount - 1) {
CurrentAnimationEffect = 0;
} else {
CurrentAnimationEffect++;
}
Animation_Read_Effect();
} else {
DelayValue++;
}
}
}
/*****************************************************************************
** 10 ms timer
*****************************************************************************/
if (TICK_10MS == __TRUE) {
TICK_10MS = __FALSE;
}
/*****************************************************************************
** 100 ms timer
*****************************************************************************/
if (TICK_100MS == __TRUE) {
TICK_100MS = __FALSE;
/*****************************************************************************
** reset button
*****************************************************************************/
if (!(LPC_GPIO1->FIOPIN & (1<<RESET_BUTTON_PIN))) {
if (RESET_VALUE_SEC >= 5) {
RESET_VALUE_SEC = 0;
Status_LED1_Set(TRUE);
Status_LED2_Set(TRUE);
while (!(LPC_GPIO1->FIOPIN & (1<<RESET_BUTTON_PIN)));
SPI_FLASH_Delete_All_Files();
NVIC_SystemReset();
Status_LED1_Set(FALSE);
Status_LED2_Set(FALSE);
}
} else {
RESET_VALUE_SEC = 0;
}
}
/*****************************************************************************
** 1 s timer
*****************************************************************************/
if (TICK_1S == __TRUE) {
TICK_1S = __FALSE;
if (ANIMATION_PLAY) {
Status_LED2_Toggle();
} else {
Status_LED2_Set(FALSE);
}
if (TCP_Connected) {
Status_LED1_Set(TRUE);
} else {
Status_LED1_Set(FALSE);
}
if (!(LPC_GPIO1->FIOPIN & (1<<RESET_BUTTON_PIN))) {
RESET_VALUE_SEC++;
}
}
/*****************************************************************************
** UDP Socket Listener
*****************************************************************************/
if (UDP_Socket_Listener_Data_Received == TRUE) {
UDP_Socket_Listener_Data_Received = FALSE; // Clear listener
switch (UDP_Receive_Check(UDP_Socket_Buffer_Receive, UDP_Socket_Receive_Length)) {
case PROTOCOL_UDP_ReceiveCheckWhich_search_device:
UDP_Socket_Send_Length = UDP_Send_Search_Device(UDP_Socket_Buffer_Send, (char *)DEVICE_IP, (char *)SETTINGS_DATA[DEVICE_NAME]);
UDP_Socket_Send(UDP_Socket_Buffer_Send, UDP_Socket_Send_Length, UDP_Socket_Remote_IP);
break;
case PROTOCOL_UDP_ReceiveCheckWhich_cube_set:
if (ANIMATION_PLAY == FALSE) {
for (a=0; a<8; a++) {
for (b=0; b<8; b++) {
cube[a][b] = UDP_Socket_Buffer_Receive[(((a * 8) + b) + 6)];
}
}
}
break;
case PROTOCOL_UDP_ReceiveCheckWhich_reset_device:
NVIC_SystemReset();
break;
default:
break;
}
}
/*****************************************************************************
** TCP Users Listener
*****************************************************************************/
TCP_Connected = FALSE;
for (TCP_USER_i=0; TCP_USER_i<TCP_USER_NUMBER_OF_SESSIONS; TCP_USER_i++) {
TCP_USER = &TCP_USER_SESSIONS[TCP_USER_i];
if (TCP_USER->State == TCP_USER_STATE_CONNECTED) {
TCP_Connected = TRUE;
}
/* ------------------- CONNECT ------------------ */
if (TCP_USER->Connect_Flag == TRUE) {
TCP_USER->Connect_Flag = FALSE; // Clear interrupt flag
}
/* ------------------- DISCONNECT --------------- */
if (TCP_USER->Disconnect_Flag == TRUE) {
TCP_USER->Disconnect_Flag = FALSE; // Clear interrupt flag
}
/* ------------------- RECEIVE ------------------ */
if (TCP_USER->Received_Flag == TRUE) {
TCP_USER->Received_Flag = FALSE; // Clear interrupt flag
switch (TCP_Receive_Check(TCP_USER->Buffer_Receive, TCP_USER->Buffer_Receive_Length)) {
case PROTOCOL_TCP_ReceiveCheckWhich_cube_set:
if (ANIMATION_PLAY == FALSE) {
for (a=0; a<8; a++) {
for (b=0; b<8; b++) {
cube[a][b] = TCP_USER->Buffer_Receive[(((a * 8) + b)+6)];
}
}
}
break;
case PROTOCOL_TCP_ReceiveCheckWhich_start_animation:
AnimationFileName = GetAnimationFileNameFromBuffer(TCP_USER->Buffer_Receive, TCP_USER->Buffer_Receive_Length);
Animation_Start();
break;
case PROTOCOL_TCP_ReceiveCheckWhich_stop_animation:
Animation_Stop();
break;
default:
break;
}
}
}
/*****************************************************************************
** UART CONSOLE Listener
*****************************************************************************/
if (UART_Count[UART_CONSOLE_NUMBER] > 0) {
UART_RBR_Disable(UART_CONSOLE_NUMBER);
// program
// end
UART_Count[UART_CONSOLE_NUMBER] = 0;
UART_RBR_Enable(UART_CONSOLE_NUMBER);
}
}
}
void cgi_process_data (U8 code, U8 *dat, U16 len) {
/* This function is called by HTTP server to process the returned Data */
/* for the CGI Form POST method. It is called on SUBMIT from the browser. */
/* Parameters: */
/* code - callback context code */
/* 0 = www-url-encoded form data */
/* 1 = filename for file upload (0-terminated string) */
/* 2 = file upload raw data */
/* 3 = end of file upload (file close requested) */
/* 4 = any xml encoded POST data (single or last stream) */
/* 5 = the same as 4, but with more xml data to follow */
/* Use http_get_content_type() to check the content type */
/* dat - pointer to POST received data */
/* len - received data length */
static FILE *f = NULL;
U32 n;
U8 *var,*p;
BOOL format_flash = FALSE;
BOOL settings_save = FALSE;
BOOL sntp_time_configurations_load = FALSE;
RTC_Time rtc_time;
BOOL rtc_save = FALSE;
BOOL add_admin = FALSE, add_user = FALSE;
BOOL save_user = FALSE, delete_user = FALSE, delete_users = FALSE;
BOOL save_admin = FALSE, delete_admin = FALSE;
int admin_number = 0;
int user_number = 0;
USER *user = malloc(sizeof(USER));
ADMIN *admin = malloc(sizeof(ADMIN));
static FINFO file_info;
//ADMIN *admin = malloc(sizeof(ADMIN));
//USER *user = malloc(sizeof(USER));
switch (code) {
case 0:
/* Url encoded form data received. */
break;
case 1:
/* Filename for file upload received as encoded by the browser. */
/* It might contain an absolute path to a file from the sending */
/* host. Open a file for writing. */
var = dat;
/* Remove path info from filename, keep only the name. */
for (p = dat; *p; p++) {
if (*p == '\\') var = p + 1;
}
if (*var == 0) {
/* Send was clicked but a filename was not selected. */
return;
}
/* Filename is OK, initialize the card. */
if (finit(NULL) != 0) {
f = NULL;
return;
}
/* Files will be stored to the root directory of SD card. */
f = fopen ((const char *)var,"w");
return;
case 2:
/* File content data received. Write data to a file. */
/* This function will be called several times with */
/* code 2 when a big file is being uploaded. */
if (f != NULL) {
/* Write in 512 byte blocks. This is the optimal way for */
/* the FAT FS with caching enabled. For cache buffer */
/* size of 4KB the file write speed is 1.2 MByte/sec. */
while ((n = len) > 0) {
if (n > 512) n = 512;
fwrite (dat,1,n,f);
dat += n;
len -= n;
}
}
return;
case 3:
/* File upload finished. Close a file. */
if (f != NULL) {
fclose (f);
}
return;
default:
/* Ignore all other codes. */
return;
}
if (len == 0) {
/* No data or all items (radio, checkbox) are off. */
return;
}
var = (U8 *)alloc_mem (40);
do {
/* Parse all returned parameters. */
dat = http_get_var (dat, var, 40);
if (var[0] != 0) {
if (str_scomp(var, (const U8*)"file_delete=") == TRUE) { // FILE DELETE
fdelete((const char *)var+12);
} else if (str_scomp(var, (const U8*)"format_flash=yes") == TRUE) { // FORMAT FLASH
format_flash = TRUE;
} else if (str_scomp(var, (const U8*)"ani_file_delete=") == TRUE) { // ANIMATION FILE DELETE
if (fdelete((const char *)var+16) == 0) {
if (ANIMATION_PLAY && strcmp(AnimationFileName, (const char *)var+16) == 0) {
Animation_Stop();
}
}
} else if (str_scomp(var, (const U8*)"delete_all_ani=yes") == TRUE) {
while (ffind("*.ani", &file_info) == 0) {
fdelete((const char*)file_info.name);
}
}
// USERS & ADMINS COMMANDS
if(str_scomp(var, (const U8*)"delete_user="******"%d", &user_number);
delete_user = TRUE;
} else if(str_scomp(var, (const U8*)"delete_users=") == TRUE) {
delete_users = TRUE;
} else if(str_scomp(var, (const U8*)"save_user="******"%d", &user_number);
save_user = TRUE;
} else if (str_scomp(var, (const U8*)"add_user=yes") == TRUE) {
add_user = TRUE;
}
if(str_scomp(var, (const U8*)"delete_admin=") == TRUE) {
sscanf((const char *)var+12, "%d", &admin_number);
delete_admin = TRUE;
} else if(str_scomp(var, (const U8*)"save_admin=") == TRUE) {
sscanf((const char *)var+10, "%d", &admin_number);
save_admin = TRUE;
} else if (str_scomp(var, (const U8*)"add_admin=yes") == TRUE) {
add_admin = TRUE;
}
if(str_scomp(var, (const U8*)"username="******"password="******"first_name=") == TRUE) {
strcpy(user->First_Name, (const char *)var+11);
} else if(str_scomp(var, (const U8*)"last_name=") == TRUE) {
strcpy(user->Last_Name, (const char *)var+10);
} else if(str_scomp(var, (const U8*)"email=") == TRUE) {
strcpy(user->Email, (const char *)var+6);
strcpy(admin->Email, (const char *)var+6);
}
// SNTP TIME COMMANDS
if(str_scomp(var, (const U8*)"sntp_time_load=yes") == TRUE) {
sntp_time_configurations_load = TRUE;
settings_save = TRUE;
} else if(str_scomp(var, (const U8*)"sntp_ip_1_0=") == TRUE) {
sscanf((const char *)var+12, "%d", (int*)&SNTP_Server_IP_1[0]);
} else if(str_scomp(var, (const U8*)"sntp_ip_1_1=") == TRUE) {
sscanf((const char *)var+12, "%d", (int*)&SNTP_Server_IP_1[1]);
} else if(str_scomp(var, (const U8*)"sntp_ip_1_2=") == TRUE) {
sscanf((const char *)var+12, "%d", (int*)&SNTP_Server_IP_1[2]);
} else if(str_scomp(var, (const U8*)"sntp_ip_1_3=") == TRUE) {
sscanf((const char *)var+12, "%d", (int*)&SNTP_Server_IP_1[3]);
} else if(str_scomp(var, (const U8*)"sntp_ip_2_0=") == TRUE) {
sscanf((const char *)var+12, "%d", (int*)&SNTP_Server_IP_2[0]);
} else if(str_scomp(var, (const U8*)"sntp_ip_2_1=") == TRUE) {
sscanf((const char *)var+12, "%d", (int*)&SNTP_Server_IP_2[1]);
} else if(str_scomp(var, (const U8*)"sntp_ip_2_2=") == TRUE) {
sscanf((const char *)var+12, "%d", (int*)&SNTP_Server_IP_2[2]);
} else if(str_scomp(var, (const U8*)"sntp_ip_2_3=") == TRUE) {
sscanf((const char *)var+12, "%d", (int*)&SNTP_Server_IP_2[3]);
}
// TIME COMMANDS
if(str_scomp(var, (const U8*)"time_format=") == TRUE) {
strcpy(SETTINGS_DATA[TIME_FORMAT], (const char *)var+12);
settings_save = TRUE;
} else if(str_scomp(var, (const U8*)"date_format=") == TRUE) {
strcpy(SETTINGS_DATA[DATE_FORMAT], (const char *)var+12);
settings_save = TRUE;
} else if(str_scomp(var, (const U8*)"timezone_offset_select=") == TRUE) {
TIME_ZONE_OFFSET_SELECTED_VALUE = atoi((const char *)var+23);
settings_save = TRUE;
}
// MANUAL TIME COMMANDS
if(str_scomp(var, (const U8*)"manual_time=") == TRUE) {
sscanf((const char *)var+12, "%d:%d", (int*)&rtc_time.Hour, (int*)&rtc_time.Min);
rtc_save = TRUE;
settings_save = TRUE;
} else if(str_scomp(var, (const U8*)"manual_date=") == TRUE) {
sscanf((const char *)var+12, "%d-%d-%d", (int*)&rtc_time.Year, (int*)&rtc_time.Mon, (int*)&rtc_time.Mday);
rtc_save = TRUE;
settings_save = TRUE;
}
// ANIMATION
if(str_scomp(var, (const U8*)"animation_start=") == TRUE) {
AnimationFileName = (char *)malloc(strlen((const char *)var)-15);
strcpy(AnimationFileName, (const char *)var+16);
Animation_Start();
} else if(str_scomp(var, (const U8*)"animation_stop=yes") == TRUE) {
Animation_Stop();
}
}
} while (dat);
free_mem ((OS_FRAME *)var);
if (format_flash == TRUE) {
SPI_FLASH_Delete_All_Files();
} else if (sntp_time_configurations_load == TRUE) {
SNTP_Load_Time();
} else if (rtc_save == TRUE) {
TIME_ZONE_OFFSET_SELECTED_VALUE = 0;
RTC_Set_Time(rtc_time);
} else if(save_user == TRUE) {
if(USERS_Check_User(user) == USER_Warning_OK) {
strcpy((&Users[user_number])->Username, user->Username);
strcpy((&Users[user_number])->Password, user->Password);
strcpy((&Users[user_number])->First_Name, user->First_Name);
strcpy((&Users[user_number])->Last_Name, user->Last_Name);
strcpy((&Users[user_number])->Email, user->Email);
USERS_Save();
}
} else if(save_admin == TRUE) {
if(ADMINS_Check_Admin(admin) == ADMIN_Warning_OK) {
strcpy((&Admins[admin_number])->Username, admin->Username);
strcpy((&Admins[admin_number])->Password, admin->Password);
strcpy((&Admins[admin_number])->Email, admin->Email);
ADMINS_Save();
}
} else if(delete_user == TRUE) {
USERS_Remove_User_By_Index(user_number);
} else if(delete_admin == TRUE) {
ADMINS_Remove_Admin_By_Index(admin_number);
} else if (add_admin == TRUE) {
ADMINS_Add_Admin(admin);
} else if (add_user == TRUE) {
USERS_Add_User(user);
} else if(delete_users == TRUE) {
USERS_Remove_All();
}
if (settings_save == TRUE) {
SETTINGS_Save();
}
free(user);
free(admin);
}