/* * Print out current value of push buttons, if board is moving or tiled, * the value of the potentiometer, and the elapsed time since bootup */ int_32 Shell_status(int_32 argc, char_ptr argv[] ) { boolean print_usage, shorthelp = FALSE; int_32 return_code = SHELL_EXIT_SUCCESS; int pot; TIME_STRUCT time; DATE_STRUCT date; print_usage = Shell_check_help_request(argc, argv, &shorthelp ); if (!print_usage) { if (argc > 1) { printf("Error, invalid number of parameters\n"); return_code = SHELL_EXIT_ERROR; print_usage=TRUE; } else { /* Print out 'Door' status */ printf("Door (SW2): "); if(SEC_GetDoorStatus()==OPENED) printf("Open\n"); else printf("Closed\n"); /* Print out 'Window' status */ printf("Window (SW3): "); if(SEC_GetWindowStatus()==OPENED) printf("Open\n"); else printf("Closed\n"); /* Print out movement/tilt status */ printf("Motion Detection: "); if(SEC_GetMovementStatus()==MOVING) printf("Movement\n"); else printf("No Movement\n"); /* Print out potentiometer percentage in 10% increments */ pot = (SEC_Params.GarageStatus / 409) * 10; printf("Garage Door (Potentiometer R2): %d%% Open\n",pot); /* Print out elapsed time since bootup */ _time_get(&time); _time_to_date(&time,&date); printf("Time Since Bootup: %02d:%02d:%02d\n\n",date.HOUR,date.MINUTE,date.SECOND); } } if (print_usage) { print_usage_simple (shorthelp, argv[0], "Display security system status"); } return return_code; }
/*FUNCTION********************************************************************** * * Function Name : print_current_time * Returned Value : none * Comments : * Get current time & printf it in "date" format to stdout * *END**************************************************************************/ static void print_rtc_time ( uint32_t rtc_time ) { /* Body*/ TIME_STRUCT ts; DATE_STRUCT tm; ts.SECONDS = rtc_time; ts.MILLISECONDS = 0; /* Convert rtc_time to date format */ if (_time_to_date(&ts, &tm) == FALSE ) { printf("\n Cannot convert rtc_time to date format"); _task_block(); } printf(" (RTC) Current time is: %s %s %3d %.2d:%.2d:%.2d %d\n", _days_abbrev[tm.WDAY], _months_abbrev[tm.MONTH - 1], tm.DAY, tm.HOUR, tm.MINUTE, tm.SECOND, (tm.YEAR)); } /* Endboy*/
_mqx_int _rtc_sync_with_mqx ( /* [IN] whether to update MQX time (source is RTC) or RTC time (source is MQX) */ boolean update_mqx ) { RTC_TIME_STRUCT rtc_time; DATE_STRUCT mqx_date; TIME_STRUCT mqx_time; if (update_mqx == TRUE) { _rtc_get_time(&rtc_time); _rtc_time_to_mqx_date(&rtc_time, &mqx_date); _time_from_date(&mqx_date, &mqx_time); _time_set(&mqx_time); } else { _time_get(&mqx_time); _time_to_date(&mqx_time, &mqx_date); _rtc_time_from_mqx_date (&mqx_date, &rtc_time); _rtc_set_time (&rtc_time); } return MQX_OK; }
/* * Display the last MAX_QUEUE events that occured with a timestamp * Button pushes and movement changes logged. Potentiometer changes are not logged. */ int_32 Shell_displaylog(int_32 argc, char_ptr argv[] ) { boolean print_usage, shorthelp = FALSE; int_32 return_code = SHELL_EXIT_SUCCESS; TIME_STRUCT time; DATE_STRUCT date; SEC_HIST_PTR hist; int i; print_usage = Shell_check_help_request(argc, argv, &shorthelp ); if (!print_usage) { if (argc > 1) { printf("Error, invalid number of parameters\n"); return_code = SHELL_EXIT_ERROR; print_usage=TRUE; } else { _time_get_elapsed(&time); _time_to_date(&time,&date); printf("Time Since Bootup: %02d:%02d:%02d\n",date.HOUR,date.MINUTE,date.SECOND); /* Print out last MAX_QUEUE events */ for(i = (MAX_QUEUE - 1);i >= 0;i--) { hist = &(SEC_Params.History[(i+SEC_Params.HistoryIndex)%MAX_QUEUE]); if(NULL != hist->eventptr) { _time_to_date(&hist->time,&date); printf("%02d:%02d:%02d %s\n", date.HOUR,date.MINUTE,date.SECOND,hist->eventptr); } } } } if (print_usage) { print_usage_simple (shorthelp, argv[0], "Display event log"); } return return_code; }
void lcd_task ( uint32_t initial_data ) { DATE_STRUCT time_rtc; uint32_t time; TIME_STRUCT ts; eLCD_Symbols spec_sym; char time[5]; char state = 0; puts("\n\n"); if (_lcd_init() == IO_ERROR) { puts("_lcd_init() function returned IO_ERROR\n"); puts("lcd_task blocked\n\n"); _task_block(); } puts("TWRPI-SLCD display is connected and lcd_task is running\n"); _lcd_segments( FALSE ); while(1) { _rtc_get_time(&time); ts.SECONDS = time; ts.MILLISECONDS = 0; _time_to_date(&ts, &time_rtc); /* post meridiem */ if( time_rtc.HOUR > 12 ) { time_rtc.HOUR -= 12; spec_sym = LCD_AM; _lcd_symbol( spec_sym, FALSE ); spec_sym = LCD_PM; _lcd_symbol( spec_sym, TRUE); } else { spec_sym = LCD_PM; _lcd_symbol( spec_sym, FALSE); spec_sym = LCD_AM; _lcd_symbol( spec_sym, TRUE); } sprintf( time, "%2d%2d", time_rtc.HOUR, time_rtc.MINUTE); if( time_rtc.MINUTE < 10 ) { time[2] = '0'; } _lcd_puts( time ); spec_sym = LCD_COL1; state = (state + 1) & 1; _lcd_symbol( spec_sym, (bool)state ); _time_delay(1000); } /* Endwhile */ } /* Endbody */
void _rtc_get_alarm_mqxd (DATE_STRUCT_PTR time) { TIME_STRUCT rtc_time; rtc_time.SECONDS = alarm_time.seconds; rtc_time.MILLISECONDS=0; _time_to_date( &rtc_time, time ); }
void _rtc_get_time_mqxd (DATE_STRUCT_PTR time) { RTC_MemMapPtr rtc = RTC_BASE_PTR; TIME_STRUCT rtc_time; rtc_time.SECONDS = rtc->TSR; rtc_time.MILLISECONDS=0; _time_to_date( &rtc_time, time ); }
/*FUNCTION********************************************************************** * * Function Name : install_alarm * Returned Value : * Comments : * *END**************************************************************************/ static void install_alarm(void) { DATE_STRUCT time_rtc; TIME_STRUCT time_mqx; _rtc_get_time_mqxd (&time_rtc); _time_from_date (&time_rtc, &time_mqx); time_mqx.SECONDS += 10; _time_to_date (&time_mqx, &time_rtc); _rtc_set_alarm_mqxd (&time_rtc); printf ("\nSetting alarm to 10 seconds to %02d.%02d.%04d %02d:%02d:%02d ... OK\n", time_rtc.DAY, time_rtc.MONTH, time_rtc.YEAR, time_rtc.HOUR, time_rtc.MINUTE, time_rtc.SECOND); printf ("Wasting time ... \n"); }
static void set_rtc_alarm ( uint_32 seconds ) { DATE_STRUCT time_rtc; TIME_STRUCT time_mqx; _rtc_get_time_mqxd (&time_rtc); _time_from_date (&time_rtc, &time_mqx); time_mqx.SECONDS += seconds; _time_to_date (&time_mqx, &time_rtc); _rtc_set_alarm_mqxd (&time_rtc); printf ("\nRTC alarm set to +%d seconds.\n", seconds); }
void _rtc_time_to_mqx_date ( /* [IN] RTC time representation */ RTC_TIME_STRUCT_PTR rtc_time, /* [OUT] MQX date representation */ DATE_STRUCT_PTR mqx_date ) { TIME_STRUCT time; time.SECONDS = rtc_time->seconds; time.MILLISECONDS=0; _time_to_date( &time, mqx_date ); }
boolean SEC_GetTime() { boolean res = FALSE; #if DEMOCFG_ENABLE_SNTP _ip_address ipaddr; TIME_STRUCT time; DATE_STRUCT date; char tries = 0; /* Try three times to get time */ while(tries<3) { _time_delay(1000); printf("\nGetting time from time server ... "); if (RTCS_resolve_ip_address(SNTP_SERVER,&ipaddr,NULL,0)) { /* Contact SNTP server and update time */ if(SNTP_oneshot(ipaddr,1000)==RTCS_OK) { printf("Succeeded\n"); res = TRUE; break; } else { printf("Failed\n"); } } else { printf("Failed - address not resolved\n"); break; } tries++; } /* Get current time */ _time_get(&time); _time_to_date(&time,&date); printf("\nCurrent Time: %02d/%02d/%02d %02d:%02d:%02d\n", date.YEAR,date.MONTH,date.DAY,date.HOUR,date.MINUTE,date.SECOND); #endif return res; }
void setup_clock(void) { uint32_t ret = 0, i = 0; uint32_t sntp_connected = 0; uint32_t sntp_max_tries = 3; TIME_STRUCT time_s; DATE_STRUCT date_s; /* NTP server: nist1-lnk.binary.net */ _ip_address ipaddr = IPADDR(216,229,0,179); for (i = 0; i < sntp_max_tries; i++) { printf("Getting time from NTP server [ attempt %d of %d ]...\n", i+1, sntp_max_tries); /* update time from NTP server */ ret = SNTP_oneshot(ipaddr, 5000); if (ret == RTCS_OK) { sntp_connected = 1; printf("SNTP successfully updated device time\n"); break; } else if (ret == RTCSERR_TIMEOUT) { printf("SNTP attempt timed out.\n"); } _time_delay(1000); } if (sntp_connected == 0) { err_sys("SNTP failed to update device time"); } /* print device time, for debug purposes */ _time_get(&time_s); _time_to_date(&time_s, &date_s); printf("Current time: %02d/%02d/%02d %02d:%02d:%02d\n", date_s.YEAR, date_s.MONTH, date_s.DAY, date_s.HOUR, date_s.MINUTE, date_s.SECOND); return; }
int32_t MFS_Close_file ( MFS_HANDLE_PTR handle, MFS_DRIVE_STRUCT_PTR drive_ptr ) { TIME_STRUCT time; DATE_STRUCT clk_time; _mfs_error error_code; error_code = MFS_lock_dos_disk( drive_ptr ); if ( error_code != MFS_NO_ERROR ) { return error_code; } #if !MFSCFG_READ_ONLY #if MFSCFG_READ_ONLY_CHECK if (MFS_is_read_only (drive_ptr)) { error_code = MFS_DISK_IS_WRITE_PROTECTED; } #endif if ((handle->TOUCHED) && (error_code == MFS_NO_ERROR)) { _time_get(&time); _time_to_date(&time, &clk_time); NORMALIZE_DATE(&clk_time); mqx_htods(handle->DIR_ENTRY.TIME, PACK_TIME(clk_time)); mqx_htods(handle->DIR_ENTRY.DATE, PACK_DATE(clk_time)); error_code = MFS_Update_entry(drive_ptr, handle); } #endif MFS_Free_handle(drive_ptr, handle); MFS_unlock(drive_ptr,TRUE); return(int32_t) error_code; }
void *MFS_Create_file ( MFS_DRIVE_STRUCT_PTR drive_ptr, unsigned char attr, /*[IN] attribute for created file*/ char *pathname, /*[IN] directory and filename of the file to be created */ _mfs_error_ptr error_ptr /*[IN/OUT] error code is written to this address */ ) { MFS_HANDLE_PTR handle; MFS_HANDLE_PTR next_handle; MFS_DIR_ENTRY_PTR dir_entry_ptr; TIME_STRUCT time; DATE_STRUCT clk_time; uint32_t dir_cluster; uint32_t dir_index; char access; _mfs_error error_code, saved_code = 0; if ( (pathname == NULL) || (*pathname == '\0') ) { *error_ptr = MFS_INVALID_PARAMETER; return( NULL ); } #if MFSCFG_READ_ONLY_CHECK if (MFS_is_read_only (drive_ptr)) { *error_ptr = MFS_DISK_IS_WRITE_PROTECTED; return NULL; } #endif error_code = MFS_lock_dos_disk( drive_ptr ); if ( error_code != MFS_NO_ERROR ) { *error_ptr = error_code; return( NULL ); } handle = NULL; attr &= (MFS_ATTR_READ_ONLY | MFS_ATTR_HIDDEN_FILE | MFS_ATTR_SYSTEM_FILE | MFS_ATTR_ARCHIVE | MFS_ATTR_VOLUME_NAME); attr |= MFS_ATTR_ARCHIVE; access = (attr & MFS_ATTR_READ_ONLY) ? MFS_ACCESS_READ_ONLY : MFS_ACCESS_READ_WRITE; dir_entry_ptr = MFS_Create_entry_slave(drive_ptr, attr, pathname, &dir_cluster, &dir_index, &error_code, TRUE); if ( (dir_entry_ptr != NULL) && !(attr & MFS_ATTR_VOLUME_NAME) ) { handle = MFS_Get_handle(drive_ptr,dir_entry_ptr); if ( handle != NULL ) { handle->DIR_CLUSTER = dir_cluster; handle->DIR_INDEX = dir_index; handle->ACCESS = access; handle->CURRENT_CLUSTER = 0; handle->PREVIOUS_CLUSTER = 0; /* ** If file exists, overwrite and set size to 0 */ if ( error_code == MFS_FILE_EXISTS ) { _time_get(&time); _time_to_date(&time, &clk_time); NORMALIZE_DATE(&clk_time); saved_code = MFS_Release_chain(drive_ptr, clustoh(handle->DIR_ENTRY.HFIRST_CLUSTER, handle->DIR_ENTRY.LFIRST_CLUSTER)); if ( saved_code == MFS_NO_ERROR || saved_code == MFS_LOST_CHAIN ) { clustod(handle->DIR_ENTRY.HFIRST_CLUSTER, handle->DIR_ENTRY.LFIRST_CLUSTER, 0); mqx_htodl(handle->DIR_ENTRY.FILE_SIZE, 0L); mqx_htodc(handle->DIR_ENTRY.ATTRIBUTE, attr); mqx_htods(handle->DIR_ENTRY.TIME, PACK_TIME(clk_time)); mqx_htods(handle->DIR_ENTRY.DATE, PACK_DATE(clk_time)); error_code = MFS_Update_entry(drive_ptr, handle); /* ** If the same file is already open, mark it as 'freshly ** truncated' so reads and writes don't clobber any data. */ if ( error_code == MFS_NO_ERROR ) { next_handle = (MFS_HANDLE_PTR) _queue_head(&drive_ptr->HANDLE_LIST); while ( next_handle ) { if ( next_handle->DIR_CLUSTER == dir_cluster && next_handle->DIR_INDEX == dir_index ) { next_handle->CURRENT_CLUSTER = 0; next_handle->PREVIOUS_CLUSTER = 0; } next_handle = (MFS_HANDLE_PTR) _queue_next(&drive_ptr->HANDLE_LIST, (QUEUE_ELEMENT_STRUCT_PTR) next_handle); } } } } /* ** No need to update the disk image if we didn't change anything. */ if ( (mqx_dtohc(handle->DIR_ENTRY.ATTRIBUTE) != attr) && (error_code == MFS_NO_ERROR) ) { mqx_htodc(handle->DIR_ENTRY.ATTRIBUTE, attr); error_code = MFS_Update_entry(drive_ptr, handle); } } else { error_code = MFS_INSUFFICIENT_MEMORY; } } MFS_unlock(drive_ptr,FALSE); if ( error_code == MFS_NO_ERROR && saved_code == MFS_LOST_CHAIN ) { *error_ptr = saved_code; } else { *error_ptr = error_code; } return((void *)handle); }
int32_t Shell_smtp (int32_t argc, char *argv[]) { struct addrinfo hints; struct addrinfo *result, *rp; int32_t retval = 0; uint32_t sfd = 0; int32_t err_code = 0; bool print_help; bool shorthelp = FALSE; SMTP_PARAM_STRUCT params; char *errstr = NULL; char *server = NULL; char *optstring = ":f:t:s:u:p:m:h"; int32_t next_option; char *email_text = NULL; uint32_t email_size = 0; TIME_STRUCT time; DATE_STRUCT date; char date_str[DATE_LENGTH]; SHELL_GETOPT_CONTEXT gopt_context; params.login = NULL; params.pass = NULL; print_help = Shell_check_help_request(argc, argv, &shorthelp); if (print_help) { if (!shorthelp) { fprintf(stdout,"Usage:"); } fprintf(stdout, "%s", argv[0]); print_usage(stdout, shorthelp); err_code = SHELL_EXIT_SUCCESS; return(err_code); } /* Parse command line options */ Shell_getopt_init(&gopt_context); do { next_option = Shell_getopt(argc, argv, optstring, &gopt_context); switch (next_option) { case 'f': params.envelope.from = gopt_context.optarg; break; case 't': params.envelope.to = gopt_context.optarg; break; case 'm': params.text = gopt_context.optarg; break; case 's': server = gopt_context.optarg; break; case 'u': params.login = gopt_context.optarg; break; case 'p': params.pass = gopt_context.optarg; break; case 'h': print_usage (stdout, FALSE); return(SHELL_EXIT_SUCCESS); case '?': /* User specified an invalid option. */ print_usage(stderr, TRUE); return(SHELL_EXIT_ERROR); case ':': /* Option has a missing parameter. */ printf("Option -%c requires a parameter.\n", next_option); return(SHELL_EXIT_ERROR); case -1: /* Done with options. */ break; default: break; } }while(next_option != -1); _time_get(&time); _time_to_date(&time,&date); snprintf(date_str, DATE_LENGTH, "%s, %d %s %d %02d:%02d:%02d -0000", wday[date.WDAY],date.DAY, months[date.MONTH-1],date.YEAR, date.HOUR, date.MINUTE, date.SECOND); /* Evaluate email size */ email_size = strlen(params.envelope.from) + strlen(params.envelope.to) + strlen(params.text) + strlen(date_str) + strlen("From: <>\r\n") + strlen("To: <>\r\n") + strlen("Subject: Freescale Tower Email\r\n") + strlen("Date: \r\n\r\n") + strlen("\r\n") + 1; /* Allocate space */ email_text = (char *) _mem_alloc_zero(email_size); if (email_text == NULL) { fprintf(stderr, " Unable to allocate memory for email message.\n"); err_code = SHELL_EXIT_ERROR; return(err_code); } /* Prepare email message */ snprintf(email_text, email_size, "From: <%s>\r\n" "To: <%s>\r\n" "Subject: Freescale Tower Email\r\n" "Date: %s\r\n\r\n" "%s\r\n", params.envelope.from, params.envelope.to, date_str, params.text); params.text = email_text; _mem_zero(&hints, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; /* TCP socket */ hints.ai_flags = AI_PASSIVE; /* For wildcard IP address */ hints.ai_protocol = 0; /* Any protocol */ hints.ai_canonname = NULL; hints.ai_addr = NULL; hints.ai_next = NULL; retval = getaddrinfo(server, NULL, &hints, &result); if (retval != 0) { fprintf(stderr, " getaddrinfo failed. Error: 0x%X\n", retval); err_code = SHELL_EXIT_ERROR; return(err_code); } /* Allocate buffer for error message */ errstr = (char *) _mem_alloc_system_zero(ERR_MSG_BUFF_SIZE); /* Try to send email using one of addresses. If it fails try another one. */ for (rp = result; rp != NULL; rp = rp->ai_next) { _mem_copy(rp->ai_addr, ¶ms.server, sizeof(params.server)); /* Try to send email */ retval = SMTP_send_email(¶ms, errstr, ERR_MSG_BUFF_SIZE); /* If connection failed try another address */ if (retval != SMTP_ERR_CONN_FAILED) { break; } } /* No address succeeded */ if (rp == NULL) { fprintf(stderr, " Unable to connect to %s.\n", server); err_code = SHELL_EXIT_ERROR; } if (retval != SMTP_OK) { printf(" Email sending failed%s %s\n", (strlen(errstr) > 0) ? ":":".", errstr); err_code = SHELL_EXIT_ERROR; } else { printf(" Email send. Server response: %s", errstr); } /* Cleanup */ freeaddrinfo(result); _mem_free(errstr); _mem_free(email_text); return(err_code); }
MFS_DIR_ENTRY_PTR MFS_Create_directory_entry ( MFS_DRIVE_STRUCT_PTR drive_ptr, /*[IN] the drive on which to operate */ char_ptr filename_ptr, /*[IN] pointer to the file's name */ char attribute, /*[IN] attribute to be assigned to the file */ uint_32_ptr dir_cluster_ptr, /*[IN/OUT] indicates cluster in which the entry was put.*/ uint_32_ptr dir_index_ptr, /*[IN/OUT] index of the location of new file within the directory */ uint_32_ptr error_ptr /*[IN/OUT] error_return_address */ ) { MFS_DIR_ENTRY_PTR dir_entry_ptr, dir_entry_ptr1; MFS_DIR_ENTRY_PTR temp_entry_ptr; TIME_STRUCT time; DATE_STRUCT clk_time; uint_32 dir_index, saved_index, temp_index; uint_32 entry_cluster, saved_cluster, temp_cluster; uint_32 needed_entries, i; int_32 length; boolean found_all = FALSE; char temp_name[SFILENAME_SIZE+1], short_name[SFILENAME_SIZE+1]; uchar checksum = 0; uint_32 prev_cluster= CLUSTER_INVALID, saved_prev_cluster, temp_prev_cluster; dir_entry_ptr = NULL; entry_cluster = *dir_cluster_ptr; dir_index = 0; /* ** Check for duplicate file */ if ( filename_ptr == NULL ) { *error_ptr = MFS_INVALID_PARAMETER; } else if ( *filename_ptr == '\0' ) { *error_ptr = MFS_FILE_NOT_FOUND; } #if MFSCFG_READ_ONLY_CHECK else if (MFS_is_read_only (NULL, drive_ptr)) { *error_ptr = MFS_DISK_IS_WRITE_PROTECTED; } #endif else if ( (dir_entry_ptr = MFS_Find_directory_entry(drive_ptr, filename_ptr, &entry_cluster, &dir_index, &prev_cluster, MFS_ATTR_ANY, error_ptr)) != NULL ) { *error_ptr = MFS_FILE_EXISTS; } else { /* ** Search for an empty slot */ dir_index = 0; dir_entry_ptr = MFS_Find_directory_entry(drive_ptr, "", &entry_cluster, &dir_index, &prev_cluster, attribute, error_ptr); if ( MFS_Dirname_valid(filename_ptr) ) { found_all = TRUE; } if ( dir_entry_ptr == NULL && !*error_ptr ) { found_all = TRUE; } /* ** Save it now because we might not go into the while loop ** If we don't go into while, we lose original values when these ** variables are restored after the while loop */ saved_cluster = entry_cluster; saved_index = dir_index; while ( !found_all ) { /* Calculate the amount of extra entries needed for LFN's */ saved_cluster = entry_cluster; saved_index = dir_index; for ( needed_entries = (strlen(filename_ptr) + 12) / 13; needed_entries >= 1 && !found_all; needed_entries-- ) { *error_ptr = MFS_Increment_dir_index(drive_ptr, &entry_cluster, &dir_index, NULL); if ( entry_cluster == CLUSTER_EOF && !*error_ptr ) { /* This means the LFN will span a cluster. */ found_all = TRUE; break; } temp_index = dir_index; temp_cluster = entry_cluster; temp_entry_ptr = MFS_Find_directory_entry(drive_ptr, "", &entry_cluster, &dir_index, &prev_cluster, MFS_ATTR_ANY,error_ptr); if ( *error_ptr ) { return NULL; } if ( !temp_entry_ptr ) { found_all = TRUE; dir_entry_ptr = NULL; break; } else if ( dir_index == temp_index && temp_cluster == entry_cluster ) { continue; } else { break; } } if ( needed_entries == 0 ) { found_all = TRUE; } if ( found_all ) { dir_entry_ptr = MFS_Find_directory_entry(drive_ptr, "", &saved_cluster, &saved_index, &saved_prev_cluster, MFS_ATTR_ANY,error_ptr); } } entry_cluster = saved_cluster; dir_index = saved_index; if ( dir_entry_ptr == NULL && !*error_ptr ) { /* ** Empty spot not found... get a new cluster and use the first entry. */ dir_index = 0; if ( entry_cluster == 0 ) { *error_ptr = MFS_ROOT_DIR_FULL; return(NULL); } else { *error_ptr = MFS_Add_cluster_to_chain(drive_ptr, entry_cluster, &entry_cluster); if ( *error_ptr == MFS_NO_ERROR ) { *error_ptr = MFS_Clear_cluster(drive_ptr, entry_cluster); if ( *error_ptr ) { return(NULL); } dir_entry_ptr = (pointer) drive_ptr->DIR_SECTOR_PTR; *error_ptr = MFS_Write_back_fat(drive_ptr); if ( *error_ptr ) { return(NULL); } } } } } if ( *error_ptr == MFS_NO_ERROR ) { /* At this point we have one of the following cases ** ** 1. We have a normal 8.3 filename and an empty slot for it ** 2. We have a LFN, and a slot which has enough consecutive free slots ** to store the LFN, followed by the actual entry */ /* If the file is a normal 8.3 file */ if ( MFS_Dirname_valid(filename_ptr) ) { _mem_zero(dir_entry_ptr, sizeof (MFS_DIR_ENTRY)); htodc(dir_entry_ptr->ATTRIBUTE, attribute); MFS_Expand_dotfile(filename_ptr, dir_entry_ptr->NAME); _time_get(&time); _time_to_date(&time, &clk_time); NORMALIZE_DATE(&clk_time); htods(dir_entry_ptr->TIME, PACK_TIME(clk_time)); htods(dir_entry_ptr->DATE, PACK_DATE(clk_time)); drive_ptr->DIR_SECTOR_DIRTY = TRUE; } else { /* Case where the file is a LFN */ length = strlen(filename_ptr); /* Get the 8.3 name and calculate the checksum */ temp_index = 0; temp_cluster = *dir_cluster_ptr; *error_ptr = MFS_lfn_to_sfn(filename_ptr, temp_name); if ( !*error_ptr ) { do { dir_entry_ptr1 = MFS_Find_directory_entry(drive_ptr, temp_name, &temp_cluster, &temp_index, &temp_prev_cluster, MFS_ATTR_ANY, error_ptr); if ( !*error_ptr && dir_entry_ptr1 != NULL ) { MFS_increment_lfn(temp_name); temp_index = 0; } } while ( !*error_ptr && dir_entry_ptr1 != NULL ); dir_entry_ptr = MFS_Find_directory_entry(drive_ptr, "", &entry_cluster, &dir_index, &prev_cluster, attribute, error_ptr); /* ** The memory should be cleared after finding the directory entry. */ _mem_zero(dir_entry_ptr, sizeof (MFS_DIR_ENTRY)); /* Setup the final slot */ ((MFS_LNAME_ENTRY_PTR) dir_entry_ptr)->ID |= MFS_LFN_END; drive_ptr->DIR_SECTOR_DIRTY = TRUE; MFS_Expand_dotfile(temp_name,short_name); checksum = MFS_lfn_checksum(short_name); } while ( length && !*error_ptr ) { i = length - ((length -1) % 13 + 1); *error_ptr = MFS_lfn_name_to_entry(filename_ptr + i, (MFS_LNAME_ENTRY_PTR) dir_entry_ptr); /* Set the entry number, the checksum value and the attribute */ ((MFS_LNAME_ENTRY_PTR) dir_entry_ptr)->ID |= (length + 12) / 13; ((MFS_LNAME_ENTRY_PTR) dir_entry_ptr)->ALIAS_CHECKSUM= checksum; ((MFS_LNAME_ENTRY_PTR) dir_entry_ptr)->ATTR = MFS_ATTR_LFN; drive_ptr->DIR_SECTOR_DIRTY = TRUE; length -= (length - i); if ( length < 0 ) { length = 0; } if ( length && !*error_ptr ) { dir_entry_ptr = MFS_Find_directory_entry(drive_ptr, "", &entry_cluster, &dir_index, &prev_cluster, attribute, error_ptr); if ( dir_entry_ptr == NULL && !*error_ptr ) { /* No empty spots... We need to get a new cluster */ dir_index = 0; if ( entry_cluster == 0 ) { *error_ptr = MFS_ROOT_DIR_FULL; return(NULL); } else { *error_ptr = MFS_Add_cluster_to_chain( drive_ptr, entry_cluster, &entry_cluster); if ( *error_ptr == MFS_NO_ERROR ) { *error_ptr = MFS_Clear_cluster(drive_ptr, entry_cluster); if ( *error_ptr ) { return(NULL); } dir_entry_ptr = (pointer) drive_ptr->DIR_SECTOR_PTR; *error_ptr = MFS_Write_back_fat(drive_ptr); if ( *error_ptr ) { return(NULL); } } } } _mem_zero(dir_entry_ptr, sizeof (MFS_DIR_ENTRY)); drive_ptr->DIR_SECTOR_DIRTY = TRUE; } } /* LFN is written, so write the actual entry */ if ( !*error_ptr ) { dir_entry_ptr = MFS_Find_directory_entry(drive_ptr, "", &entry_cluster, &dir_index, &prev_cluster, attribute, error_ptr); if ( dir_entry_ptr == NULL && !*error_ptr ) { dir_index = 0; if ( entry_cluster == 0 ) { *error_ptr = MFS_ROOT_DIR_FULL; return(NULL); } else { *error_ptr = MFS_Add_cluster_to_chain( drive_ptr, entry_cluster, &entry_cluster); if ( *error_ptr == MFS_NO_ERROR ) { *error_ptr = MFS_Clear_cluster(drive_ptr, entry_cluster); if ( *error_ptr ) { return(NULL); } dir_entry_ptr = (pointer) drive_ptr->DIR_SECTOR_PTR; *error_ptr = MFS_Write_back_fat(drive_ptr); if ( *error_ptr ) { return(NULL); } } } } _mem_zero(dir_entry_ptr, sizeof (MFS_DIR_ENTRY)); htodc(dir_entry_ptr->ATTRIBUTE, attribute); MFS_Expand_dotfile(temp_name, dir_entry_ptr->NAME); _time_get(&time); _time_to_date(&time, &clk_time); NORMALIZE_DATE(&clk_time); htods(dir_entry_ptr->TIME, PACK_TIME(clk_time)); htods(dir_entry_ptr->DATE, PACK_DATE(clk_time)); drive_ptr->DIR_SECTOR_DIRTY = TRUE; } } if ( *error_ptr ) { return(NULL); } } *dir_cluster_ptr = entry_cluster; *dir_index_ptr = dir_index; return(dir_entry_ptr); }
void main_task ( uint_32 initial_data ) { DATE_STRUCT time_rtc; TIME_STRUCT time_mqx; if (_lwevent_create(&lwevent,0) != MQX_OK) { printf("\nMake event failed"); _task_block(); } printf ("\fStart time (MQX synchronized to RTC time during bsp init):\n\n"); /* initialize time */ time_rtc.YEAR = 2010; time_rtc.MONTH = 10; time_rtc.DAY = 15; time_rtc.HOUR = 10; time_rtc.MINUTE = 8; time_rtc.SECOND = 0; time_rtc.MILLISEC = 0; _time_from_date (&time_rtc, &time_mqx); _time_set( &time_mqx); if( _rtc_sync_with_mqx(FALSE) != MQX_OK ) { printf("\nError synchronize time!\n"); _task_block(); } _time_get (&time_mqx); _time_to_date (&time_mqx, &time_rtc); print_mqx_time(&time_rtc, &time_mqx); print_current_time(); /* except MPC5125 */ #ifndef BSP_TWRMPC5125 install_interrupt(); /* enable stopwatch */ install_stopwatch(); /* enable alarm */ install_alarm(); _lwevent_wait_ticks(&lwevent,LWE_ALARM,FALSE,0); _lwevent_clear(&lwevent,LWE_ALARM); printf ("\nALARM!\n"); print_current_time(); /* end of alarm */ printf ("Continue wasting time (2 minutes max) ...\n"); _lwevent_wait_ticks(&lwevent,LWE_STOPWATCH,FALSE,0); _lwevent_clear(&lwevent,LWE_STOPWATCH); printf ("\nSTOPWATCH!\n"); print_current_time(); printf ("\nClearing RTC:\n"); _rtc_init (RTC_INIT_FLAG_CLEAR | RTC_INIT_FLAG_ENABLE); print_current_time(); install_alarm(); _lwevent_wait_ticks(&lwevent,LWE_ALARM,FALSE,0); _lwevent_clear(&lwevent,LWE_ALARM); printf ("ALARM!\n"); print_current_time(); #else /* BSP_TWRMPC5125 */ printf ("Waste 10 seconds here\n"); _time_delay(10000); _rtc_get_time_mqxd (&time_rtc); print_rtc_time(&time_rtc, &time_mqx); #endif printf ("Synchronize RTC to MQX time again:\n"); _rtc_sync_with_mqx (FALSE); _rtc_get_time_mqxd (&time_rtc); _time_from_date (&time_rtc, &time_mqx); print_rtc_time(&time_rtc, &time_mqx); #if PSP_HAS_IRTC == 1 irtc_test(); #endif /* PSP_HAS_IRTC == 1 */ /* Test tamper event functionality on MCF51EMxx device */ #if PSP_MQX_CPU_IS_MCF51EM test_tamper(); #else printf ("Finish, press/hold reset to repeat.\n"); _task_block() ; #endif }