Foram realizados dois experimentos a bordo de veículos diferentes, como explicado no quarto capítulo. Estes experimentos permitiram comparar o comportamento dos motoristas e a intensidade dos eventos inerciais capturados nos diferentes veículos, particular e de transporte público (ônibus).
Na análise por quantidade de eventos, primeiramente cabe destacar que nos dois expe- rimentos, a quantidade de eventos gerados por aceleração é maior que a quantidade de eventos por giro, esta diferença de quantidades sugere que são mais perceptíveis as vibrações e mudan- ças de velocidade do que os balanços no interior dos veículos. Também pode se observar que quanto menor é a velocidade média do percurso, maior é a quantidade de eventos inerciais coletados. Os percursos com menor velocidade média são causados por congestão veicular no transito, ou seja, um ambiente de pare e siga.
Embora o comprimento dos percursos seja muito diferente entre o experimento 1 e 2 (36 km e 7 km respectivamente) pode se observar uma grande diferença entre a quantidade de eventos de aceleração e giro entre os dois tipos de veículos. O veículo particular, que percorreu quase 5 vezes mais distancia que os ônibus e atingiu velocidades mais altas gerou a metade de eventos de aceleração que o ônibus adaptado para cadeirantes, e um terço da quantidade de
eventos de aceleração que os ônibus convencionais. Em contrapartida, a quantidade de eventos de giro foi maior no veículo particular, isto é devido à topologia do percurso (como foi afirmado na análise por intensidade) e a diferença do comprimento dos veículos.
Na análise por intensidade não podem ser comparados os dois experimentos, pois são percursos, motoristas e veículos distintos.
A intensidade dos eventos de aceleração e giro para cada eixo no experimento 1, são similares, este resultado era o esperado sendo o mesmo motorista, percurso e veículo, as varia- ções existentes estão dadas pela quantidade variável de usuários na estrada em cada dia em que foi realizado o experimento.
Entre os três ônibus é possível realizar uma comparação utilizando a análise de intensi- dade, pois o transito e os veículos foram similares e o percurso foi igual. Foi demostrado que existe uma relação direta entre as frenagens e acelerações sobre o eixo X e os balanços em torno do eixo Y (ΩY), como aconteceu com o ônibus 5220. Igualmente existe uma relação entre a aceleração sobre o eixo Z, causados por lombadas e imperfeições no pavimento, e os balanços experimentados abordo do ônibus em torno do eixo X (ΩX), neste caso deve ser considerado que o ônibus 2110 possui uma altura e um sistema de suspensão (hidráulico) diferente dos ou- tros ônibus.
A análise por proximidade dos eventos apresentou os locais com maior número de ocor- rências, indiferentemente da variável física com que tinham sido geradas, esta analise poderia ser utilizada em futuros trabalhos para informar quais são os percursos que oferecem mais se- gurança para seus usuários, diferentemente dos percursos mais rápidos ou mais curtos forneci- dos atualmente por sistemas de navegação assistida.
Finalmente, pode se concluir que a ferramenta desenvolvida neste trabalho é um sistema embarcado que captura, armazena e transmite eventos inerciais relacionados com comporta- mentos inseguros no transito, utilizando tecnologia MEMS e técnicas de processamento de si- nal, resultando em baixo consumo energético, baixo custo e confiabilidade dos dados coletados.
8 BIBLIOGRAFIA
[1] R. Smart, R. E. Mann, J. Zhao e G. Stoduto, “Is road rage increasing? Results of a repeated survey,” Journal of Safety Research, pp. 195-201, 2005.
[2] R. Smart e R. Mann, “Deaths and injuries from road rage: Cases in Canadian newspapers,” Canadian Medical Association Journal, pp. 761-762, 2002.
[3] J. Boyle, S. Dienstfrey e A. Sothoron , “National Survey of Speeding and Other Unsafe Driving Actions Volume II: Driver Attitudes and Behavior,” National Highway Traffic Safety Administration, Washington, DC, 1998.
[4] Observatório Nacional de Segurança Viária, “Relatorio Anual 2013,” Observatório Nacional de Segurança Viária, 2013.
[5] D. Ornelas, “Impacto das Políticas Públicas na Redução de Acidentes de Trânsito no Brasil,” Dissertação de mestrado, Instituto Brasileiro de Mercado de Capitais, Rio de Janeiro, 2007.
[6] Occam, “Manual de Eco condução,” Instituto da Mobilidade e dos Transportes, Lisboa, 2010.
[7] J. P. DePasquale, S. E. Geller, W. S. Clarke e C. L. Littleton, “Measuring road rage Development of the Propensity for Angry Driving Scale,” Journal of Safety Research, vol. 32, pp. 1-16, 2000.
[8] K. Koch, “CNN Online Interactive,” 26 Agosto 1998. [Online]. Available: http://edition.cnn.com/US/9708/26/road.ignorance/.
[9] J. C. Castellanos e F. Fruett, “Embedded system to evaluate the passenger comfort in public transportation based on dynamical vehicle behavior with user's feedback,” Measurement, vol. 47, pp. 442-451, 2014.
[10] S. Boonmee e P. Tangamchit, “Portable reckless driving detection system,” Pattaya, 2009. [11] H. Gao, A. Yûce e J.-P. Thiran, “Detecting emotional stress from facial expressions for
driving safety,” Paris, 2014.
[12] M. Andrejašicˇ e I. Poberaj, “University of Ljubljana Department of physics,” March 2008. [Online]. Available: http://www.fmf.uni-lj.si/. [Acesso em 20 February 2014]. [13] A. Albarbar, S. Mekid, A. Starr e R. Pietruszkiewicz, “Suitability of MEMS
Accelerometers for Condition Monitoring: An experimental study,” Sensors, pp. 784-799, 2 February 2008.
[14] R. J. Noriega, “Prof. Robert Laughlin, Department of Physics, Stanford University,” 31
Outubro 2007. [Online]. Available:
http://large.stanford.edu/courses/2007/ph210/noriega1/. [Acesso em 8 Setembro 2015]. [15] O. J. Woodman, “An introduction to inertial navigation,” University of Cambridge
Computer Laboratory, 2007.
[16] T. Ozyagcilar, “Calibrating an eCompass in the Presence of Hard and Soft-Iron Interface,” Freescale Semiconductor Application Note, 2013.
[17] J. Lenz e A. S. Edelstein, “Magnetic sensor and their applications,” IEEE Sensors , vol. 6, pp. 631-649, 2006.
[18] Pulskamp, “PZT MEMS resonant Lorentz force magnetometer”. Estados Unidos Patente H01L 41/08, 5 January 2010.
[19] T. Ozyagcilar, “Implementing a Tilt-Compensated eCompass using Accelerometer and Magnetometer Sensors,” Freescale Semicondutor Application Note, 2013.
[20] U. Eklund e H. Gustavsson, “Architecting automotive product lines: Industrial practice,” Science of Computer Programming, vol. 78, nº 12, pp. 2347-2359, 2013.
[21] A. Noureldin, T. B. Karamat e J. Georgy, Fundamentals of Inertial Navigation, Satellite- based Positioning and their Integration, Springer, 2013.
[22] M. Grewall, L. Weill e A. Andrews, Global positioning systems, inertial navigation and integration, 2nd ed., New York: Wiley, 2007.
[23] J. Farrell, Aided navigation: GPS with high rate sensors, New York: McGraw-Hill, 2008. [24] Transportation Research Board, “The Safety Promise and Challenge of Automotive
Electronics: insights from unintended acceleration,” National Research Council of the National Academies, Washington D.C., 2012.
[25] S. Sarasini, “Electrifying the automotive industry: The geography and governance of R&D collaboration,” Environmental Innovation and Societal Transitions, 18 June 2014. [26] IT & ITS Planning Division, “Intelligent Transport Systems, The future of mobility,”
APÊNDICE A – Modo de condução defensiva
No Manual de direção defensiva publicado pelo Departamento Nacional de Trânsito (DENATRAN) os riscos e perigos no trânsito estão relacionados com: os veículos, os conduto- res e seu comportamento, as vias de trânsito e o ambiente, segue a descrição dos mesmos.
Veículo: Este dispõe de equipamentos e sistemas importantes para evitar ou diminuir acidentes, eles estão sujeitos a desgaste com o uso, isto pode prejudicar o seu próprio funcionamento comprometendo a segurança dos tripulantes. Os pneus, o cinto de segu- rança, a suspensão, direção, sistema de iluminação e freios devem ter uma manutenção periódica e preventiva.
O condutor e as vias de transito: A seguir é apresentada um conjunto de recomenda- ções para diminuir tanto o desgaste físico e mental do motorista quanto os riscos de acidentes, pois as falhas humanas são as causas de 75% dos acidentes segundo o Insti- tuto da Mobilidade e dos Transportes de Portugal (IMTT) e de 98% segundo o Obser- vatório Nacional de Segurança Viária (ONSV):
o Os limites de velocidade estabelecidos para cada via devem ser respeitados. Quanto maior a velocidade, menor é o tempo que se dispõe para tomar decisões frente a diferentes situações que podem ocorrer em um percurso.
o Para as curvas, recomenda-se diminuir a velocidade com antecedência, usando o freio e, se necessário, reduzir a marcha antes de iniciar o movimento do vo- lante. A curva deve ser feita com movimentos suaves e contínuos no volante acelerando gradativamente.
o Em uma direção segura devem ser evitadas as mudanças bruscas de velocidade. Estas mudanças podem ser evidenciadas nos declives, na ultrapassagem, estrei- tamentos, imperfeições ou cruzamentos de pista.
o A ultrapassagem deve ser feita exclusivamente nos trechos sinalizados, se a faixa do sentido contrário de fluxo estiver livre e levando em consideração a potência do próprio veículo e a velocidade daquele que vai à frente. Trafegar com veículos automotores no acostamento é proibido, porque isso pode causar acidentes com outros veículos parados ou atropelamentos de pedestres ou ciclis- tas.
o Nas imperfeiçoes da pista, a velocidade deve ser reduzida suavemente para evi- tar a perda do controle do veículo.
o A sinalização sempre deve ser respeitada, pois ela é projetada com base na en- genharia e no comportamento humano, independentemente das habilidades in- dividuais do condutor e do estado particular de conservação do veículo.
O ambiente: Algumas condições climáticas e naturais afetam as condições de segu- rança no trânsito, tais condições são: chuva, aquaplanagem ou hidroplanagem, neblina ou cerração, vento e condições de luz variáveis. Nestas condições devem ser adotadas algumas atitudes que garantam a segurança do próprio motorista e a dos demais usuários da via.
APÊNDICE B – Panorama de sistemas eletrônicos em transporte inteli-
gente
Até meados dos anos 70, os aparelhos de rádio, reprodutores de cassete e sistemas de ignição eram os dispositivos eletrônicos mais sofisticados disponíveis nos veículos de uso par- ticular. No final desta década, também foram introduzidos circuitos de estado sólido para me- lhorar o conforto do motorista, assim como surgiu a demanda por sistemas que melhorassem o nível das emissões de poluentes. Esta evolução resultou no início do uso de microprocessadores elementares que controlavam o tempo de ignição e a mistura entre ar e combustível [22]. Nos anos 80, o uso da eletrônica variava desde o controle de injetores de combustível até ar condi- cionado e para a década dos anos 90 o desafio foi introduzir veículos híbridos e completamente elétricos: carros, ônibus e caminhões. O primeiro passo nesse sentido foi dado pela Toyota em 1997, com o lançamento do primeiro carro híbrido produzido em série [23].
O sistema elétrico em carros, ônibus e caminhões é um sistema embarcado que possui diversas Unidades de Controle Eletrônico (ECU), cada uma com um microprocessador execu- tando tarefas diferentes. Estas ECUs controlam o funcionamento de todas as funções elétricas do veículo. Estima-se que os dispositivos eletrônicos acrescem entre 10 a 30% o preço dos veículos. Prevê-se de igual forma que 80% de todas as inovações automotivas esperadas no futuro sejam eletrônicas [18].
O sistema de transporte inteligente é definido pela Toyota, como aquele que exige inte- rações integradas entre as pessoas, os veículos e o ambiente de tráfego. Para isto, é preciso identificar os eventos e classificá-los analisando as causas, os riscos e a magnitude do dano. É possível reproduzir um evento com diferentes parâmetros, para estudar os momentos “antes e depois” da colisão, tornando possível preveni-lo. Este sistema também propõe uma rede de comunicação cooperativa entre veículos, onde permite reduzir o número de acidentes notifi- cando os outros motoristas das condições da estrada, a partir dos sensores instalados nos veícu- los, ou mesmo, na estrada [24].
APÊNDICE C – Cálculo da inclinação transversal e longitudinal baseado
na componente gravitacional
Na ausência de aceleração linear, a única aceleração medida pelo sensor, será o vetor do campo gravitacional da terra, 𝐺 = 9,81[𝑚 𝑠⁄ ]. 2
𝐺𝑟 = ( 0 0 𝑔 ) (C.1)
A aceleração do dispositivo, 𝐺𝑝, medida pelo sensor depois das três possíveis rotações
é descrita pela seguinte equação:
𝐺𝑝 = 𝑅𝑥(ф)𝑅𝑦(Ѳ)𝑅𝑧(Ѱ)𝐺𝑟 = 𝑅𝑥(ф)𝑅𝑦(Ѳ)𝑅𝑧(Ѱ) ( 0 0 𝑔 ) (C.2)
O balanço transversal e longitudinal é calculado multiplicando a equação anterior pela matriz inversa do rotacional. 𝑅𝑥(−ф)𝑅𝑦(−Ѳ)𝐺𝑝 = 𝑅𝑥(−ф)𝑅𝑦(−Ѳ) ( 𝐺𝑝𝑥 𝐺𝑝𝑦 𝐺𝑝𝑧 ) = 𝑅𝑧(Ѱ) (00 𝑔 ) (C.3)
𝐺𝑝𝑥, 𝐺𝑝𝑦, 𝐺𝑝𝑧, são as componentes vetoriais medidas pelo acelerômetro.
( 𝐶𝑜𝑠Ѳ 0 𝑆𝑖𝑛Ѳ 0 1 0 −𝑆𝑖𝑛Ѳ 0 𝐶𝑜𝑠Ѳ ) ( 1 0 0 0 𝐶𝑜𝑠ф −𝑆𝑖𝑛ф 0 𝑆𝑖𝑛ф 𝐶𝑜𝑠ф ) ( 𝐺𝑝𝑥 𝐺𝑝𝑦 𝐺𝑝𝑧 ) = (00 𝑔 ) (C.4) ( 𝐶𝑜𝑠Ѳ 𝑆𝑖𝑛Ѳ𝑆𝑖𝑛ф 𝑆𝑖𝑛Ѳ𝐶𝑜𝑠ф 0 𝐶𝑜𝑠ф −𝑆𝑖𝑛ф −𝑆𝑖𝑛Ѳ 𝐶𝑜𝑠Ѳ𝑆𝑖𝑛ф 𝐶𝑜𝑠ф𝐶𝑜𝑠Ѳ ) ( 𝐺𝑝𝑥 𝐺𝑝𝑦 𝐺𝑝𝑧 ) = (00 𝑔 ) (C.5) 𝐺𝑝𝑦𝐶𝑜𝑠ф − 𝐺𝑝𝑧𝑆𝑖𝑛ф = 0 (C.6) Rotação (𝑟𝑜𝑙𝑙): 𝑡𝑎𝑛ф =𝐺𝑝𝑦 𝐺𝑝𝑧 (C.7) 𝐺𝑝𝑥𝐶𝑜𝑠Ѳ + 𝐺𝑝𝑦𝑆𝑖𝑛Ѳ𝑆𝑖𝑛ф + 𝐺𝑝𝑧𝑆𝑖𝑛Ѳ𝐶𝑜𝑠ф = 0 (C.8) 𝑃𝑖𝑡𝑐ℎ: 𝑡𝑎𝑛Ѳ = −𝐺𝑝𝑥 𝐺𝑝𝑦𝑆𝑖𝑛ф + 𝐺𝑝𝑧𝐶𝑜𝑠ф (C.9)
APÊNDICE D – Firmware do SMI
A seguir são apresentadas as rotinas, em linguagem C, com que foram realizados os experimentos, nos comentários é explicitado o comportamento/função das mesmas.
/*********************************************************************************** ***
* Nome do Arquivo: app.c *
* Criado em: Sep 18, 2014 * Autor: Juan Diego Díaz López * Unicamp - DSIF * *********************************************************************************** **/ #include <math.h> #include <stdio.h> #include <string.h> #include <stdlib.h>
#include "Cpu.h" //header de configuração do processador #include "Events.h" //header de interrupções
#include "app.h" //header de programação modular
#include "I2C2.h" //header de configuração da comunicação I2C #include "ringo.h" //header do buffer circular de transmissão serial #include "WAIT1.h" //header de configuração do timer de uso geral #include "AS1.h" //header de configuração da comunicação serial #include "LEDR.h" //GPIO LED vermelho
#include "LEDG.h" //GPIO LED verde
#include "FAT1.h" //Configuração bloco de dados tipo FAT #define PI 3.14159265 //constante global π
uint8 sUARTOutputBuf[256]; // Buffer tipo vetor para envio de informação static Iner_T deviceData; //Estrutura de dados para dispositivos inerciais static int8_t xyz[3]; //Estrutura de dados para leitura X, Y, Z static int mag[6]; //Estrutura de dados para leitura do magnetômetro H/L static FATFS fs; //Estrutura para dados cartão de memoria static FIL fp; //Estrutura para dados cartão de memoria /*********************************************************************************** ***
* Nome da função: getgps
* Descrição: Módulo para filtrar sentencia de NMEA * Parâmetros: String proveniente do modulo GPS *
*********************************************************************************** **/
void getgps(char buf_pos[80]) {
unsigned int e=0,j=0; unsigned char ch;
if (ringo_NofElements()!=0) { while (ringo_NofElements()!=0) {
(void)ringo_Get(&ch);
if (ch=='R')e=2; if (ch=='M' && e==2)e=4;
if (ch=='C' && e==4)e=6;
if(e==6 && ch=='$'){ //indicador de próxima sentencia e=0; j=0; } if(e==6){ buf_pos[j]=ch; j++; }}}} /*********************************************************************************** ***
* Nome da função: UARTSendChar
* Descrição: Módulo para envio de caracteres via UART * Parâmetros: Caracteres a enviar e estrutura de dados *
*********************************************************************************** **/
void UARTSendChar(unsigned char ch, Iner_T *desc) { desc->isSent = FALSE;
while(UART_SendBlock(desc->handleu, (LDD_TData*)&ch, 1)!=ERR_OK) {} while(!desc->isSent) {}
}
/*********************************************************************************** ***
* Nome da função: UARTSendString
* Descrição: Módulo para envio de string via UART * Parâmetros: String a enviar e estrutura de dados *
*********************************************************************************** **/
void UARTSendString(const unsigned char *str, Iner_T *desc) { while(*str!='\0') {
UARTSendChar(*str++, desc); }}
/*********************************************************************************** ***
* Nome da função: BlueRadios_Init
* Descrição: Módulo para inicialização módulo bluetooth * Parâmetros: Estrutura lógica do dispositivo
*
*********************************************************************************** **/
void BlueRadios_Init(LDD_TDeviceData *DeviceDataPtr) {
// transmit "ATSRM,2,0\r" // 2: response mode at to minimal
// 0: disconnected mode is command mode // \r: carriage return escape sequence
UARTSendString((unsigned char*)"ATSRM,2,0\r", &deviceData);
while(UART_ReceiveBlock(deviceData.handleu, (LDD_TData *)&deviceData.rxChar, sizeof(device- Data.rxChar))!=ERR_OK){}
// UARTSendString((unsigned char*)"AT+NAME", &deviceData);
//while(UART_ReceiveBlock(deviceData.handleu, (LDD_TData *)&deviceData.rxChar, sizeof(device- Data.rxChar))!=ERR_OK){}
// UARTSendString((unsigned char*)"JUAN", &deviceData);
// while(UART_ReceiveBlock(deviceData.handleu, (LDD_TData *)&deviceData.rxChar, sizeof(deviceData.rxChar))!=ERR_OK){}
return; }
/*********************************************************************************** ***
* Nome da função: gethour
* Descrição: Módulo para filtrar hora de NMEA
* Parâmetros: String NMEA, string vazio de 10 posições *
*********************************************************************************** **/
void gethour (char pos[80],char hour[10]) { int vir=0,i=0,c=0; hour[0]=NULL; for(i=0;i<=7;i++){ if (vir==1){ hour[c]=pos[i]; c++; } if (c==6){ hour[c]=NULL;//'.'; c++; } if (pos[i]==',') {
vir++; //contador de virgulas }
} }
/*********************************************************************************** ***
* Nome da função: getdata
* Descrição: Módulo para filtrar data de NMEA
* Parâmetros: String NMEA, string vazio de 10 posições *
*********************************************************************************** **/
void getdata (char pos[80],char hour[10]) { int vir=0,i=0,c=0;
hour[0]=NULL; for(i=0;i<=60;i++){
if (vir==9){
c++; } if (c==6){ hour[c]=NULL;//'.'; c++; } if (pos[i]==',') {
vir++; //contador de virgulas }
} }
/*********************************************************************************** ***
* Nome da função: getspeed
* Descrição: Módulo para filtrar velocidade de NMEA * Parâmetros: String NMEA, string vazio de 6 posições *
*********************************************************************************** **/
void getspeed (char pos[80],char hour[6]) { int vir=0,i=0,c=0; hour[0]=NULL; for(i=0;i<=60;i++){ if (vir==7){ hour[c]=pos[i]; c++; } if (c==5){ hour[c]=NULL; c++; } if (pos[i]==',') { vir++; } } } /*********************************************************************************** ***
* Nome da função: getpos
* Descrição: Módulo para filtrar posição de NMEA * Parâmetros: String NMEA, string vazio de 25 posições *
*********************************************************************************** **/
void getpos (char pos[80],char posG[25]) { char hour[10],data[10]; hour[0]=NULL; data[0]=NULL; posG[0]=NULL; int vir=0,i=0,c=0; for(i=0;i<=40;i++){
if (pos[i]==',') vir++; //Contador de virgulas if ((vir==3 || vir==5)&& c>0 && pos[i]!='.'){
posG[c]=pos[i]; c++;
}
if ((vir==3 || vir==5) && (c==0 || c==11)){
posG[c]='-'; //Norte/sul , este/oeste c++; } if (c==3 || c==15){ posG[c]='.'; c++; } if (vir==6){ posG[c]=NULL; c++; }} if(pos[13]=='V') {
LEDR_Off(); //indicador LED enlace GPS LEDG_Off();
}
if(pos[13]=='A'){
gethour (pos,hour); int hora= atoi(hour);
hora=hora/10000;
int minuto=(atoi(hour)-hora*10000)/100;
int segundo=(atoi(hour)-hora*10000-minuto*100); if(TmDt1_SetTime(hora, minuto, segundo,0)!=ERR_OK){ }
getdata(pos,data); int dia= atoi(data);
dia=dia/10000; int mes=(atoi(data)-dia*10000)/100; uint16_t anho=(atoi(data)-dia*10000-mes*100)+2000; if(TmDt1_SetDate(anho,mes,dia)!=ERR_OK){ LEDR_Neg();WAIT1_Waitms(200); } LEDG_On(); LEDR_Off(); } }
uint8_t I2CReadReg(uint8_t addr, uint8_t *data, short dataSize) { uint8_t res;
res = I2C2_MasterSendBlock(deviceData.handle, &addr, 1U, LDD_I2C_NO_SEND_STOP); if (res!=ERR_OK) {
return ERR_FAILED; }
while (!deviceData.dataTransmittedFlg) {} /* Wait until data is sent */ deviceData.dataTransmittedFlg = FALSE;
res = I2C2_MasterReceiveBlock(deviceData.handle, data, dataSize, LDD_I2C_SEND_STOP); if (res!=ERR_OK) {
return ERR_FAILED; }
while (!deviceData.dataReceivedFlg) {} /* Wait until data is received received */ deviceData.dataReceivedFlg = FALSE;
return ERR_OK; }
uint8_t I2CWriteReg(uint8_t addr, uint8_t val) { uint8_t buf[2], res;
buf[0] = addr; buf[1] = val;
res = I2C2_MasterSendBlock(deviceData.handle, &buf, 2U, LDD_I2C_SEND_STOP); if (res!=ERR_OK) {
return ERR_FAILED; }
while (!deviceData.dataTransmittedFlg) {} /* Wait until date is sent */ deviceData.dataTransmittedFlg = FALSE;
return ERR_OK; }
uint8_t I2CReadReg9x(uint8_t addr, int *data, short dataSize) { //Modulo de leitura I2C uint8_t res;
res = I2C0_MasterSendBlock(deviceData.handle9x, &addr, 1U, LDD_I2C_NO_SEND_STOP); if (res!=ERR_OK) {
return ERR_FAILED; }
while (!deviceData.dataTransmittedFlg9x) {} /* Wait until data is sent */ deviceData.dataTransmittedFlg9x = FALSE;
res = I2C0_MasterReceiveBlock(deviceData.handle9x, data, dataSize, LDD_I2C_SEND_STOP); if (res!=ERR_OK) {
return ERR_FAILED; }
while (!deviceData.dataReceivedFlg9x) {} /* Wait until data is received received */ deviceData.dataReceivedFlg9x = FALSE;
return ERR_OK; }
uint8_t I2CWriteReg9x(uint8_t addr, uint8_t val) { uint8_t buf[2], res;
buf[0] = addr; buf[1] = val;
res = I2C0_MasterSendBlock(deviceData.handle9x, &buf, 2U, LDD_I2C_SEND_STOP); if (res!=ERR_OK) {
return ERR_FAILED; }
while (!deviceData.dataTransmittedFlg9x) {} /* Wait until date is sent */ deviceData.dataTransmittedFlg9x = FALSE;
return ERR_OK; }
/*********************************************************************************** * Nome da função: LogToFile
* Descrição: Módulo para criação do arquivo e processo de escrita da informação * Parâmetros: rumo magnético, vetor de aceleração, vetor de velocidade angular, sina- * lizador de tipo de evento, valor máximo de aceleração ( X, Y e Z), valor máximo de velo-
* cidade angular (X,Y e Z) *
***********************************************************************************/ static void LogToFile(int n, char a[2410], char g[2410],int bandera,int max,int may,int maz, int mgx,int mgy,int mgz) {
uint8_t write_buf[5300]; UINT bw;
TIMEREC time; DATEREC fecha;
char bufpos[80], pos[25], name[15], fecha1[10], hour1[10], velo[6]; bufpos[0]=NULL; pos[0]=NULL; hour1[0]=NULL; fecha1[0]=NULL; velo[0]=NULL; getgps(bufpos); getpos(bufpos,pos); gethour(bufpos,hour1); getdata(bufpos,fecha1); getspeed(bufpos,velo); if (TmDt1_GetTime(&time)!=ERR_OK) { } // write data write_buf[0] = NULL;
UTIL1_strcat(write_buf, sizeof(write_buf),(unsigned char*) "H:"); UTIL1_strcatNum8u(write_buf, sizeof(write_buf), n);
UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)"\r\n"); UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)"P:"); UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)pos); UTIL1_chcat(write_buf, sizeof(write_buf), '\t');
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), time.Hour); UTIL1_chcat(write_buf, sizeof(write_buf), ':');
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), time.Min); UTIL1_chcat(write_buf, sizeof(write_buf), ':');
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), time.Sec);
UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)hour1); UTIL1_chcat(write_buf, sizeof(write_buf), '\t');
UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)fecha1); if (TmDt1_GetDate(&fecha)==ERR_OK) {
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), fecha.Day); UTIL1_chcat(write_buf, sizeof(write_buf), ':');
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), fecha.Month); UTIL1_chcat(write_buf, sizeof(write_buf), ':');
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), fecha.Year); UTIL1_chcat(write_buf, sizeof(write_buf), '\t');
}
if (TmDt1_GetDate(&fecha)!=ERR_OK) {
UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)"NO DATA"); }
UTIL1_strcat(write_buf, sizeof(write_buf),(unsigned char*) " Max Acc x:"); UTIL1_strcatNum8u(write_buf, sizeof(write_buf), max);
UTIL1_strcat(write_buf, sizeof(write_buf),(unsigned char*) " Max Acc y:"); UTIL1_strcatNum8u(write_buf, sizeof(write_buf), may);
UTIL1_strcat(write_buf, sizeof(write_buf),(unsigned char*) " Max Acc z:"); UTIL1_strcatNum8u(write_buf, sizeof(write_buf), maz);
UTIL1_strcat(write_buf, sizeof(write_buf),(unsigned char*) " Max giro x:"); UTIL1_strcatNum8u(write_buf, sizeof(write_buf), mgx);
UTIL1_strcat(write_buf, sizeof(write_buf),(unsigned char*) " Max giro y:"); UTIL1_strcatNum8u(write_buf, sizeof(write_buf), mgy);
UTIL1_strcat(write_buf, sizeof(write_buf),(unsigned char*) " Max giro z:"); UTIL1_strcatNum8u(write_buf, sizeof(write_buf), mgz);
UTIL1_strcat(write_buf, sizeof(write_buf),(unsigned char*) " Speed:"); UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)velo); UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)"\r\n");
UTIL1_strcat(write_buf, sizeof(write_buf),(unsigned char*) "A:"); UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)"\r\n"); UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)a); UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)"\r\n"); UTIL1_strcat(write_buf, sizeof(write_buf),(unsigned char*) "G:"); UTIL1_strcatNum8u(write_buf, sizeof(write_buf),bandera); UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)"\r\n"); UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)g); UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)"\r\n"); UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)"\n"); LEDR_On(); LEDG_On(); WAIT1_Waitms(100); bufpos[0]=NULL; if (TmDt1_GetDate(&fecha)!=ERR_OK) {} /* open file */ name[0]=NULL; sprintf(name,"./DM%02d%02d.txt",fecha.Month,fecha.Day);
if (FAT1_open(&fp, name, FA_OPEN_ALWAYS|FA_WRITE)!=FR_OK) { }
if (FAT1_lseek(&fp, fp.fsize) != FR_OK || fp.fptr != fp.fsize) { }
if (FAT1_write(&fp, write_buf, UTIL1_strlen((char*)write_buf), &bw)!=FR_OK) { (void)FAT1_close(&fp); } (void)FAT1_close(&fp); LEDR_Off(); LEDG_Off(); pos[0]=NULL; getpos(bufpos,pos);
pos[0]=NULL; a[0]=NULL; g[0]=NULL; } /*********************************************************************************** * Nome da função: initINER
* Descrição: Módulo para inicializar sensores via I2C * Parâmetros: nenhum * **********************************************************************************/ void initINER(void){ deviceData.handle9x = I2C0_Init(&deviceData); while(I2C0_SelectSlaveDevice(deviceData.handle9x,LDD_I2C_ADDRTYPE_7BITS,30)!=ERR_OK) {} //select 8700 magnetometro
while(I2CWriteReg9x(0x0E, 0x01)!=ERR_OK) {} //range 8g acc8700 while(I2CWriteReg9x(0x2A, 0x05)!=ERR_OK) {} //ctrl_reg1 acc8700 while(I2CWriteReg9x(0x5B, 0x1F)!=ERR_OK) {} //MAG_ctrl_reg1 8700 deviceData.handle = I2C2_Init(&deviceData);
while(I2CWriteReg(0x0E,0x03)!=ERR_OK) {} //range 8g on the accelerometer while(I2CWriteReg(0x2A, 0x01|0x02)!=ERR_OK) {} //ctrl_reg1 acc8451
while(I2C0_SelectSlaveDevice(deviceData.handle9x,LDD_I2C_ADDRTYPE_7BITS,32)!=ERR_OK) {} //select gyro
while(I2CWriteReg9x(0x0D, 0x1F)!=ERR_OK) {} //range 200dg/s gyro while(I2CWriteReg9x(0x13, 0x0A)!=ERR_OK) {} //active mode, ODR gyro
//juego de LEDs para indicar inicializacion correcta de sensores WAIT1_Waitms(1000);
LEDR_On(); WAIT1_Waitms(100); LEDG_On(); WAIT1_Waitms(200);
LEDR_Off(); WAIT1_Waitms(300); LEDG_Off(); WAIT1_Waitms(400); //fin de juego de LEDs indicando inicializacion de sensores
deviceData.handles = AS1_Init(&deviceData); deviceData.handleu = UART_Init(&deviceData); deviceData.isSent = FALSE; deviceData.rxChar = '\0'; deviceData.rxPutFct = ringo_Put; ringo_Init();
while(AS1_ReceiveBlock(deviceData.handles, (LDD_TData *)&deviceData.rxChar, sizeof(de- viceData.rxChar))!=ERR_OK) {}
WAIT1_Waitms(300); }
void SendChar(unsigned char ch, Iner_T *desc) { desc->isSent = FALSE;
while(AS1_SendBlock(desc->handles, (LDD_TData*)&ch, 1)!=ERR_OK) {} while(!desc->isSent) {}
}
void SendString(const unsigned char *str, Iner_T *desc) { while(*str!='\0') {
SendChar(*str++, desc); }
}
/*********************************************************************************** * Nome da função: app
* Descrição: Módulo raiz para inicializar o sistema, e monitorar os sinais * Parâmetros: nenhum * **********************************************************************************/ void app(void){ char buf0[17]; char gyr[2410];
char Acel[2410]; //3 eixos de 4 caracteres y 40 amostras
int iPsi=0, cont=100, contb=0, d=0, event=0, eventos=0, giroscopio=0, Max=0, May=0, Maz=0, Mgx=0, Mgy=0, Mgz=0;
initINER(); //inicialização dos sensores BlueRadios_Init(UART_DeviceData); //Inicialização bluetooth buf0[0]=NULL;
Acel[0]=NULL; gyr[0]=NULL; FAT1_Init();
if (FAT1_mount(0, &fs) != FR_OK) { /* mount file system */ }
for(;;) { //Loop infinito //WAIT1_Waitms(5);
while(I2CReadReg(0x01, (uint8_t*)&xyz, 3)!=ERR_OK){} //captura da aceleração MMA8451 fast read out_X_MSB
sprintf(buf0,"q%03d",xyz[0]); strcat(Acel,buf0); //Acel sprintf(buf0,"w%03d",xyz[1]); strcat(Acel,buf0); sprintf(buf0,"e%03d",xyz[2]); strcat(Acel,buf0); buf0[0]=NULL; contb++;
UARTSendString((unsigned char*)Acel, &deviceData); Acel[0]=NULL;
while(I2C0_SelectSlaveDevice(deviceData.handle9x, LDD_I2C_ADDRTYPE_7BITS, 32 ) !=ERR_OK){} //select gyro
while(I2CReadReg9x(0x01, (int*)&xyz[0], 1)!=ERR_OK){} //Medição do giroscópio 21000 out_X_MSB
while(I2CReadReg9x(0x03, (int*)&xyz[1], 1)!=ERR_OK){} while(I2CReadReg9x(0x05, (int*)&xyz[2], 1)!=ERR_OK){} sprintf(buf0,"a%03d",xyz[1]); strcat(gyr,buf0); //gyr sprintf(buf0,"s%03d",xyz[0]); strcat(gyr,buf0); sprintf(buf0,"d%03dj",xyz[2]); strcat(gyr,buf0); buf0[0]=NULL;
UARTSendString((unsigned char*)gyr, &deviceData); gyr[0]=NULL; Max=0; May=0; Maz=0; Mgx=0; Mgy=0; Mgz=0; giroscopio=0; buf0[0]=NULL; Acel[0]=NULL; gyr[0]=NULL; event=0; cont=100; contb=0;
if(contb==cont && event==10){ //threshold ultrapassado
while(I2C0_SelectSlaveDevice(deviceData.handle9x,LDD_I2C_AD- DRTYPE_7BITS,30)!=ERR_OK) {} //select 8700 magnetômetro
while(I2CReadReg9x(0x33, (int*)&mag[0], 1)!=ERR_OK){} //OUT_X_MSB while(I2CReadReg9x(0x34, (int*)&mag[1], 1)!=ERR_OK){} //OUT_X_LSB while(I2CReadReg9x(0x35, (int*)&mag[2], 1)!=ERR_OK){} //OUT_Y_MSB
while(I2CReadReg9x(0x36, (int*)&mag[3], 1)!=ERR_OK){} //OUT_Y_LSB
while(I2CReadReg9x(0x37, (int*)&mag[4], 1)!=ERR_OK){} //OUT_Z_MSB
while(I2CReadReg9x(0x38, (int*)&mag[5], 1)!=ERR_OK){} //OUT_Z_LSB int16_t xyz1=((mag[0]<<8)|mag[1])-511;//-497;//-35; // // processo de cálculo de MSB y LSB int16_t xyz2=((mag[2]<<8)|mag[3])-181;//-192;//-126;//((mx2+mn2)/2); iPsi = atan2(-xyz2,xyz1)*180.0/PI; LogToFile(iPsi,Acel,gyr,giroscopio,Max,May,Maz,Mgx,Mgy,Mgz); Max=0; May=0; Maz=0; Mgx=0; Mgy=0; Mgz=0; giroscopio=0; buf0[0]=NULL; Acel[0]=NULL; gyr[0]=NULL; event=0; cont=100; contb=0; eventos++; } } I2C2_Deinit(deviceData.handle); I2C0_Deinit(deviceData.handle9x); }
APÊNDICE E – Arquivo de Dados
O sistema SMI gera um arquivo no formato texto com extensão .TXT. A visualização dos dados é feita simplesmente abrindo o arquivo de texto, desde o cartão de memória, com qualquer programa incluído no Windows, como por exemplo: notepad, wordpad, etc.
O nome de cada arquivo de dados gerado possui duas letras (que identificam o dispositivo SMI utilizado - hardware) e quatro números referentes ao dia e o mês da data em que foi realizada a medição. Devem ser considerados e utilizados somente os dados nos quais o nome do arquivo (dia e mês) corresponde à data em que foi realizada a medição (Isso indica que houve a leitura da posição do sistema GPS e esta é confiável).
Cada evento armazenado no cartão de memória tem o formato apresentado na Figura E.1. Os valores de aceleração e velocidade angular apresentados no arquivo de texto são contagens