file_system_manager.cpp

00001 #include "file_system_manager.h"
00002 
00003 QSPIFileSystem qspifs("qspi");
00004 
00005 extern Serial pc;
00006 
00007 char file_buffer [ FILE_BUFFER_SIZE ];
00008 
00009 int fset_header_ip ( const char * new_header_ip )
00010 {
00011     FILE * fip = fopen("/qspi/myip.txt", "w");
00012     if ( fip )
00013     {
00014         fprintf( fip, "%s\n\r", new_header_ip  );
00015         fclose( fip );
00016         return ( 0 );
00017     }
00018         else
00019     {
00020         return ( -1 );
00021     }
00022 }
00023 
00024 int fget_ip ( char * header_ip, const size_t length )
00025 {
00026     FILE * fip = fopen ("/qspi/myip.txt", "r" );
00027     if ( fip != NULL )
00028     {
00029         int read = fread ( header_ip, 1, length, fip );
00030         if( read > 0 )
00031         {
00032             for ( register int i = 0; i < read; i++ )
00033             {
00034                 if( header_ip [ i ] == '\n' || header_ip [ i ] == '\r' )
00035                 {
00036                     header_ip [ i ] = '\0';
00037                     break;
00038                 }
00039             }
00040         } else {
00041             if ( fip ) fclose ( fip );
00042             return ( -3 );
00043         }
00044         
00045         header_ip [ length ] = 0;
00046 
00047         if ( fip ) fclose ( fip );
00048         
00049         return ( read );
00050     } 
00051     
00052     return ( -1 );
00053 }
00054 
00055 int fget_fw_ip ( char * fw_ip, const size_t length )
00056 {
00057     FILE *ffw_ip = fopen( "/qspi/fw_ip.txt", "r");
00058     if( ffw_ip == NULL ){
00059         return ( -1 );
00060     }else{
00061         int read = fread( fw_ip, 1, 512, ffw_ip );
00062         if( read > 0 ){
00063             for( int i = 0; i < read; i++ ) 
00064                 if( fw_ip[ i ] == '\n' || fw_ip[ i ] == '\r' ){
00065                     fw_ip[ i ] = '\0';
00066                     break;
00067                 }           
00068         }else{
00069            if ( ffw_ip ) fclose ( ffw_ip );
00070            return ( -3 );
00071         }
00072         
00073        if ( ffw_ip ) fclose ( ffw_ip );
00074        
00075        fw_ip [ length ] = 0;
00076        
00077        return ( read );
00078     }
00079  }
00080 
00081 int fget_server_ip ( char * server_ip, const size_t length )
00082 {
00083     FILE * fsip = fopen ("/qspi/serverip.txt", "r" );
00084     if ( fsip != NULL )
00085     {
00086         int read = fread ( server_ip, 1, length, fsip );
00087         if( read > 0 )
00088         {
00089             for ( register int i = 0; i < read; i++ )
00090             {
00091                 if( server_ip [ i ] == '\n' || server_ip [ i ] == '\r' )
00092                 {
00093                     server_ip [ i ] = '\0';
00094                     break;
00095                 }
00096             }
00097         } else {
00098             if ( fsip ) fclose ( fsip );
00099             return ( -3 );
00100         }
00101         
00102         server_ip [ length ] = 0;
00103 
00104         fclose ( fsip );
00105         
00106         return ( read );
00107     } 
00108     
00109     return ( -1 );
00110 }
00111 
00112 int fget_mask ( char * eth_mask, const size_t length )
00113 {
00114     FILE * fmsk = fopen("/qspi/mymask.txt", "r");
00115     if ( fmsk != NULL )
00116     {
00117         int read = fread ( eth_mask, 1, length, fmsk );
00118         if( read > 0 )
00119         {
00120             for ( register int i = 0; i < read; i++ )
00121             {
00122                 if( eth_mask [ i ] == '\n' || eth_mask [ i ] == '\r' )
00123                 {
00124                     eth_mask [ i ] = '\0';
00125                     break;
00126                 }
00127             }
00128         } else {
00129             if ( fmsk ) fclose ( fmsk );
00130             return ( -3 );
00131         }
00132         
00133         eth_mask [ length ] = 0;
00134 
00135         if ( fmsk ) fclose ( fmsk );
00136         
00137         return ( read );
00138     } 
00139     
00140     return ( -1 );    
00141 }
00142 
00143 int fget_gateway ( char * eth_gw, const size_t length )
00144 {
00145     FILE * fgw = fopen("/qspi/mygateway.txt", "r");
00146     if ( fgw != NULL )
00147     {
00148         int read = fread ( eth_gw, 1, length, fgw );
00149         if( read > 0 )
00150         {
00151             for ( register int i = 0; i < read; i++ )
00152             {
00153                 if( eth_gw [ i ] == '\n' || eth_gw [ i ] == '\r' )
00154                 {
00155                     eth_gw [ i ] = '\0';
00156                     break;
00157                 }
00158             }
00159         } else { 
00160             if ( fgw ) fclose ( fgw );
00161             return ( -3 );
00162         }
00163         
00164         eth_gw [ length ] = 0;
00165 
00166         if ( fgw ) fclose ( fgw );
00167         
00168         return ( read );
00169     } 
00170         
00171     return ( -1 );        
00172 }
00173 
00174 int fset_header_ext ( const int new_header_ext )
00175 {
00176     FILE * fext = fopen( "/qspi/myext.txt", "w" );
00177     if ( fext )
00178     {
00179         fprintf( fext, "%i\n\r", new_header_ext );
00180         fclose( fext );
00181         return ( 0 );
00182     }
00183         else
00184     {
00185         return ( -1 );    
00186     }
00187 }
00188 
00189 int fset_acceptable_delay ( const int new_acceptable_delay )
00190 {
00191     FILE * fad = fopen( "/qspi/acceptable_delay.txt", "w" );
00192     if ( fad )
00193     {
00194         fprintf ( fad, "%i\n\r", new_acceptable_delay );
00195         fclose ( fad );
00196         return ( 0 );
00197     }
00198         else
00199     {
00200         return ( -1 );    
00201     }
00202 }
00203 
00204 int fget_acceptable_delay ( void )
00205 {
00206     char get_acceptable_delay_buffer [ 32 ] = "";
00207     
00208     FILE * fad = fopen ( "/qspi/acceptable_delay.txt", "r" );
00209     if ( fad == NULL )
00210     {   
00211         return ( -3 );
00212     } else {
00213         if( fread ( ( void * ) get_acceptable_delay_buffer, 1, sizeof ( get_acceptable_delay_buffer ) - 1, fad ) > 0 )
00214         {
00215             if ( fad ) fclose ( fad );
00216             return ( atoi ( get_acceptable_delay_buffer ) );
00217         } else {
00218             if ( fad ) fclose ( fad );
00219             return ( -5 );
00220         }
00221     }
00222 }
00223 
00224 int fget_header_ext ( void )
00225 {
00226     char get_header_ext_buffer [ 32 ] = "";
00227     
00228     FILE * fext = fopen ( "/qspi/myext.txt", "r" );
00229     if ( fext == NULL )
00230     {   
00231         return ( -3 );
00232     } else {
00233         if( fread ( ( void * ) get_header_ext_buffer, 1, sizeof ( get_header_ext_buffer ) - 1, fext ) > 0 )
00234         {
00235             if ( fext ) fclose ( fext );
00236             return ( atoi ( get_header_ext_buffer ) );
00237         } else {
00238             if ( fext ) fclose ( fext );
00239             return ( -5 );
00240         }
00241     }
00242 }
00243 
00244 int fset_header_sip_port ( const int new_header_sip_port )
00245 {
00246     FILE * fport = fopen("/qspi/mysipport.txt", "w");
00247     if ( fport )
00248     {
00249         fprintf( fport,"%i\n\r", new_header_sip_port );
00250         fclose( fport );
00251         return ( 0 );
00252     }
00253         else
00254     {
00255         return ( -1 );    
00256     }
00257 }
00258 
00259 int fget_header_sip_port ( void )
00260 {
00261     char get_header_sip_port_buffer [ 32 ] = "";
00262     
00263     FILE * fport = fopen ( "/qspi/mysipport.txt", "r" );
00264     if ( fport == NULL )
00265     {
00266         return ( -1 );
00267     } else {
00268         if( fread ( ( void * ) get_header_sip_port_buffer, 1, sizeof ( get_header_sip_port_buffer ) - 1, fport ) > 0 )
00269         {
00270             if ( fport ) fclose ( fport );
00271             return ( atoi ( get_header_sip_port_buffer ) );
00272         } else {
00273             if ( fport ) fclose ( fport );
00274             return ( -3 );
00275         }
00276     }
00277 }
00278 
00279 int fset_server_ip ( const char * new_server_ip )
00280 {
00281     FILE * fsip = fopen("/qspi/serverip.txt", "w");
00282     if ( fsip )
00283     {
00284         fprintf( fsip,"%s\n\r", new_server_ip );
00285         fclose( fsip );
00286         return ( 0 );
00287     }
00288         else
00289     {
00290         return ( -1 );    
00291     }
00292 }
00293 
00294 int fset_server_ext ( const int new_server_ext )
00295 {
00296     FILE * fserext = fopen("/qspi/peerext.txt", "w");
00297     if ( fserext )
00298     {
00299         fprintf( fserext , "%i\n\r", new_server_ext );
00300         fclose( fserext );
00301         return ( 0 );
00302     }
00303         else
00304     {
00305         return ( -1 );    
00306     }
00307 }
00308 
00309 int fget_server_ext ( void )
00310 {
00311     char get_server_ext_buffer [ 32 ] = "";
00312     
00313     FILE * fserver_ext = fopen ( "/qspi/peerext.txt", "r" );
00314     if ( fserver_ext == NULL )
00315     {   
00316         return ( -3 );
00317     } else {
00318         if( fread ( ( void * ) get_server_ext_buffer, 1, sizeof ( get_server_ext_buffer ) - 1, fserver_ext ) > 0 )
00319         {
00320             if ( fserver_ext ) fclose ( fserver_ext );
00321             return ( atoi ( get_server_ext_buffer ) );
00322         } else {
00323             if ( fserver_ext ) fclose ( fserver_ext );
00324             return ( -5 );
00325         }
00326     }
00327 }
00328 
00329 int fset_server_port ( const int new_server_port )
00330 {
00331     FILE * fsport = fopen("/qspi/serverport.txt", "w");   
00332     if ( fsport )
00333     {
00334         fprintf(fsport,"%i\n\r", new_server_port );
00335         fclose( fsport );
00336         return ( 0 );
00337     }
00338         else
00339     {
00340         return ( -1 );    
00341     }
00342 }
00343 
00344 int fget_server_port ( void )
00345 {
00346     char get_server_sip_port_buffer [ 32 ] = "";
00347     
00348     FILE * fserver_port = fopen ( "/qspi/serverport.txt", "r" );
00349     if ( fserver_port == NULL )
00350     {
00351         return ( -1 );
00352     } else {
00353         if( fread ( ( void * ) get_server_sip_port_buffer, 1, sizeof ( get_server_sip_port_buffer ) - 1, fserver_port ) > 0 )
00354         {
00355             if ( fserver_port ) fclose ( fserver_port );
00356             return ( atoi ( get_server_sip_port_buffer ) );
00357         } else {
00358             if ( fserver_port ) fclose ( fserver_port );
00359             return ( -3 );
00360         }
00361     }
00362 }
00363 
00364 int fset_mask ( const char * new_mask )
00365 {
00366     FILE * fmask = fopen("/qspi/mymask.txt", "w");
00367     if ( fmask )
00368     {
00369         fprintf(fmask,"%s\n\r",new_mask );
00370         fclose( fmask );
00371         return ( 0 );
00372     }
00373         else
00374     {
00375         return ( -1 );    
00376     }
00377 }
00378 
00379 int fset_gateway ( const char * new_gateway )
00380 {
00381     FILE * fgate = fopen("/qspi/mygateway.txt", "w");
00382     if ( fgate )
00383     {
00384         fprintf(fgate,"%s\n\r", new_gateway );
00385         fclose( fgate );
00386         return ( 0 );
00387     }
00388         else
00389     {
00390         return ( -1 );    
00391     }
00392 }
00393 
00394 int set_udp_port_listener ( const int new_udp_port_listener )
00395 {
00396     FILE * fudpport = fopen( "/qspi/udpport.txt", "w" );
00397     if ( fudpport )
00398     {
00399         fprintf( fudpport, "%i\n\r",new_udp_port_listener );
00400         fclose( fudpport );
00401         return ( 0 );
00402     }
00403         else
00404     {
00405         return ( -1 );    
00406     }
00407 }
00408 
00409 int fget_udp_port_listener ( void )
00410 {
00411     char get_udp_port_listener_buffer [ 32 ] = "";
00412     
00413     FILE * fudp_port_listener = fopen ( "/qspi/udpport.txt", "r" );
00414     if ( fudp_port_listener == NULL )
00415     {
00416         return ( -1 );
00417     } else {
00418         if( fread ( ( void * ) get_udp_port_listener_buffer, 1, sizeof ( get_udp_port_listener_buffer ) - 1, fudp_port_listener ) > 0 )
00419         {
00420             if ( fudp_port_listener ) fclose ( fudp_port_listener );
00421             return ( atoi ( get_udp_port_listener_buffer ) );
00422         } else {
00423             if ( fudp_port_listener ) fclose ( fudp_port_listener );
00424             return ( -3 );
00425         }
00426     }
00427 }
00428 
00429 int set_tcp_port_listener ( const int new_tcp_port_listener )
00430 {
00431     FILE * ftcpport = fopen( "/qspi/tcpport.txt", "w" );
00432     if ( ftcpport )
00433     {
00434         fprintf( ftcpport, "%i\n\r",new_tcp_port_listener );
00435         fclose( ftcpport );
00436         return ( 0 );
00437     }
00438         else
00439     {
00440         return ( -1 );    
00441     }
00442 }
00443 
00444 int fget_tcp_port_listener ( void )
00445 {
00446     char get_tcp_port_listener_buffer [ 32 ] = "";
00447     
00448     FILE * ftcp_port_listener = fopen ( "/qspi/tcpport.txt", "r" );
00449     if ( ftcp_port_listener == NULL )
00450     {
00451         return ( -1 );
00452     } else {
00453         if( fread ( ( void * ) get_tcp_port_listener_buffer, 1, sizeof ( get_tcp_port_listener_buffer ) - 1, ftcp_port_listener ) > 0 )
00454         {
00455             if ( ftcp_port_listener ) fclose ( ftcp_port_listener );
00456             return ( atoi ( get_tcp_port_listener_buffer ) );
00457         } else {
00458             if ( ftcp_port_listener ) fclose ( ftcp_port_listener );
00459             return ( -3 );
00460         }
00461     }
00462 }
00463 
00464 int fset_fw_ip ( const char * new_fw_ip )
00465 {
00466     FILE * ffwip = fopen("/qspi/fw_ip.txt", "w" );
00467     if ( ffwip )
00468     {
00469         fprintf(ffwip,"%s\n\r", new_fw_ip );
00470         fclose( ffwip );
00471         return ( 0 );
00472     }
00473         else
00474     {
00475         return ( -1 );    
00476     }
00477 }
00478 
00479 int fset_fw_port ( const int new_fw_port )
00480 {
00481     FILE * ffwport = fopen("/qspi/fw_port.txt", "w" );
00482     if ( ffwport )
00483     {
00484         fprintf(ffwport,"%i\n\r", new_fw_port );
00485         fclose( ffwport );
00486         return ( 0 );
00487     }
00488         else
00489     {
00490         return ( -1 );    
00491     }
00492 }
00493 
00494 int fget_fw_port ( void )
00495 {
00496     char get_fw_server_port_buffer [ 32 ] = "";
00497     
00498     FILE * ffw_server_port = fopen ( "/qspi/fw_port.txt", "r" );
00499     if ( ffw_server_port == NULL )
00500     {
00501         return ( -1 );
00502     } else {
00503         if( fread ( ( void * ) get_fw_server_port_buffer, 1, sizeof ( get_fw_server_port_buffer ) - 1, ffw_server_port ) > 0 )
00504         {
00505             if ( ffw_server_port ) fclose ( ffw_server_port );
00506             return ( atoi ( get_fw_server_port_buffer ) );
00507         } else {
00508             if ( ffw_server_port ) fclose ( ffw_server_port );
00509             return ( -3 );
00510         }
00511     }
00512 }
00513 
00514 int fset_max_ext ( const int new_max_ext )
00515 {
00516     FILE * fmex = fopen( "/qspi/maxext.txt", "w" );
00517     if ( fmex ){
00518         fprintf( fmex, "%i\n\r", new_max_ext );
00519         fclose( fmex );
00520         return ( 0 );
00521     }
00522         else
00523     {
00524         return ( -1 );    
00525     }
00526 }
00527 
00528 int fget_max_ext ( void )
00529 {
00530     char get_max_ext_buffer [ 32 ] = "";
00531     
00532     FILE * fmax_ext = fopen ( "/qspi/maxext.txt", "r" );
00533     if ( fmax_ext == NULL )
00534     {
00535         return ( -1 );
00536     } else {
00537         if( fread ( ( void * ) get_max_ext_buffer, 1, sizeof ( get_max_ext_buffer ) - 1, fmax_ext ) > 0 )
00538         {
00539             if ( fmax_ext ) fclose ( fmax_ext );
00540             return ( atoi ( get_max_ext_buffer ) );
00541         } else {
00542             if ( fmax_ext ) fclose ( fmax_ext );
00543             return ( -3 );
00544         }
00545     }
00546 }
00547 
00548 int fset_min_ext ( const int new_min_ext )
00549 {
00550     FILE * fmin = fopen( "/qspi/minext.txt", "w" );
00551     if ( fmin ){
00552         fprintf( fmin, "%i\n\r", new_min_ext );
00553         fclose( fmin );
00554         return ( 0 );
00555     }
00556         else
00557     {
00558         return ( -1 );    
00559     }
00560 }
00561 
00562 int fget_min_ext ( void )
00563 {
00564     char get_min_ext_buffer [ 32 ] = "";
00565     
00566     FILE * fmin_ext = fopen ( "/qspi/minext.txt", "r" );
00567     if ( fmin_ext == NULL )
00568     {
00569         return ( -1 );
00570     } else {
00571         if( fread ( ( void * ) get_min_ext_buffer, 1, sizeof ( get_min_ext_buffer ) - 1, fmin_ext ) > 0 )
00572         {
00573             if ( fmin_ext ) fclose ( fmin_ext );
00574             return ( atoi ( get_min_ext_buffer ) );
00575         } else {
00576             if ( fmin_ext ) fclose ( fmin_ext );
00577             return ( -3 );
00578         }
00579     }
00580 }
00581 
00582 // Print the content of a given file
00583 int cat ( const char * fname )
00584 {
00585     char buff[513];
00586     int num;
00587     
00588     FILE * fp = fopen( fname, "r" );
00589     if ( fp == NULL )
00590     {
00591         pc.printf( "Failed to open %s", fname);
00592         return ( -3 );
00593     }
00594     
00595     while( ( num = fread( buff, 1, 512, fp ) ) > 0 )
00596     {
00597         buff[ num ] = '\0';
00598         pc.printf( "%s", buff );
00599     }
00600     
00601     if ( fp ) fclose ( fp );
00602     
00603     return ( 0 );
00604 }
00605 
00606 int fset_shift_port ( const int new_shift_port )
00607 {
00608     FILE * shift_port = fopen("/qspi/shift_port.txt", "w" );
00609     if( shift_port )
00610     {
00611         fprintf( shift_port,"%i\n\r", new_shift_port );
00612         fclose( shift_port );
00613         return ( 0 );
00614     }
00615         else
00616     {
00617         return ( -1 );
00618     }
00619 }
00620 
00621 
00622 int fget_shift_port ( void )
00623 {
00624     char get_shift_port_buffer [ 32 ] = "";
00625     
00626     FILE * fshift_port = fopen ( "/qspi/shift_port.txt", "r" );
00627     if ( fshift_port == NULL )
00628     {
00629         return ( -1 );
00630     } else {
00631         if( fread ( ( void * ) get_shift_port_buffer, 1, sizeof ( get_shift_port_buffer ) - 1, fshift_port ) > 0 )
00632         {
00633             if ( fshift_port ) fclose ( fshift_port );
00634             return ( atoi ( get_shift_port_buffer ) );
00635         } else {
00636             if ( fshift_port ) fclose ( fshift_port );
00637             return ( -3 );
00638         }
00639     }
00640 }
00641 
00642 int files ( const char type )
00643 {       
00644     if ( type == 's' ) {     
00645         pc.printf("Header IP " );
00646         cat ("/qspi/myip.txt");
00647 
00648         pc.printf("Header ext ");
00649         cat("/qspi/myext.txt");
00650 
00651         pc.printf("Header port ");
00652         cat("/qspi/mysipport.txt");
00653 
00654         pc.printf("Server IP ");
00655         cat("/qspi/serverip.txt");
00656 
00657         pc.printf("Server ext ");
00658         cat("/qspi/peerext.txt");
00659 
00660         pc.printf("Server port ");
00661         cat("/qspi/serverport.txt");
00662 
00663         pc.printf("Mascara de rede ");
00664         cat("/qspi/mymask.txt");
00665 
00666         pc.printf("Gateway IP ");
00667         cat("/qspi/mygateway.txt");
00668 
00669         pc.printf("UDP Port ");
00670         cat("/qspi/udpport.txt");
00671 
00672         pc.printf("TCP Port ");
00673         cat("/qspi/tcpport.txt");
00674 
00675         pc.printf("FW Server IP ");
00676         cat("/qspi/fw_ip.txt");
00677 
00678         pc.printf("FW Server Port ");
00679         cat("/qspi/fw_port.txt");
00680 
00681         pc.printf("Max Ext ");
00682         cat("/qspi/maxext.txt");
00683 
00684         pc.printf("Min Ext ");
00685         cat("/qspi/minext.txt");
00686         
00687         pc.printf("Shift Port ");
00688         cat("/qspi/shift_port.txt");
00689 
00690         pc.printf("Clock Server IP ");
00691         cat("/qspi/serverip.txt");
00692             
00693         return ( 0 );
00694     }
00695     
00696     return ( -1 );
00697 }
00698 
00699 int init_fsystem ( void )
00700 {
00701     //  init file system and check if files exist
00702     int return_value = 0;
00703     
00704     if (!qspifs.isformatted()) {
00705         qspifs.format();
00706         return_value |= BIT0;
00707     }
00708     
00709     return ( return_value |= BIT1 );
00710 }
00711 
00712 int fset_cbx_detach_mode ( const bool new_cbx_detach_mode )
00713 {
00714     FILE * file_cbx_detach_mode = fopen ("/qspi/cbx_detach_mode.txt", "w" );
00715     if ( file_cbx_detach_mode )
00716     {
00717         fprintf ( file_cbx_detach_mode,"%i\n\r", ( new_cbx_detach_mode ) ? 1 : 0 );
00718         fclose ( file_cbx_detach_mode );
00719         return ( 0 );
00720     }
00721         else
00722     {
00723         return ( -1 );
00724     }
00725 }
00726 
00727 bool fget_cbx_detach_mode ( int * err )
00728 {
00729     char get_cbx_detach_mode_buffer [ 32 ] = "";
00730     
00731     FILE * file_cbx_detach_mode = fopen ( "/qspi/cbx_detach_mode.txt", "r" );
00732     if ( file_cbx_detach_mode == NULL )
00733     {
00734         *err = -1;
00735     } else {
00736         if( fread ( ( void * ) get_cbx_detach_mode_buffer, 1, sizeof ( get_cbx_detach_mode_buffer ) - 1, file_cbx_detach_mode ) > 0 )
00737         {
00738             if ( file_cbx_detach_mode ) fclose ( file_cbx_detach_mode );
00739             int tmp = atoi ( get_cbx_detach_mode_buffer );
00740             
00741             return ( ( tmp == 1 ) ? true : false );
00742         } else {
00743             if ( file_cbx_detach_mode ) fclose ( file_cbx_detach_mode );
00744             *err = -3;
00745         }
00746     }
00747     
00748     return false;
00749 }
00750 
00751 int fset_cbx_wake_mode ( const bool new_cbx_wake_mode )
00752 {
00753     FILE * file_cbx_wake_mode = fopen ("/qspi/cbx_wake_mode.txt", "w" );
00754     if ( file_cbx_wake_mode )
00755     {
00756         fprintf ( file_cbx_wake_mode,"%i\n\r", ( new_cbx_wake_mode ) ? 1 : 0 );
00757         fclose ( file_cbx_wake_mode );
00758         return ( 0 );
00759     }
00760         else
00761     {
00762         return ( -1 );
00763     }
00764 }
00765 
00766 bool fget_cbx_wake_mode ( int * err )
00767 {
00768     char get_cbx_wake_mode_buffer [ 32 ] = "";
00769     
00770     FILE * file_cbx_wake_mode = fopen ( "/qspi/cbx_wake_mode.txt", "r" );
00771     if ( file_cbx_wake_mode == NULL )
00772     {
00773         *err = -1;
00774     } else {
00775         if( fread ( ( void * ) get_cbx_wake_mode_buffer, 1, sizeof ( get_cbx_wake_mode_buffer ) - 1, file_cbx_wake_mode ) > 0 )
00776         {
00777             if ( file_cbx_wake_mode ) fclose ( file_cbx_wake_mode );
00778             int tmp = atoi ( get_cbx_wake_mode_buffer );
00779             
00780             return ( ( tmp == 1 ) ? true : false );
00781         } else {
00782             if ( file_cbx_wake_mode ) fclose ( file_cbx_wake_mode );
00783             *err = -3;
00784         }
00785     }
00786     
00787     return false;
00788 }
00789 
00790 int fset_cbx_mode ( const uint8_t new_cbx_mode )
00791 {
00792     FILE * file_cbx_mode = fopen ("/qspi/cbx_mode.txt", "w" );
00793     if ( file_cbx_mode )
00794     {
00795         fprintf ( file_cbx_mode,"%i\n\r", new_cbx_mode );
00796         fclose ( file_cbx_mode );
00797         return ( 0 );
00798     }
00799         else
00800     {
00801         return ( -1 );
00802     }
00803 }
00804 
00805 int fget_cbx_mode ( void )
00806 {
00807     char get_cbx_mode_buffer [ 32 ] = "";
00808     
00809     FILE * file_cbx_mode = fopen ( "/qspi/cbx_mode.txt", "r" );
00810     if ( file_cbx_mode == NULL )
00811     {
00812         return ( -1 );
00813     } else {
00814         if( fread ( ( void * ) get_cbx_mode_buffer, 1, sizeof ( get_cbx_mode_buffer ) - 1, file_cbx_mode ) > 0 )
00815         {
00816             if ( file_cbx_mode ) fclose ( file_cbx_mode );
00817             return ( atoi ( get_cbx_mode_buffer ) );
00818         } else {
00819             if ( file_cbx_mode ) fclose ( file_cbx_mode );
00820             return ( -3 );
00821         }
00822     }
00823 }