File content as of revision 1:0e0967c88590:

#include "funcoesSDCard.h"
#include "serialPC.h"

arquivoSD sdCard::envio;
arquivoSD sdCard::armazenamento;
arquivoSD sdCard::config;
arquivoSD sdCard::devices;
arquivoSD sdCard::status;
arquivoSD sdCard::tempFile;

char sdCard::nomeArquivoEmRecebimento[30];


bool sdCard::deleteSentFiles;

SDFileSystem sd(p11, p12, p13, p14, "sd");


bool sdCard::abreArquivo(arquivoSD *arquivo,char *mode){
    //Struct do arquivo e seu nome
    if(arquivo->aberto){
        if(!fclose(arquivo->fp)){
            return false;    
        }
    }
     
    //pc.printf("Abrindo arquivo <%s>.\n",arquivo->nome);
    if((arquivo->fp = fopen(arquivo->nome,mode))!=NULL){
        arquivo->aberto = true;    
        return true;
    }else{
        return false;   
     } 
}

uint16_t sdCard::calcCheckSum16BITFile(char *nome){
    FILE *fp;
    char c;
    uint16_t sum = 0;
    
    fp = fopen (nome,"r");    
    if(fp != NULL){            
        do{
            c = fgetc(fp);
            if(!feof(fp)){sum+=c;}
        }while(!feof(fp));
        fclose(fp);                
    }
    return sum;
}

bool sdCard::insereDadosArquivoPeloNome(char *nome, char *dados,uint16_t tam){
    FILE *fp;
    fp = fopen(nome,"a");
    uint16_t i;
    if(fp!=NULL){
        for(i=0;i<tam;i++){
            fprintf(fp,"%c",dados[i]);
            fflush(fp);    
        }
        fclose(fp);
    }else{
        return false;  
     }    
    return true;
}

bool sdCard::insereDadosArquivo(arquivoSD *arquivo, char* data,uint16_t tam){
    //Struct do arquivo, dados a inserir e tamanho deles    
    uint16_t i;    
    
    if(!sdCard::abreArquivo(arquivo,"a")){
        pc.printf("Erro abrindo %s .\n",arquivo->nome);
        if(!sdCard::fechaArquivo(arquivo)){
            return false;    
        }        
    }
    
    for(i=0;i<tam;i++){
        fprintf(arquivo->fp,"%c",data[i]);
        fflush(arquivo->fp);    
    }
    
    sdCard::fechaArquivo(arquivo);
    return true;
}
bool sdCard::fechaArquivo(arquivoSD* arquivo){
    //Struct do arquivo    
    fclose(arquivo->fp);
    arquivo->aberto = false;
    return true;    
}

bool sdCard::excluiArquivo(arquivoSD *arquivo){
    bool retorno = true;
    if(arquivo->aberto){
        if(!sdCard::fechaArquivo(arquivo)){retorno = false;}
    }
    if(!remove(arquivo->nome)){retorno = false;}
    return retorno;
}

bool sdCard::exibeArquivo(arquivoSD *arquivo){
    
    if(!sdCard::abreArquivo(arquivo,"r")){
        return false;
    }
    
    //rewind(arquivo->fp);
    char c;
    pc.printf("\n\nInicio do arquivo %s.\n\n",arquivo->nome);
    
    do{
        c = fgetc(arquivo->fp);
        if(!feof(arquivo->fp)){pc.printf("%c",c);}
    }while(!feof(arquivo->fp));
    pc.printf("\n\nFim do arquivo %s.\n",arquivo->nome);
    sdCard::fechaArquivo(arquivo);
    return true;    
}

int sdCard::init(){
    //Inicializando SDCard         
    
    strcpy(sdCard::envio.nome,"/sd/RAD/envio.txt");
    strcpy(sdCard::armazenamento.nome,"/sd/RAD/armazenamento.txt");
    strcpy(sdCard::config.nome,"/sd/RAD/config.bin");    
    strcpy(sdCard::devices.nome,"/sd/RAD/devices.cfg");
    strcpy(sdCard::status.nome,"/sd/RAD/status.txt");
    strcpy(sdCard::tempFile.nome,"/sd/RAD/tempFile.bin");
    
    
    
    
    if(!sdCard::abreArquivo(&sdCard::config,"r")){
        //Não foi encontrado o arquivo config.bin, então vou criar o diretório        
        pc.printf("Nao foi encontrado o arquivo config.bin .\n");        
        //Criando o diretorio
        pc.printf("Criando diretorio e arquivo config.bin .\n");
        mkdir("/sd/RAD", 0777);
        
        if(sdCard::abreArquivo(&sdCard::config,"w")){
         //Fazer o arquivo de configuração aqui!
         pc.printf("Criado arquivo config.bin .\n");
         fprintf(sdCard::config.fp,"SSID:DROME\r\nPASSWORD:VITAE\r\nPORT:80");
         
        }        
    }   
    //Fechando arquivo de configuração;
    fechaArquivo(&sdCard::config);    
    if(!sdCard::abreArquivo(&sdCard::devices,"r")){
        pc.printf("Remota nao parametrizada!!!\n");    
    }else{
        fechaArquivo(&sdCard::devices);   
     }    
    return 1;
}

