daily pastebin goal
24%
SHARE
TWEET

Untitled

a guest Dec 7th, 2017 51 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*****************************************************************************
  2.  *   Peripherals such as temp sensor, light sensor, accelerometer,
  3.  *   and trim potentiometer are monitored and values are written to
  4.  *   the OLED display.
  5.  *
  6.  *   Copyright(C) 2009, Embedded Artists AB
  7.  *   All rights reserved.
  8.  *
  9.  ******************************************************************************/
  10.  
  11. #include "mcu_regs.h"
  12. #include "type.h"
  13. #include "uart.h"
  14. #include "stdio.h"
  15.  
  16. #include "i2c.h"
  17. #include "gpio.h"
  18. #include "ssp.h"
  19. #include "adc.h"
  20. #include "light.h"
  21. #include "oled.h"
  22. #include "temp.h"
  23. #include "acc.h"
  24.  
  25. #include "myTimer.h"
  26. #include "joystick.h"
  27. #include "diskio.h"
  28. #include "ff.h"
  29.  
  30. #include "mySSP.h"
  31. #include "diskio.h"
  32. #include "ff.h"
  33.  
  34.  
  35. static uint32_t msTicks = 0;                    // Número de Ticks
  36. static uint8_t buf[10];                         // Buffer de retorno da função intToString()                                        
  37. volatile uint8_t valorbotao = 0;                // Inicializa o botão como não apertado
  38.  
  39.  
  40. ///////////////////////FUNÇÃO PARA CONVERTER UM INTEIRO EM UMA STRING/////////////////////////////
  41.  
  42. static void intToString(int value, uint8_t* pBuf, uint32_t len, uint32_t base)
  43. {
  44.     static const char* pAscii = "0123456789abcdefghijklmnopqrstuvwxyz";
  45.     int pos = 0;
  46.     int tmpValue = value;
  47.  
  48.     // the buffer must not be null and at least have a length of 2 to handle one
  49.     // digit and null-terminator
  50.     if (pBuf == NULL || len < 2)
  51.     {
  52.         return;
  53.     }
  54.  
  55.     // a valid base cannot be less than 2 or larger than 36
  56.     // a base value of 2 means binary representation. A value of 1 would mean only zeros
  57.     // a base larger than 36 can only be used if a larger alphabet were used.
  58.     if (base < 2 || base > 36)
  59.     {
  60.         return;
  61.     }
  62.  
  63.     // negative value
  64.     if (value < 0)
  65.     {
  66.         tmpValue = -tmpValue;
  67.         value    = -value;
  68.         pBuf[pos++] = '-';
  69.     }
  70.  
  71.     // calculate the required length of the buffer
  72.     do {
  73.         pos++;
  74.         tmpValue /= base;
  75.     } while(tmpValue > 0);
  76.  
  77.  
  78.     if (pos > len)
  79.     {
  80.         // the len parameter is invalid.
  81.         return;
  82.     }
  83.  
  84.     pBuf[pos] = '\0';
  85.  
  86.     do {
  87.         pBuf[--pos] = pAscii[value % base];
  88.         value /= base;
  89.     } while(value > 0);
  90.  
  91.     return;
  92.  
  93. }
  94.  
  95. /////////////////////////////////////HANDLE DO SYSTICK/////////////////////////////////////////////
  96.  
  97. void SysTick_Handler(void) {
  98.     msTicks++;
  99.     disk_timerproc();
  100. }
  101.  
  102. static uint32_t getTicks(void)
  103. {
  104.     return msTicks;
  105. }
  106. ///////////////////////////ESTRUTURA QUE RECEBE O VALOR DOS SENSORES///////////////////////////////
  107.  
  108. typedef struct Sensores{
  109.     int8_t x;
  110.     int8_t y;
  111.     int8_t z;
  112.     uint32_t temp;
  113.     uint32_t lux;
  114. }T_Sensores;
  115.  
  116. struct Sensores sensores;
  117.  
  118. ///////////////////FUNÇÃO PARA SINALIZAR QUAL O TEMPO DE ATUALIZAÇÃO (SD e OLED)///////////////////
  119.  
  120. void sinalizar_tempo(int tempo_atualizacao, int display){
  121.   if(display == 0){                                        // Se não for para sinalizar o tempo de atualização do display
  122.       switch(tempo_atualizacao){                           // Vamos sinalizar o tempo de escrita no SD
  123.         case 500:                                          // Se o tempo for 500ms
  124.             pca9532_setLeds(0x0001,0xffff);                // Acende 1 LED vermelho
  125.             break;
  126.         case 1000:                                         // Se passo for 1000ms
  127.             pca9532_setLeds(0x0003,0xffff);                // Acende 2 LEDs vermelhos
  128.             break;
  129.         case 1500:                                         // Se passo for 1500ms
  130.             pca9532_setLeds(0x0007,0xffff);                // Acende 3 LEDs vermelhos
  131.             break;    
  132.         case 2000:                                         // Se passo for 2000ms
  133.             pca9532_setLeds(0x000f,0xffff);                // Acende 4 LEDs vermelhos
  134.             break;
  135.         case 2500:                                         // Se passo for 2500ms
  136.             pca9532_setLeds(0x001f,0xffff);                // Acende 5 LEDs vermelhos
  137.             break;
  138.         case 3000:                                         // Se passo for 3000ms
  139.             pca9532_setLeds(0x003f,0xffff);                // Acende 6 LEDs vermelhos
  140.             break;
  141.         case 3500:                                         // Se passo for 3500ms
  142.             pca9532_setLeds(0x007f,0xffff);                // Acende 7 LEDs vermelhos
  143.             break;
  144.         case 4000:                                         // Se passo for 4000ms
  145.             pca9532_setLeds(0x00ff,0xffff);                // Acende 8 LEDs vermelhos
  146.             break;
  147.         default:                                          
  148.             break;
  149.       }
  150.   }else{
  151.       switch(tempo_atualizacao){                          // Se for para sinalizar o tempo de atualização do display
  152.         case 500:                                        
  153.             pca9532_setLeds(0x8000,0xffff);               // Se o tempo for 500ms
  154.             break;                                        // Acende 1 LED verde
  155.         case 1000:                                        
  156.             pca9532_setLeds(0xc000,0xffff);               // Se passo for 1000ms
  157.             break;                                        // Acende 2 LEDs verdes
  158.         case 1500:                                        
  159.             pca9532_setLeds(0xe000,0xffff);               // Se passo for 1500ms
  160.             break;                                        // Acende 3 LEDs verdes
  161.         case 2000:                                        
  162.             pca9532_setLeds(0xf000,0xffff);               // Se passo for 2000ms
  163.             break;                                        // Acende 4 LEDs verdes
  164.         case 2500:                                        
  165.             pca9532_setLeds(0xf800,0xffff);               // Se passo for 2500ms
  166.             break;                                        // Acende 5 LEDs verdes
  167.         case 3000:                                        
  168.             pca9532_setLeds(0xfc00,0xffff);               // Se passo for 3000ms
  169.             break;                                        // Acende 6 LEDs verdes
  170.         case 3500:                                        
  171.             pca9532_setLeds(0xfe00,0xffff);               // Se passo for 3500ms
  172.             break;                                        // Acende 7 LEDs verdes
  173.         case 4000:                                        
  174.             pca9532_setLeds(0xff00,0xffff);               // Se passo for 4000ms
  175.             break;                                        // Acende 8 LEDs verdes
  176.         default:                                          
  177.             break;
  178.       }
  179.   }
  180. }
  181.  
  182. ///////////////////LÊ DO ARQUIVO DE CONFIGURAÇÃO DO CARTÃO SD O TEMPO DE ATUALIZAÇÃO DO OLEO E DE GRAVAÇÃO NO SD///////////////////
  183.  
  184. void ler_tempo_arquivo_config(char *line, char *line2, int *tempo_amostragem_ms , int *tempo_atualizacao_display){
  185.      
  186.     switch (line[0]){                                   // Compara o primeiro caracter da primeira linha do arquivo de configuração
  187.       case '5':                                         // Se o primeiro caracter for 5                
  188.           *tempo_amostragem_ms = 500;                   // O tempo de gravação do cartão SD é de 500ms
  189.       break;  
  190.      
  191.       case '1':                                         // Se o primeiro caracter for 1, temos que ver se o segundo caracter é 0 ou 5              
  192.           if(line[1] == '0'){                           // Se for 0
  193.               *tempo_amostragem_ms = 1000;              // O tempo de gravação do cartão SD é de 1000ms
  194.           }else{                                        // Senão
  195.               *tempo_amostragem_ms = 1500;              // O tempo de gravação do cartão SD é de 1500ms        
  196.           }
  197.       break;  
  198.      
  199.       case '2':                                         // Se o primeiro caracter for 2, temos que ver se o segundo caracter é 0 ou 5  
  200.           if(line[1] == '0'){                           // Se for 0
  201.               *tempo_amostragem_ms = 2000;              // O tempo de gravação do cartão SD é de 2000ms
  202.           }else{                                        // Senão
  203.               *tempo_amostragem_ms = 2500;              // O tempo de gravação do cartão SD é de 2500ms        
  204.           }
  205.       break;  
  206.      
  207.       case '3':                                         // Se o primeiro caracter for 3, temos que ver se o segundo caracter é 0 ou 5  
  208.           if(line[1] == '0'){                           // Se for 0
  209.               *tempo_amostragem_ms = 3000;              // O tempo de gravação do cartão SD é de 3000ms
  210.           }else{                                        // Senão
  211.               *tempo_amostragem_ms = 3500;              // O tempo de gravação do cartão SD é de 3500ms        
  212.           }
  213.       break;
  214.      
  215.       case '4':                                         // Se o primeiro caracter for 4              
  216.           *tempo_amostragem_ms = 4000;                  // O tempo de gravação do cartão SD é de 4000ms
  217.       break;  
  218.    
  219.     }
  220.  
  221.     switch (line2[0]){                                  // Compara o primeiro caracter da segunda linha do arquivo de configuração
  222.       case '5':                                         // Se o primeiro caracter for 5                
  223.           *tempo_atualizacao_display = 500;             // O tempo de atualização do display OLED é de 500ms
  224.       break;                                            
  225.                                                        
  226.       case '1':                                         // Se o primeiro caracter for 1, temos que ver se o segundo caracter é 0 ou 5
  227.           if(line2[1] == '0'){                          // Se for 0
  228.               *tempo_atualizacao_display = 1000;        // O tempo de atualização do display OLED é de 1000ms
  229.           }else{                                        // Senão
  230.               *tempo_atualizacao_display = 1500;        // O tempo de atualização do display OLED é de 1500ms        
  231.           }                                            
  232.       break;                                            
  233.                                                        
  234.       case '2':                                         // Se o primeiro caracter for 2, temos que ver se o segundo caracter é 0 ou 5
  235.           if(line2[1] == '0'){                          // Se for 0
  236.               *tempo_atualizacao_display = 2000;        // O tempo de atualização do display OLED é de 2000ms
  237.           }else{                                        // Senão
  238.               *tempo_atualizacao_display = 2500;        // O tempo de atualização do display OLED é de 2500ms        
  239.           }                                            
  240.       break;                                            
  241.                                                        
  242.       case '3':                                         // Se o primeiro caracter for 3, temos que ver se o segundo caracter é 0 ou 5
  243.           if(line2[1] == '0'){                          // Se for 0
  244.               *tempo_atualizacao_display = 3000;        // O tempo de atualização do display OLED é de 3000ms
  245.           }else{                                        // Senão
  246.               *tempo_atualizacao_display = 3500;        // O tempo de atualização do display OLED é de 3500ms        
  247.           }                                            
  248.       break;                                            
  249.                                                        
  250.       case '4':                                         // Se o primeiro caracter for 4              
  251.           *tempo_atualizacao_display = 4000;            // O tempo de atualização do display OLED é de 4000ms
  252.       break;  
  253.    
  254.     }
  255. }
  256.  
  257.  
  258. static FILINFO Finfo;                                   // Variáveis da FatFS
  259. static FATFS Fatfs[1];                                  // Variáveis da FatFS
  260.  
  261.  
  262. ///////////////////HANDLE DO PORT2 - ROTINA DE TRATAMENTO DE INTERRUPÇÃO DO BOTÃO SW3///////////////////
  263.  
  264. void PIOINT2_IRQHandler(void)
  265. {
  266.   uint32_t regVal;
  267.  
  268.   regVal = GPIOIntStatus( PORT2, 9 );                   // Recebe o status da interrupção do pino 9 do PORT2
  269.   if ( regVal )                                         // Se ocorreu a interrupção
  270.   {
  271.         GPIOIntClear( PORT2, 9 );                       // Limpa o flag de interrupção
  272.         valorbotao = 1;                                 // Seta o botão como pressionado
  273.   }    
  274.   return;
  275. }
  276.  
  277. FATFS FatFs;                                            // Variáveis da FatFS
  278.  
  279. int main (void)
  280. {
  281.    
  282.     ////////////////*INICIALIZAÇÕES/////////////////
  283.    
  284.     SystemCoreClockUpdate();  
  285.     GPIOInit();
  286.     init_myTimer(0);
  287.     I2CInit( (uint32_t)I2CMASTER, 0x3c );
  288.     SSPInit();
  289.     oled_init();
  290.     light_init();
  291.     acc_init();
  292.     joystick_init();
  293.     temp_init (&getTicks);
  294.     light_enable();
  295.     light_setRange(LIGHT_RANGE_4000);
  296.    
  297.     ////////////////////////////////////////////////
  298.  
  299.     int tempo_amostragem_ms = 0;                        // Inicia o tempo de gravação dos dados do cartão SD como 0
  300.     int tempo_atualizacao_display = 0;                  // Inicia o tempo de atualização do display OLED como 0
  301.    
  302.     T_Sensores *p_sensor = (T_Sensores*) &sensores;     // Pointer Casting para os sensores
  303.    
  304.     int32_t xoff = 0;                                   // Inicia o offset do acelerometro em relação ao eixo x como 0
  305.     int32_t yoff = 0;                                   // Inicia o offset do acelerometro em relação ao eixo y como 0
  306.     int32_t zoff = 0;                                   // Inicia o offset do acelerometro em relação ao eixo z como 0        
  307.  
  308.     p_sensor->x = 0;                                    // Inicia o valor do eixo x do acelerometro como 0
  309.     p_sensor->y = 0;                                    // Inicia o valor do eixo y do acelerometro como 0
  310.     p_sensor->z = 0;                                    // Inicia o valor do eixo z do acelerometro como 0        
  311.  
  312.     p_sensor->temp = 0;                                 // Inicia o valor da temperatura como 0
  313.     p_sensor->lux = 0;                                  // Inicia o valor da luminosidade como 0
  314.  
  315.    
  316.     ////////// Inicia o SysTick, utilizado pelo sensor de temperatura //////////
  317.    
  318.     SysTick_Config(SystemCoreClock / 1000);                     // Inicia o SysTick, utilizado pelo sensor de temperatura
  319.     if ( !(SysTick->CTRL & (1<<SysTick_CTRL_CLKSOURCE_Msk)) )
  320.     {
  321.       LPC_SYSCON->SYSTICKCLKDIV = 0x08;                         // Divisor do clock do SysTick
  322.     }
  323.  
  324.     ////////////////////////////////////////////////////////////////////////////
  325.  
  326.     acc_read(&p_sensor->x, &p_sensor->y, &p_sensor->z);         // Lê os valores do acelerometro
  327.     xoff = 0-p_sensor->x;                                       // Calcula o offset em x
  328.     yoff = 0-p_sensor->y;                                       // Calcula o offset em y
  329.     zoff = 64-p_sensor->z;                                      // Calcula o offset em z
  330.  
  331.    
  332.     ///////////////// Coloca no display OLED as strings que serão fixas //////////////  
  333.    
  334.     oled_clearScreen(OLED_COLOR_WHITE);                                                 // Limpa a tela
  335.     oled_putString(1,17,  (uint8_t*)"Temp   : ", OLED_COLOR_BLACK, OLED_COLOR_WHITE);   // Escreve a string Temp na terceira linha
  336.     oled_putString(1,25, (uint8_t*)"Acc x  : ", OLED_COLOR_BLACK, OLED_COLOR_WHITE);    // Escreve a string Acc x na quarta linha
  337.     oled_putString(1,33, (uint8_t*)"Acc y  : ", OLED_COLOR_BLACK, OLED_COLOR_WHITE);    // Escreve a string Acc y na quinta linha
  338.     oled_putString(1,41, (uint8_t*)"Acc z  : ", OLED_COLOR_BLACK, OLED_COLOR_WHITE);    // Escreve a string Acc z na sexta linha
  339.     oled_putString(1,49,  (uint8_t*)"Light  : ", OLED_COLOR_BLACK, OLED_COLOR_WHITE);   // Escreve a string Light na sétima linha        
  340.    
  341.     //////////////////////////////////////////////////////////////////////////////////
  342.    
  343.     int flagbotao = 1;                                  // Flag para ver se devemos pausar ou não a aquisição dos dados
  344.     int contador_amostras = 0;                          // Contador de quantas leituras dos sensores já foram realizadas
  345.     int offset_config = 0;                              // Offset necessário para ler dados do arquivo de configuração
  346.    
  347.     FIL fil;                                            // File object do arquivo em que serão escritos os dados dos sensores
  348.     FIL fil_config;                                     // File object do arquivo de configuração
  349.     char line[100];                                     // Para para receber a primeira linha do cartãod e configuração
  350.     char line2[100];                                    // Para para receber a segunda linha do cartãod e configuração
  351.     FRESULT fr;                                         // Usada para receber código de retorno do FatFS
  352.     DSTATUS stat;                                       // Usada para receber código de retorno do FatFS
  353.     BYTE res;                                           // Usada para receber código de retorno do FatFS
  354.     DIR dir;                                            // Usada para receber código de retorno do FatFS
  355.     int file_offset = 0;                                // Offset necessário para não sobrescrever os dados dos sensores no arquivo do cartão SD
  356.     int bytes_write = 0;                                // Número de bytes escrito no cartão SD
  357.    
  358.     stat = disk_initialize(0);                          // Inicialização o cartão SD
  359.    
  360.     res = f_mount(0, &Fatfs[0]);                        // Registra a área de trabalho do SD
  361.     if (res != FR_OK) {                                 // Vê se não houve nenhum erro        
  362.         return 1;
  363.     }
  364.  
  365.     res = f_opendir(&dir, "/");                         // Abre um diretório
  366.     if (res) {                                          // Vê se não houve nenhum erro
  367.         return 1;
  368.     }
  369.  
  370.    
  371.     fr = f_open(&fil_config, "conf.txt", FA_READ);      // Abre o arquivo de configuração
  372.     if (fr != FR_OK) return 1;                          // Vê se não houve nenhum erro
  373.     f_gets(line, sizeof line, &fil_config);             // Lê a primeira linha do arquivo de configuração e salva em line
  374.     if (line[0] == '5'){                                // Esse if é para corrigir eventuais erros de offset para ler a segunda linha
  375.         offset_config = 15;                             // Pois se o primeiro caracter for 5, significa que o valor lido será 500 e vai possuir 3 digitos
  376.     }else{                                              // Caso não for 5 o primeiro caracter, temos que o valor lido terá 4 digitos
  377.         offset_config = 16;                             // Então o offset deve ser incrementado de 1
  378.     }
  379.     res = f_lseek(&fil_config, offset_config);          // Move a posição do ponteiro do arquivo
  380.     f_gets(line2, sizeof line2, &fil_config);           // Lê a segunda linha do arquivo de configuração e salva em line2
  381.     ler_tempo_arquivo_config(line, line2, &tempo_amostragem_ms, &tempo_atualizacao_display);    // Retira das strings line e line2 (primeira e segunda linha do arquivo de configuração)
  382.                                                                                                 // o tempo de atualização do display e de gravação do cartão SD
  383.     f_close(&fil_config);                               // Fecha o arquivo      
  384.    
  385.     offset_config = 0;                                  // Zera o offset do arquivo de configuração (será utilizado na hora de reescrever os tempos com o joystick)
  386.    
  387.    
  388.     fr = f_open(&fil, "teste.txt", FA_WRITE | FA_OPEN_ALWAYS);          // Abre o arquivo onde serão salvos os dados dos sensores
  389.     if (fr != FR_OK) return 1;                                          // Vê se não houve nenhum erro        
  390.     bytes_write = f_printf(&fil, "<%dmseg>\r\n", tempo_amostragem_ms);  // Escreve o tempo de gravação do SD e salva quantas bytes foram escritos
  391.     file_offset = file_offset + bytes_write;                            // Atualiza o offset da gravação no cartão SD
  392.     f_close(&fil);                                                      // Fecha o arquivo      
  393.    
  394.    
  395.     GPIOIntEnable(PORT2, 9);                                            // Habilita a interrupção da SW3 (PORT 2 pino 9)
  396.     GPIOSetInterrupt(PORT2, 9, 0, 0, 1);                                // Configura a interrupção da SW3 (PORT 2 pino 9)
  397.    
  398.     oled_putString(1,1, line, OLED_COLOR_BLACK, OLED_COLOR_WHITE);      // Escreve a primeira linha lida do arquivo da configuração na primeira linha do OLED
  399.     oled_putString(1,9, line2, OLED_COLOR_BLACK, OLED_COLOR_WHITE);     // Escreve a segunda linha lida do arquivo da configuração na segunda linha do OLED
  400.  
  401.     while(1) {
  402.  
  403.         if (valorbotao == 1){                                           // Se o botão SW3 foi pressionado              
  404.           valorbotao = 0;                                               // Zera o flag de botão pressionado
  405.           flagbotao =  flagbotao*-1;                                    // Atualiza o flag que indica se devemos pausar ou não as aquisições
  406.         }
  407.      
  408.      
  409.         if(flagbotao > 0){                                              // Se não for para pausar
  410.            
  411.            
  412.            
  413.             ////////////////////////////// LEITURA DOS SENSORES///////////////////////////////////
  414.          
  415.             contador_amostras++;                                        // Incrementa o contador de leitura dos sensores
  416.            
  417.             /* Accelerometer */
  418.             acc_read(&p_sensor->x, &p_sensor->y, &p_sensor->z);         // Lê o acelerometro
  419.             p_sensor->x = p_sensor->x+xoff;                             // Atualiza o valor do eixo x do acelerometro
  420.             p_sensor->y = p_sensor->y+yoff;                             // Atualiza o valor do eixo y do acelerometro
  421.             p_sensor->z = p_sensor->z+zoff;                             // Atualiza o valor do eixo z do acelerometro
  422.  
  423.             /* Temperature */
  424.             p_sensor->temp = temp_read();                               // Lê o sensor de temperatura
  425.  
  426.             /* light */
  427.             p_sensor->lux = light_read();                               // Lê o sensor de luminosidade
  428.  
  429.          
  430.             ////////////////////////////// ESCRITA DOS DADOS NO CARTÃO SD//////////////////////////
  431.          
  432.             fr = f_open(&fil, "teste.txt", FA_WRITE);                                   // Abre o arquivo onde serão salvos os dados dos sensores
  433.             res = f_lseek(&fil, file_offset);                                           // Move a posição do ponteiro do arquivo                
  434.             bytes_write = f_printf(&fil, "(<%d> <%d> <%d> <%d> <%d> <%d>)\r\n",contador_amostras, p_sensor->temp, p_sensor->x, p_sensor->y, p_sensor->z, p_sensor->lux);  // Escreve os dados no SD e salva quantas bytes foram escritos
  435.             f_close(&fil);                                                              // Fecha o arquivo
  436.             file_offset = file_offset + bytes_write;                                    // Atualiza o offset da gravação no cartão SD (para não sobrescrever dados)
  437.            
  438.             pca9532_setLeds(0x00ff,0xffff);                                             // Acende todos os LEDs vermelhos
  439.             delayMs(0, tempo_amostragem_ms);                                            // Delay de acordo com o tempo de gravação no SD
  440.        
  441.             /////////////////////////// ESCRITA DOS DADOS NO DISPLAY OLED/////////////////////////
  442.          
  443.             intToString(p_sensor->temp/10, buf, 10, 10);                                  // Converter o valor do sensor de temperatura para string
  444.             oled_fillRect((1+9*6),17,90 , 24, OLED_COLOR_WHITE);                          // Limpa o valor antigo que estava no display (desenha um retângulo sobre ele)        
  445.             oled_putString((1+9*6),17, buf, OLED_COLOR_BLACK, OLED_COLOR_WHITE);          // Escreve o novo valor no display
  446.  
  447.             intToString(p_sensor->x, buf, 10, 10);                                        // Converter o valor do eixo x do acelerometro para string
  448.             oled_fillRect((1+9*6),25, 90, 32, OLED_COLOR_WHITE);                          // Limpa o valor antigo que estava no display (desenha um retângulo sobre ele)
  449.             oled_putString((1+9*6),25, buf, OLED_COLOR_BLACK, OLED_COLOR_WHITE);          // Escreve o novo valor no display
  450.  
  451.             intToString(p_sensor->y, buf, 10, 10);                                        // Converter o valor do eixo y do acelerometropara string
  452.             oled_fillRect((1+9*6),33, 90, 40, OLED_COLOR_WHITE);                          // Limpa o valor antigo que estava no display (desenha um retângulo sobre ele)
  453.             oled_putString((1+9*6),33, buf, OLED_COLOR_BLACK, OLED_COLOR_WHITE);          // Escreve o novo valor no display
  454.  
  455.             intToString(p_sensor->z, buf, 10, 10);                                        // Converter o valor do eixo z do acelerometro para string      
  456.             oled_fillRect((1+9*6),41, 90, 48, OLED_COLOR_WHITE);                          // Limpa o valor antigo que estava no display (desenha um retângulo sobre ele)
  457.             oled_putString((1+9*6),41, buf, OLED_COLOR_BLACK, OLED_COLOR_WHITE);          // Escreve o novo valor no display
  458.  
  459.             intToString(p_sensor->lux, buf, 10, 10);                                      // Converter o valor do sensor de luminosidade para string      
  460.             oled_fillRect((1+9*6),49, 90, 56, OLED_COLOR_WHITE);                          // Limpa o valor antigo que estava no display (desenha um retângulo sobre ele)
  461.             oled_putString((1+9*6),49, buf, OLED_COLOR_BLACK, OLED_COLOR_WHITE);          // Escreve o novo valor no display
  462.            
  463.             pca9532_setLeds(0xff00,0xffff);                                               // Acende todos os LEDs verdes      
  464.             delayMs(0, tempo_atualizacao_display);                                        // Delay de acordo com o tempo de atualização do display
  465.              
  466.         }
  467.        
  468.         while(flagbotao < 0 ){                                                  // Se for para pausar                  
  469.              
  470.               sinalizar_tempo(tempo_amostragem_ms, 0);                          // Sinaliza o tempo de escrita no SD nos LEDs vermelhos
  471.               sinalizar_tempo(tempo_atualizacao_display, 1);                    // Sinaliza o tempo de atualização do display nos LEDs verdes
  472.              
  473.               switch(joystick_read()){                                          // Lê o joystick
  474.                   case JOYSTICK_LEFT:                                           // Se for para esqueda
  475.                       tempo_amostragem_ms = tempo_amostragem_ms - 500;          // Diminui o tempo de escrita no cartão SD
  476.                       if(tempo_amostragem_ms <= 0){                            
  477.                           tempo_amostragem_ms = 500;                            // Limita valor mín em 500ms        
  478.                       }
  479.                       delayMs(0, 100);                                          // Delay anti-bounce
  480.                       sinalizar_tempo(tempo_amostragem_ms, 0);                  // Sinaliza o tempo de escrita no SD nos LEDs vermelhos      
  481.                       break;
  482.                  
  483.                   case JOYSTICK_RIGHT:                                          // Se for para direita
  484.                       tempo_amostragem_ms = tempo_amostragem_ms + 500;          // Aumenta o tempo de escrita no cartão SD
  485.                       if(tempo_amostragem_ms > 4000){                          
  486.                           tempo_amostragem_ms = 4000;                           // Limita valor max em 4000ms        
  487.                       }                                                        
  488.                       delayMs(0, 100);                                          // Delay anti-bounce
  489.                       sinalizar_tempo(tempo_amostragem_ms, 0);                  // Sinaliza o tempo de escrita no SD nos LEDs vermelhos    
  490.                       break;
  491.                  
  492.                   case JOYSTICK_CENTER:                                                                 // Se for pressionado o botão central
  493.                        
  494.                         fr = f_open(&fil_config, "conf.txt", FA_CREATE_ALWAYS | FA_WRITE | FA_READ);    // Abre o arquivo de configuração
  495.                         offset_config = f_printf(&fil_config, "%dmseg - TBK\r\n", tempo_amostragem_ms); // Escreve o novo tempo de escrita no cartão SD e salva quantos bytes foram escritos
  496.                         f_close(&fil_config);                                                           // Fecha o arquivo
  497.                        
  498.                         fr = f_open(&fil_config, "conf.txt", FA_CREATE_ALWAYS | FA_WRITE | FA_READ);    // Abre o arquivo de configuração
  499.                         res = f_lseek(&fil_config, offset_config);                                      // Move a posição do ponteiro do arquivo (para escrever na segunda linha)
  500.                         f_printf(&fil_config, "%dmseg - S11", tempo_atualizacao_display);               // Escreve o novo tempo de atualização do display OLED
  501.                         f_close(&fil_config);                                                           // Fecha o arquivo
  502.                        
  503.                         fr = f_open(&fil_config, "conf.txt", FA_READ);                                  // Abre o arquivo de configuração
  504.                         if (fr != FR_OK) return 1;                                                      // Vê se não houve nenhum erro
  505.                         f_gets(line, sizeof line, &fil_config);                                         // Lê a primeira linha do arquivo de configuração e salva em line
  506.                         res = f_lseek(&fil_config, offset_config);                                      // Move a posição do ponteiro do arquivo (para ler a segunda linha)
  507.                         f_gets(line2, sizeof line2, &fil_config);                                       // Lê a segunda linha do arquivo de configuração e salva em line2
  508.                         f_close(&fil_config);                                                           // Fecha o arquivo
  509.                                                                                                        
  510.                         oled_fillRect(1,1,95 , 8, OLED_COLOR_WHITE);                                    // Limpa a primeira linha do display (desenha um retângulo sobre ela)
  511.                         oled_putString(1,1, line, OLED_COLOR_BLACK, OLED_COLOR_WHITE);                  // Escreve a nova primeira linha do arquivo de config no display OLED
  512.                         oled_fillRect(1,9,95 , 16, OLED_COLOR_WHITE);                                   // Limpa a segunda linha do display (desenha um retângulo sobre ela)
  513.                         oled_putString(1,9, line2, OLED_COLOR_BLACK, OLED_COLOR_WHITE);                 // Escreve a nova segunda linha do arquivo de config no display OLED
  514.                        
  515.                         fr = f_open(&fil, "teste.txt", FA_WRITE | FA_OPEN_ALWAYS);                      // Abre o arquivo onde serão salvos os dados dos sensores
  516.                         if (fr != FR_OK) return 1;                                                      // Vê se não houve nenhum erro
  517.                         res = f_lseek(&fil, file_offset);                                               // Move a posição do ponteiro do arquivo
  518.                         bytes_write = f_printf(&fil, "<%dmseg> \r\n", tempo_amostragem_ms);             // Escreve o novo tempo de escrita no cartão SD
  519.                         f_close(&fil);                                                                  // Fecha o arquivo
  520.                         file_offset = file_offset + bytes_write;                                        // Atualiza o offset do ponteiro
  521.                        
  522.                       break;
  523.                      
  524.                  case JOYSTICK_DOWN:                                                     // Se for para baixo
  525.                       tempo_atualizacao_display = tempo_atualizacao_display - 500;       // Diminui o tempo de atualização do display
  526.                       if(tempo_atualizacao_display <= 0){                                
  527.                           tempo_atualizacao_display = 500;                               // Limita valor mín em 500ms        
  528.                       }                                                                  
  529.                       delayMs(0, 100);                                                   // Delay anti-bounce
  530.                       sinalizar_tempo(tempo_atualizacao_display, 1);                     // Sinaliza o tempo de atualização do display nos LEDs verdes    
  531.                       break;                                                            
  532.                                                                                          
  533.                   case JOYSTICK_UP:                                                      // Se for para cima
  534.                       tempo_atualizacao_display = tempo_atualizacao_display + 500;       // Aumenta o tempo de atualização do display
  535.                       if(tempo_atualizacao_display > 4000){                              
  536.                           tempo_atualizacao_display = 4000;                              // Limita valor max em 4000ms        
  537.                       }                                                                  
  538.                       delayMs(0, 100);                                                   // Delay anti-bounce
  539.                       sinalizar_tempo(tempo_atualizacao_display, 1);                     // Sinaliza o tempo de atualização do display nos LEDs verdes    
  540.                       break;
  541.                      
  542.                   default:                                                  
  543.                       break;
  544.               }
  545.              
  546.               if (valorbotao == 1){                                                     // Se o botão SW3 foi pressionado              
  547.                   valorbotao = 0;                                                       // Zera o flag de botão pressionado
  548.                   flagbotao =  flagbotao*-1;                                            // Atualiza o flag que indica que devemos despausar as aquisições
  549.               }
  550.         }
  551.        
  552.  
  553.  
  554.        
  555.        
  556.         /* delay */
  557.    
  558.     }
  559.  
  560. }
RAW Paste Data
Top