int sdCard::preparaEnvio(void){         
    //Verifico se existe arquivo pendente de envio.
    if(sdCard::envio.aberto||sdCard::armazenamento.aberto){        
        pc.printf("Um dos dois arquivos esta aberto. envio = %u, armazenamento = %u.\n",sdCard::envio.aberto,sdCard::armazenamento.aberto);             
        return 2;
    }    
    
    
    if(abreArquivo(&sdCard::envio,"r")){     
     pc.printf("Tem um arquivo pendente de envio.\n");     
     fechaArquivo(&sdCard::envio);          
     return 1;
    }    
    
    if(sdCard::abreArquivo(&sdCard::armazenamento,"r")){
        sdCard::fechaArquivo(&sdCard::armazenamento);    
    }else{
        pc.printf("Nao foi encontrado o arquivo de armazenamento em preparaEnvio.\n");
        return 0;   
     }
    
    sdCard::armazenamento.aberto = true;
    sdCard::envio.aberto = true;
    
    //Incluindo o status no envio
    modemCom::writeStatusToSD();
    
    if(!sdCard::file_rename("/sd/RAD/armazenamento.txt","/sd/RAD/envio.txt")){
        pc.printf("Nao foi possivel renomear arquivo para envio.\n");
        sdCard::armazenamento.aberto = false;
        sdCard::envio.aberto = false;
        return 0;
    }    
    
    sdCard::armazenamento.aberto = false;
    sdCard::envio.aberto = false;
    pc.printf("Renomeado.\n");        
    return 1;
}

void sdCard::finalizaEnvio(void){    
    if(sdCard::envio.aberto){fclose(sdCard::envio.fp);}
    remove(sdCard::envio.nome);  
    pc.printf("Deletado o arquivo de envio apos envio do mesmo ao server.\n");  
}

bool sdCard::getFileTam(arquivoSD *arquivo){
    uint32_t tam=0;        
    uint8_t timeout = 50;
    while((timeout>0)&&(arquivo->aberto)){
        //Aguardo fechar o arquivo caso ele esteja aberto
        timeout--;
        osDelay(100);
    }
    
    if(arquivo->aberto){
        fechaArquivo(arquivo);
    }        
    
    if(sdCard::abreArquivo(arquivo,"r")){    
        rewind(arquivo->fp);
        while(fgetc(arquivo->fp)!=EOF){
         tam++;
        }
        sdCard::fechaArquivo(arquivo);
    }else{
        return false;   
     }
    arquivo->bytes = tam;
    return true;
}

bool sdCard::arquivoAberto(){
/*extern arquivoSD envio;
 extern arquivoSD armazenamento;
 extern arquivoSD config;
 extern arquivoSD devices;
 extern arquivoSD status; 
 extern arquivoSD tempFile;*/
    return (
    sdCard::envio.aberto
    ||
    sdCard::armazenamento.aberto
    ||
    sdCard::config.aberto
    ||
    sdCard::devices.aberto
    ||
    sdCard::status.aberto
    ||
    sdCard::tempFile.aberto
    );    
}


//***********************************************************
// file_rename: renames a file (via copy & delete).
//    Moves data instead of adjusting the file name in the
//    file directory. Checks to insure the file was renamed.
//    Returns -1 = error; 0 = success
//***********************************************************
uint8_t sdCard::file_rename(const char *oldfname, const char *newfname) {
    int retval = 0;
    int ch;
    sdCard::envio.bytes=0;
 
    FILE *fpold = fopen(oldfname, "r");   // src file
    if(fpold == NULL){
        fclose(fpold);        
        return 0;    
    }    
    
    FILE *fpnew = fopen(newfname, "w");   // dest file
    if(fpnew == NULL){        
        fclose(fpnew);
        return 0;    
    }    
    
    pc.printf("Iniciando copia.\n");
    
    sdCard::envio.bytes=0;
    ch = fgetc(fpold);    
    while(ch != EOF){
        fputc(ch, fpnew);    
        ch = fgetc(fpold);
        sdCard::envio.bytes++;    
    }    
    
    fclose(fpnew);
    fclose(fpold);
 
    fpnew = fopen(newfname, "r"); // Reopen dest to insure
    if(fpnew == NULL) {           // that it was created.
        retval = (0);            // Return Error.
    } 
    else {
        fclose(fpnew);  
        remove(oldfname);         // Remove original file.
        retval = (1);             // Return Success.
    }
    return (retval);
}