Ir ao conteúdo
  • Cadastre-se

Ítalo Rodrigues

Membros Juniores
  • Total de itens

    16
  • Registro em

  • Última visita

  • Qualificações

    0%

Reputação

0

Sobre Ítalo Rodrigues

  • Data de Nascimento 05-09-1992 (26 anos)

Informações gerais

  • Cidade e Estado
    Ceara
  1. Bom galera, bateu um curiosidade ao ver a necessidade de comprar uma TvBox para uma televisão da LG full hd (LG42LE5300). Nela há uma conexão serial RS232C, onde é possível gerenciar todas as funcionalidades da TV através desta porta, dispensando o controle remoto por assim dizer. Já que a maioria das TvBox vem com uma porta USB, seria possível conectar um cabo USB/RS232 (como o da leadership https://goo.gl/tQ8Xat) e através de um app, gerenciar completamente a TV por um único aparelho, tornando uma TV normal e uma verdadeira smart?
  2. Ae encontrei a solução kkkkkk!! Deixar aqui que irá servir para muitos por ae! Bom, notei que o cabo flat do touchpad estava bem maleável perto do conector (pois é para ser ligeiramente rígida), o que subtendi que as trilhas estivessem rompidas. Com auxílio de um multímetro, fiz teste de continuidade para saber se o cabo estava realmente ligado, CUIDADO: fazer com notebook totalmente desligado! Multímetro para quem não sabe o que é, é um equipamento elétrico que serve para medir diversas grandezas elétricas, efetuar algumas leituras e testes também. E notei que o cabo flat realmente estava rompido internamente, caso tenha suspeita, se ele estiver dobrando facilmente em um determinado ponto, ou machucado, provavelmente estará danificado, pois o restante de seu corpo estará mais rígido. O cabo flat do meu touchpad é semelhante a este: http://notepart.vteximg.com.br/arquivos/ids/204943-1000-1000/cabo-flat-touchpad_fronte.jpg, com 6 regiões de contato. O que fiz para solucionar: já que não tinha outro e na minha cidade isso é bem difícil, corte a parte danificada e raspei a isolação praticamente do mesmo tamanho que era antes, removi a etiqueta azul e colei com cola tekbond! Só ter cuidado para não raspar do lado errado, pois a cabos flats que são inversos, como nessa imagem que mostrei. Eu me enganei e raspei do lado errado, e não funcionou. Cortei novamente e refiz o mesmo procedimento e deu certo, ou seja, touchpad totalmente normal! Removi o driver que estava instalado, instalei o que a Dell aconselha (Synaptics Touchpad Driver; Versão 17.0.8.0, A00; Data da versão 09 out 2013) e depois utilizei o software DriverPack para buscar uma versão mais recente. Hoje está na versão 19.2.17.52. Só ultimas considerações: quando liguei o touchpad, no "gerenciador de arquivos" surgiu o dispositivo PS/2! E em "Programas e recursos", o driver instalado "Synaptics Pointing Device Driver" passou a ser "Dell Touchpad". Espero que ajude a todos ae, solução provisória até corrigir de forma adequada.
  3. Tudo bem galera do Clube do Hardware? vocês são feras, só para deixar claro! Tentarei ser o mais descritivo possível A dois dias atrás, meu notebook Dell Inspiron 14z 5423 apresentou uma falha no touchpad! Tendo o funcionamento de modo intermitente, ou seja, hora funcionava e hora não. No entanto, nesse touchpad há um led que indica se está habilitado/desabilitado (apagado/ligado). Mesmo com o passar dos dedos na área, apertando os dois botões, ele não funcionava só voltava a funcionar após alguns minutos e depois deligava, ficando assim nesse ciclo, mas ao fazer o comando "FN + F3" (que desabilita/habilita o touchpad, liga/desliga o led) funcionava normalmente. Fisicamente, há dois cabos flat: para o circuito do touchpad, outro para o led (sim, apenas para o led). Fui pesquisar problemas relacionados, a maioria cita problemas de versões de drivers e atualizações driver/windows. Assim fiz um procedimento que piorou a situação: fui em Gerenciador de Dispositivos -> Mouse e outro dispositivos apontadores e abri as propriedades do driver referente ao touchpad (que se não me engano, o nome deve ser "Dell touchpad", "Synaptics SMBus Touchpad" ou "Touchpad PS/2", alguma coisa do tipo) e clickei em "Reveter Driver". Fiz o procedimento de reiniciar e quando retornou parou de funcionar de vez! Nem touchpad e nem led mais! Fui buscar os drivers, coisa que normalmente faço, site da dell e lá é fornecido um driver para Mouse, Teclado e dispositivos de entrada: Synaptics Touchpad Driver; Versão 17.0.8.0, A00; Data da versão 09 out 2013. Já fiz formatação no meu note algumas vezes e sei que esse driver nunca funcionou, pois até quando entro em Painel de control -> Mouse para acessar as propriedades do mouse, surge uma janela de erro "não foi possível conectar o driver do synaptics dispositivo indicador". Então sempre utilizo aqueles programas gerenciadores de drivers: Driver Booster, Driver Easy, Device Doctor, DriverPack e Driver Toolkit, por exemplo, para ir em busca de versões mais novas, sendo assim, possível acessar as propriedades normalmente e fazer as devidas configurações, como mostra nesse vídeo: https://www.youtube.com/watch?v=6SSQTnjzi3A Hoje, a versão que está instalada é a 19.2.17.52. Só que desta vez, o touchpad não voltou a funcionar! Fiz diversas desinstalação de drivers e instalei versões mais velhas/novas e nada. Sempre aparecendo a mesma mensagem "não foi possível conectar o driver do synaptics dispositivo indicador" onde pedi para desinstalar ou não. Mesmo colocando não, a janela que surge, não possui mais a aba "Dell touchpad", referente ao driver instalado para as configurações. Lembro que em "Programas e recursos", onde se faz a desinstalação de software, havia um chamado de "dell touchpad" e o driver normal "Synaptics Pointing Device Driver", mas hoje há apenas o segundo. E nessa de instalar diversas versões de drivers, vez ou outra o teclado acaba sofrendo também: funcionando nos primeiros instante que windows liga e depois para. MINHAS DUVIDAS O porque de todos os drivers que instalo, sempre aparecer a mensagem de erro e não ter serventia de nada? Tenho a impressão de que necessito desse outro software "dell touchpad" para operar também. Em configurações do computador -> computador e dispositivos -> mouse e touchpad -> só há configurações do mouse, nada do touchpad, coisa que deveria, como o habilitar/desabilitar, algumas configurações, por isso que suspeito que algum arquivo se corrempou, pois não há mais nada de configuração de touchpad disponível CONSIDERAÇÕES Note não é novo, tem uns 4~5 anos já, mas acredito que o problema não seja físico, pois estava operando, mesmo ruim, mas estava, o que fez para de vez foi depois de reverter o driver. O Windows fez uma atualização um dia antes de começar apresentar o problema, coisa que acredito não ter sido o problema, mas é possível pois há bastantes relatos de problemas após alguma atualização do windows seja aquelas comuns, como a transição do 8.1 para o 10. Meu note roda Windows 8.1 original, segundo a dell, o Windows 10 é incompatível com meu modelo, pois já apresentou problemas de incompatibilidade de drivers antes e de muitos outros que possuem mesmo note. Técnico da dell aconselhou formatar, caso não resolvesse, o problema seria físico. Em gerenciadores de dispositivos, a unica coisa que aparece agora em Mouse e outro dispositivos apontadores é o mouse compatível dom HID (que é o mouse de USB). E em propriedades de mouse no painel de controle, aparece a mensagem de erro do driver Sinaptics, e as configurações comum do mouse e o a referente do mouse de USB. Desculpa o texto enorme, mas quis descrever o tudo que fiz e as condições atual. Agradeço desde já a todos!!!
  4. Boa noite pessoal, acabei de construir um placa PICkit2 Clone para me ajudar nuns projetos e ela não está operando adequadamente e preciso da ajuda de vocês!!! =D segue o layout e a placa produzida. Bom, para começo não sei como ela funciona, só peguei esse layout da minha faculdade e funciona perfeitamente e na minha apresenta falhas. Quando insiro ela na na USB e abro o software PICkit 2 v2.61 é reconhecido normalmente, mas quando faço a busca do microcontrolador a ser gravado, simplesmente não encontra (Tools -> Check communication). Por dificuldades de encontrar alguns componentes na minha cidade, foram feita adaptações, como a construção do indutor, coisa que está em torno de 720uH, onde deveria ser 680 uH correto? E também outros transistores foram substituídos. Gostaria de saber o motivo, o erro cometido, a opinião de vocês, pois como não sei o funcionamento de um gravador PICkit2 e muito menos o da minha placa, fico sem muito o que saber fazer. O pinos ICSP de cima para baixos, estão na ordem correta (Vpp, Vdd, GND, PGD, PGC e AUX). Não sei pra que serve esse pino AUX também. Faço a seguinte conexão no PIC18F4520: Vpp -> pino 1 Vdd -> pino 11 e pino 32 GND -> pino 12 e pino 31 PGD -> pino 40 PGC -> pino 39 email: [email protected]<script cf-hash='f9e31' type="text/javascript"> /* */</script>
  5. Boa noite pessoal, Bom..estive funçando esses dias e verifiquei que ao tentar abrir um arquivo no diretório original do arquivo, por exemplo um de foto, verifiquei que a mensagem que apareceu não foi de erro de leitura, e sim de permissão de contas "O Visualizador de Fotos não pode abrir esta imagem porque você não tem permissão para acessar o local do arquivo." Então fui verificar nas propriedades avançada de segurança do arquivo (botão direito->propriedades->aba de seguraça->avançadas) as contas liberadas e percebi que estava faltando a minha conta de administrador em "Entradas de permissão", como pode ver na imagem 1. Então fui adiciona-la manualmente em "adicionar->Selecionar uma entidade de seguraça->Avançado->Localizar agora" e selecionei minha conta de adiministrador do note, como na imagem 2 (OBS.: não sei o porque que ao selecionar, existe muitas contas com meu nome, e por meio de tentativas uma delas deu certo). Depois dei OK, ai o nome da conta foi parar na janela "Selecionar Usuário ou Grupo", dei OK de novo. Com a conta selecionada, na janela "Entrada de Permissão + nome do arquivo", selecionei a opção "Controle total" e apertei OK, como mostra imagem 3. Feito isso, apertei em aplicar e depois em OK, OK. pronto!!! Terminado isso, já podia acessar o arquivo que selecionei. Não sei como isso aconteceu e o porque..mas deu certo, e isso não está acontecendo com todos meus arquivos, mas com boa parte e não somente um local. Por exemplo, alguns arquivos (não funcionando) que estão numa pasta que criei em "Bibliotecas" eu simplesmete copio/recorto e colo na area de trabalho, o arquivo passa a funcionar. Mas não necessariamente todos os arquivos desta pasta não estão funcionando. E acabei de verificar que os arquivos de video da minha area de trabalho (não funcionando) recorto para uma pequena partição do meu note, o video volta a funcionar, e quando recoloco onde estava, o video volta a funcionar. kkkkkkkkkkkkkkk não to entendendo mais nada... como habilito essa permissão geral, para todos meus arquivos de uma vez.
  6. Fiz já, restaurei para segunda-feira e nada..
  7. Boa noite, Estou com um problema que me enlouqueceu hoje, todos meus arquivos estavam corrompidos!!! Ontem instalei o antivírus 360 Security Internet e fiz uma varredura completa no meu note. Depois de quase uma tarde inteira, percebi que ele detectava os executáveis do meus programas como virus "GEN-MALWARE3.0", "GEN-MALWARE6.0" coisa do tipo. Interrompi a varredura pela metade e o desinstanlei e continuei a usar meu note normalmente. Quando foi hoje de manhã, nenhum dos meus arquivos abriam mais, arquivos de pdf's, de foto, de vídeo, de texto ".txt", ".doc", arquivos de códigos de programações em C/C++ por exemplo, arquivos de projeto de software como Proteus, Pcad por exemplo. Dai me falaram para colocar tais arquivos em outra maquina, no momento que passei para pendrive percebi que ali mesmo era possível abri-los/acessa-los e que também colocando em outras partições do HD e em outros diretórios no mesmo note eles abriam, mas se retornassem para onde estavam, volta a "corromper". Que tipo de problema é esse??? Aaahh, e também meu notebook Dell Inpiro 14z 5423 quando liga, aparece uma mensagem "Preparando reparação automática do windows", dai parte para uma tela azul, com a seguinte mensagem: "Reparo Automático O Reparo Automático não pôde reparar o computador Pressione "Opções avançadas" para tentar reparar o computador ou "Desligar" para desliga-lo. Arquivo de log: C:\Windows\System32\Logfiles\Srt\SrtTrail.txt" Ai click em "Outras opções" e em "sair e continuar com windows 8.1", ai ele reiniciar e a aperto "F2" para entrar na tela de configurações do bot, saio da tela sem alterações e é reiniciado novamente. Dai, o sistema operacional entra normalmente... Agradeço desde já...
  8. Pois é xykoTE, utilizo um cristal de 20MHz e tenho acesso a comunicação Serial via radio-PC, contudo programo em C pelo software CCS, e Isadora Ferraz, gostaria de uma coisa mais prática, mais por via linha de código, tipo usando o timer0 do própio PIC. Pois esse tempo que desejo calcular é porque faço a comunicação com um sensor pelo barramento I2C e gostaria de saber o tempo que levou para obter a cada duas leituras; Tentei usando set_timer0 e coletando dps de um tempo pelo get_timer0, mas não obtive sucesso. Acredito está fazendo errado.
  9. Boa noite, estou encucado com isso, mas gostaria de saber como calcular/saber o tempo que demora uma função em um microcontrolador PIC para ser executada. Tipo, estou querendo saber quanto tempo o PIC leva para fazer duas leituras de um protocolo de comunicação, usando umas funções que criei. Pensei em usar o timer0 para tentar calcular pela função "get_timer0()" mas não obtive sucesso. Bom, utilizo o compilador CCS e o microntrolador PIC18F4520. Se puderem mandar algum algoritmo, formula ou código mesmo, agradeço desde já!! Obg.
  10. Bom pessoal, realmente demorei, mas estou aqui para agradecer uma breve explicação sobre manipulação de registradores..isso me ajudou bastante como interpretar melhor o datasheet e a nota de aplicação dada de cada modulo sensorial LSM303DLH http://www.pololu.com/file/0J434/LSM303DLH-compass-app-note.pdf L3G4200D http://www.parallax.com/sites/default/files/downloads/27911-L3G4200D-Gyroscope-Application-Note.pdf há uma certa quantidade de códigos ou explicação na internet, mas não são muito bem descritos, não são muito coerente para facilitar mais a utlização do mesmo. Tive muitas dificuldades para conseguir a leitura dos modulos, mas consegui em parte, não estou conseguindo filtra-los e manipular os valores para utilizar em calculos para orientação absoluta do do sensor. Gostaria de saber mais sobre estes sensores e como manipula-los bem e como melhorar meu código. segue o código que consegui efetuar a leitura do acelerômetro e do giroscópio, do magnetômentro não estou obtendo sucesso =/ Acelerômetro #include <18F4520.h> #use delay(clock=20000000) #FUSES NOWDT,HS,NOBROWNOUT,NOLVP #use i2c(Master,fast=400,sda=PIN_C4,scl=PIN_C3,force_sw) #use rs232 (baud=19200, parity=N, xmit=PIN_C6, rcv=PIN_C7) #define AccR 0x31 #define AccW 0x30 #define tmp 100 #define CTRL_REG1_A 0x20 #define CTRL_REG4_A 0x23 #define SET_REG1_A 0x27 #define SET_REG4_A 0x40 #define OUT_X_L_A 0x28 #define OUT_X_H_A 0x29 #define OUT_Y_L_A 0x2A #define OUT_Y_H_A 0x2B #define OUT_Z_L_A 0x2C #define OUT_Z_H_A 0x2D int16 LerAcc(int endereco) { int16 retorno=0; int LSB=0x00, MSB=0x00; i2c_start(); i2c_write(AccW); i2c_write(endereco); i2c_start(); i2c_write(AccR); LSB=i2c_read(); MSB=i2c_read(0); i2c_stop(); retorno=MSB; retorno=(retorno<<8)+LSB; return(retorno); } int16 Ax; int16 Ay; int16 Az; void main(){ delay_ms(tmp); printf("Comecar comunicao I2C!"); set_tris_c(0xFF); enable_interrupts(GLOBAL); enable_interrupts(INT_SSP); i2c_start(); i2c_write(AccW); i2c_write(CTRL_REG1_A); i2c_write(SET_REG1_A); i2c_stop(); i2c_start(); i2c_write(AccW); i2c_write(CTRL_REG4_A); i2c_write(SET_REG4_A); i2c_stop(); while(true){ Ax=LerAcc(OUT_X_L_A); Ay=LerAcc(OUT_Y_L_A); Az=LerAcc(OUT_Z_L_A); printf("\r"); printf("ACC:\t%ld\t%ld\t%ld",Ax,Ay,Az); delay_ms(tmp); } } Giroscópio #include <18F4520.h> #use delay(clock=20000000) #FUSES NOWDT,HS,NOBROWNOUT,NOLVP #use i2c(Master,fast=400,sda=PIN_C4,scl=PIN_C3,force_sw) #use rs232 (baud=19200, parity=N, xmit=PIN_C6, rcv=PIN_C7) #define GyroR 0xD3 #define GyroW 0xD2 #define tmp 10 #define CTRL_REG1_G 0x20 #define CTRL_REG2_G 0x21 #define CTRL_REG3_G 0x22 #define CTRL_REG4_G 0x23 #define CTRL_REG5_G 0x24 #define SET_REG1_G 0x0F #define SET_REG2_G 0x20 #define SET_REG3_G 0x00 #define SET_REG4_G 0x30 #define SET_REG5_G 0x00 #define OUT_X_L_G 0x28 #define OUT_X_H_G 0x29 #define OUT_Y_L_G 0x2A #define OUT_Y_H_G 0x2B #define OUT_Z_L_G 0x2C #define OUT_Z_H_G 0x2D void GyroW_REG(BYTE reg, BYTE set) { i2c_start(); i2c_write(GyroW); i2c_write(reg); i2c_write(set); i2c_stop(); } int16 LerGyro(int endereco1, int endereco2) { int16 retorno=0; int LSB=0x00, MSB=0x00; i2c_start(); i2c_write(GyroW); i2c_write(endereco1); i2c_start(); i2c_write(GyroR); LSB=i2c_read(0); i2c_start(); i2c_write(GyroW); i2c_write(endereco2); i2c_start(); i2c_write(GyroR); MSB=i2c_read(0); i2c_stop(); retorno=MSB; retorno=(retorno<<8)+LSB; return(retorno); } int16 Gx; int16 Gy; int16 Gz; void main() { delay_ms(tmp); printf("Comecar comunicao I2C!"); set_tris_c(0xFF); enable_interrupts(GLOBAL); enable_interrupts(INT_SSP); GyroW_REG(CTRL_REG1_G, SET_REG1_G); delay_ms(tmp); GyroW_REG(CTRL_REG2_G, SET_REG2_G); delay_ms(tmp); GyroW_REG(CTRL_REG3_G, SET_REG3_G); delay_ms(tmp); GyroW_REG(CTRL_REG4_G, SET_REG4_G); delay_ms(tmp); GyroW_REG(CTRL_REG5_G, SET_REG5_G); delay_ms(tmp); while(true) { Gx=LerGyro(OUT_X_L_G,OUT_X_H_G); Gy=LerGyro(OUT_Y_L_G,OUT_Y_H_G); Gz=LerGyro(OUT_Z_L_G,OUT_Z_H_G); printf("\r"); printf("Gyro:\t%ld\t%ld\t%ld",Gx,Gy,Gz); delay_ms(tmp); } } Magnetômetro #include <18F4520.h> #use delay(clock=20000000) #FUSES NOWDT,HS,NOBROWNOUT,NOLVP #use i2c(Master,fast=400,sda=PIN_C4,scl=PIN_C3,force_sw) #use rs232 (baud=19200, parity=N, xmit=PIN_C6, rcv=PIN_C7) #define MagR 0x3D #define MagW 0x3C #define tmp 100 #define CRA_REG_M 0x00 #define MR_REG_M 0x02 #define SET_CRA_M 0x14 #define SET_MR_M 0x00 #define OUT_X_H_M 0x03 #define OUT_X_L_M 0x04 #define OUT_Y_H_M 0x07 #define OUT_Y_L_M 0x08 #define OUT_Z_H_M 0x05 #define OUT_Z_L_M 0x06 int16 LerMag(int endereco) { int16 retorno=0; int LSB=0x00, MSB=0x00; i2c_start(); i2c_write(MagW); i2c_write(endereco); i2c_start(); i2c_write(MagR); LSB=i2c_read(); MSB=i2c_read(0); i2c_stop(); retorno=MSB; retorno=(retorno<<8)+LSB; return(retorno); } int16 temp; int16 Mx, My, Mz; int16 mxl,mxh,myl,myh,mzl,mzh; void main(){ delay_ms(tmp); printf("Comecar comunicao I2C!"); set_tris_c(0xFF); enable_interrupts(GLOBAL); enable_interrupts(INT_SSP); i2c_start(); i2c_write(MagW); i2c_write(CRA_REG_M); i2c_write(SET_CRA_M); i2c_stop(); i2c_start(); i2c_write(MagW); i2c_write(MR_REG_M); i2c_write(SET_MR_M); i2c_stop(); while(true){ /*i2c_start(); i2c_write(MagW); i2c_write(OUT_X_H_M); i2c_start(); i2c_write(MagR); mxl=i2c_read(); mxh=i2c_read(); myl=i2c_read(); myh=i2c_read(); mzl=i2c_read(); mzh=i2c_read(0); i2c_stop();*/ Mx=LerMag(OUT_X_H_M); My=LerMag(OUT_Y_H_M); Mz=LerMag(OUT_Z_H_M); printf("\r"); printf("MAG:\t%ld\t%ld\t%ld",Mx,My,Mz); delay_ms(tmp); } }
  11. Caro mateusmaxi, estou trabalhando também com um sensor que envolve o acelerômetro e magnetômetro (LSM303DLH) + um que é o giroscópio (L3G4200D). também tive grandes, mais grandes dificuldades de implementar um código em PIC para conseguir obter a leitura. Com a nota de aplicação referente ao sensor http://www.pololu.com/file/0J434/LSM303DLH-compass-app-note.pdf lhe dá uma boa base de onde começar, não tenha duvidas. Mais sempre requer atenção aos detalhes e fique sempre atento ao datasheet do mesmo http://www.st.com/web/en/resource/technical/document/datasheet/CD00260288.pdf assim voce consiguira interpretando o sensor aos poucos. Meu código não está perfeito, mais a comunicação foi obtido, mas a leitura não está totalmente correta. #include <18F4520.h> #use delay(clock=20000000) #FUSES NOWDT,HS,NOBROWNOUT,NOLVP #use i2c(Master,fast=400,sda=PIN_C4,scl=PIN_C3,force_sw) #use rs232 (baud=19200, parity=N, xmit=PIN_C6, rcv=PIN_C7) #define AccR 0x31 #define AccW 0x30 #define tmp 10 #define CTRL_REG1_A 0x20 #define CTRL_REG4_A 0x23 #define SET_REG1_A 0x27 #define SET_REG4_A 0x40 #define OUT_X_L_A 0x28 #define OUT_X_H_A 0x29 #define OUT_Y_L_A 0x2A #define OUT_Y_H_A 0x2B #define OUT_Z_L_A 0x2C #define OUT_Z_H_A 0x2D int16 LerAcc(int enderecoL, int enderecoH) { int16 retorno=0; int DL=0x00, DH=0x00; i2c_start(); i2c_write(AccW); i2c_write(enderecoL); i2c_start(); i2c_write(AccR); DL=i2c_read(); DH=i2c_read(0); i2c_stop(); retorno=(int)(DL<<8)+DH; return(retorno); } int16 Ax; int16 Ay; int16 Az; void main(){ delay_ms(tmp); printf("Comecar comunicao I2C!"); set_tris_c(0xFF); enable_interrupts(GLOBAL); enable_interrupts(INT_SSP); i2c_start(); i2c_write(AccW); i2c_write(CTRL_REG1_A); i2c_write(SET_REG1_A); i2c_stop(); i2c_start(); i2c_write(AccW); i2c_write(CTRL_REG4_A); i2c_write(SET_REG4_A); i2c_stop(); while(true){ Ax=LerAcc(OUT_X_L_A,OUT_X_H_A); Ay=LerAcc(OUT_Y_L_A,OUT_Y_H_A); Az=LerAcc(OUT_Z_L_A,OUT_Z_H_A); printf("\r"); printf("ACC=\t%x\t%x\t%x",Ax,Ay,Az); delay_ms(tmp); } } O segredo até então para mim foi que no barramento I2C, voce precisa "indicar" se é leitura ou escrita, ou seja, se voce quer ler a saída OUT_X_H_A, voce deve fazer o seguinte: i2c_start(); //inicia comunicação i2c_write(endereço do sensor+bit 0); //o endereço do sensor é geralmente 7 bits + bit de escrita "0" - escreva endereço i2c_write(OUT_X_H_A); //escreve qual registrador voce quer i2c_start(); //renicia comunicação i2c_write(endereço do sensor+bit 1); //o endereço do sensor 7 bits + bit de leitura "1" variavel=i2c_read(); //voce ler o que o sensor, no caso o dispositivo escravo, ira lhe mandar i2c_stop(); //comunicação encerrada endereço do sensor LSM303DLH (leitura 00110001b – 0x31 ") (escrita 00110000b – 0x30) - Tabela 12 datasheet mais antes voce precisa configurar o sensor, mexendo em seus registradores, na nota de aplicação na pag 9 a partir da seção 2, ensina a manusear o sensor com utilidades basicas para se ter noção i2c_start(); i2c_write(AccW); i2c_write(CTRL_REG1_A); i2c_write(SET_REG1_A); i2c_stop(); i2c_start(); i2c_write(AccW); i2c_write(CTRL_REG4_A); i2c_write(SET_REG4_A); i2c_stop(); eu utilizei o arduino para ler..conseguia valores de +16000 a -16000...no meu código vai de 0 a 255 e não consegui de jeito algum colocar de outra forma. espero ter dado uma esperaça ae, qualquer coisa meu email: italorodriguesb@gmail.com =D
  12. Bom Felipe, não tenha duvidas que seu post me deu um excelente norte kkkkkkkkkk...sou novo na questão de microcontroladores PIC, venho mexendo tá com uns 6~8meses, e o que aprendi bem foi a usar seu periféricos de saida/entrada, portas analogicas/digitais, comunicação serial (rs232), PWM, etc...claro que não todos e de começo nem sabia da existência dos tais registradores, com o tempo e pesquisas foi notando a sua presença em códigos mais nunca consegui compreende-los bem, o que realmente são e pra que servem, com tal estudo venho percebendo a sua utilização em diversas situações. Não foi por falta de interesse ou coisa do tipo, mais como o tempo era corrido, não tive tempo de aprender praticamente nada sobre eles, somente uma breve introdução...por isso não me atrevo a falar sobre. Como já venho tentando ler o sensor já algum tempo, já vi diversos códigos que utilizam registradores e fui me "familiarizando" de forma bruta a eles. Do seu post entendi quase que 100% da sua lógica, apesar da linguagem está um "pouco" diferente da que utilizo. Uso o compilidador CCS C Compiler v.4. Referente ao artigo citado, irei ler..mais tenho um leve conhecimento em cima do protocolo, na parte logica, apesar da dificuldade. Percebi que fogem a minha linha de raciocinio, pois no compilador que utilizo tem as diretivas de setar os pinos como entrada, caracterizar o PIC como mestre/escraco como abaixo #use i2c(Master,fast,sda=PIN_C4,scl=PIN_C3,force_sw) #use i2c(SLAVE,fast, SDA=PIN_C4, SCL=PIN_C3, address=0xA0) e tambem tem algumas funções para iniciar/parar a comunicação i2c_start(); i2c_stop(); para ler o dado i2c_write(dado); dentre outras... Abaixo segue meu código pra você ter uma noção de como consegui simular na comunicação I2C entre dois PICs. A ideia é: PIC escravo está sendo usado como um "voltimetro de 5V" que fica lendo a tensão constantemente e o PIC mestre fica solicitando com essa tensão a ser lida e joga numa tela LCD e/ou envia serialmente a tensão lida. Tal situação foi bolada com a intenção de "simular" um sensor, como eu já disse, consegui tal proesa graças ao site espanhol que citei http://robotypic.blogspot.com.es/ onde tem um endereço e um dado que indica o que quer ser lido, no caso o endereço do PIC escravo é 0xA0 e o dado para conseguir tal tensão é 0x01 Código PIC MESTRE: #include <16F876a.h> #use delay(clock=4000000) #fuses XT, NOWDT, BROWNOUT, NOPUT, NOPROTECT, NOLVP, NOCPD, NOWRT, NODEBUG #use i2c(Master,fast,sda=PIN_C4,scl=PIN_C3,force_sw) #use rs232 (baud=9600, parity=N, xmit=PIN_C6, rcv=PIN_C7) //Taxa de transmissão 19200; terminais de comunicação TX e RX; #include <input.c> BYTE dado=0, endereco=0; int32 dado_lido=0; //Funcao ESCREVER para para PICS escravos void envio(endereco, dado){ i2c_start(); // Comienzo comunicación i2c_write(endereco); // Dirección del esclavo en el bus I2C i2c_write(dado); // Dato a transmitir i2c_stop(); // Fin comunicación delay_ms(1); } //Funcao LEITURA de PICS escravos void leitura (byte endereco, byte dado1, byte dado2,byte dado3,byte dado4) { i2c_start(); // Comienzo de la comunicación i2c_write(endereco); // Dirección del esclavo en el bus I2C i2c_start(); // Reinicio i2c_write(endereco+1); // Dirección del esclavo en modo lectura dado1=i2c_read(0); // Lectura del dato i2c_start(); // Reinicio i2c_write(endereco+1); // Dirección del esclavo en modo lectura dado2=i2c_read(0); i2c_start(); // Reinicio i2c_write(endereco+1); // Dirección del esclavo en modo lectura dado3=i2c_read(0); i2c_start(); // Reinicio i2c_write(endereco+1); // Dirección del esclavo en modo lectura dado4=i2c_read(0); i2c_stop(); // Fin comunicación delay_ms(50); printf("tensão lida:%i%i%i%i" dado1, dado2, dado3, dado4); delay_ms(2000); } //Funcao principal void main(){ BYTE dado=0, endereco=0, dado_lido1=0, dado_lido2=0, dado_lido3=0, dado_lido4=0; enable_interrupts(GLOBAL); //Habilitacao da interrupcao GLOBAL e I2C enable_interrupts(INT_SSP); while(TRUE){ endereco=0xA0; dado=0x01; envio(endereco, dado); printf("\fCOMUNICANDO COM DISPOSITIVO:%x ...\n"endereco); delay_ms(200); leitura(endereco, dado_lido1, dado_lido2, dado_lido3, dado_lido4); } } Códgio PIC ESCRAVO: #include <16F876A.h> #device adc=10 //Configura o compilador para conversor A/D de 8 bits #fuses XT,NOWDT,NOPROTECT,NOLVP #use delay(clock=4000000) #use i2c(SLAVE,fast, SDA=PIN_C4, SCL=PIN_C3, address=0xA0) #define use_portb_lcd TRUE #include <mod_lcd.c> typedef enum {NOTHING, CONTROL_READ,ADDRESS_READ} I2C_STATE; I2C_STATE fState; int32 buffer,tensão,u,d,c,m; short envio=0; //Funcao de interrupcao I2C de recebimento #INT_SSP void ssp_interupt (){ static byte cont; BYTE incoming; //Onde se armazena o BYTE enviado pelo mestre fstate = i2c_isr_state(); //Estado do barramento apos interrupcao if (fstate == 0x80){ //Se nao houver dados recebidos -> leitura do escravo para mestre u=buffer/10; //divisao para retirar a unidade u=buffer-(u*10); //subtracao para obter o valor o numero da unidade pura d=buffer/100; //divisao para retirar a dezena d=(buffer-((d*100)+u))/10; //subtracao para obter o numero da dezena pura c=buffer/1000; //divisao para retirar a centena m=c; c=((buffer-(c*1000))-((d*10)+u))/100; //calculo para retirar dezena e unidade cont++; if(cont==1){ i2c_write (m); } if(cont==2){ i2c_write ©; } if(cont==3){ i2c_write (d); } if(cont==4){ i2c_write (u); cont=0; } } else{ //Se ha dados no barramento I2C... incoming = i2c_read(); //...le if (fState == NOTHING){ //Informacao recebida é um aviso que ira mandar algo ao mestre fState = CONTROL_READ; //Em seguida essa informacao sera a posicao que guardara os dados } else if (fState == CONTROL_READ) { //Informcao recebida corresponde a posicao if(incoming==1){ tensão=read_adc(); //Leitura do sinal, valor, analógico tensão=(tensão*5000)/1023; //calculo para conversão buffer=tensão; } fState = NOTHING; envio=1; } } } //Funcao principal void main (){ lcd_ini(); fState = NOTHING; enable_interrupts(INT_SSP); enable_interrupts(GLOBAL); setup_ADC_ports(all_analog); //Usar a porta RA0-analogica setup_adc(ADC_CLOCK_INTERNAL); //Ler junto com pulso clock set_adc_channel(0); //Selecionar o canal 0 delay_us(10); //Colocar 10us pois é o tempo que o pic leva para ler o sinal while(TRUE){} } Muito da estrutura do código, tive que apanhar pra conseguir entender como e pra que funcionava...código certamente tem bastante falhas e coisas desnecessária, não fiz uma filtragem a fundo para reduzi-lo mais obti algum resultado...a primeira leitura vem com erro (não entendo o porque). Muita coisa ae explica da seguinte forma, "só sei que é assim e funcionou", total compreensão do código foi baseado nessa aplicação http://robotypic.blogspot.com.es/2012/03/comunicacion-i2c-entre-tres-pics.html http://robotypic.blogspot.com.es/2010/10/comunicacion-via-i2c-entre-dos-pic.html Segue o link da imagem que contem o circuito bolado https://imagizer.imageshack.us/v2/784x594q90/822/xr22.png https://imageshack.com/i/muxr22p Segue o link da imagem que contem o resultado da simulação https://imagizer.imageshack.us/v2/821x356q90/842/ukgb.png https://imageshack.com/i/neukgbp
  13. Bom dia pessoal, venho ao forum pedir ajuda de vocês, pois já recorrir diversas vezes e sei que aqui encontro material e respostas de qualidade. Bom, meu problema está na comunicação I2C com sensor da POLOLU, 9DOF (giroscópio, acelerômetro e magnetômetro - L3G4200D e LSM303DLM). Segue o link da fabricante: http://multilogica-shop.com/unidade-de-medicao-inercial-9dof-minimu-l3g4200d-e-lsm303dlm Eu já mexo com microcontrolador PIC já tem um bom tempo, só que agora estou com um trabalho e necessito fazer a leitura desse sensor com PIC, seja 18F4520, 18F4550, 18F2550, 16F877A, ou qualquer outro, mas o que mais utilizo é o 18F4520. No link acima tem a descrição bem definida do sensor e tudo mais, juntamente com download da biblioteca e códigos para a sua leitura, calibração também, mais isso disponível para Arduíno. Com tais códigos, consegui sim fazer a leitura e trabalhar um pouco com o sensor, mas somente com Arduíno, e pra isso preciso implementar um código que em C para o PIC e conseguir as mesma leituras obtidas com Arduíno. A comunicação I2C pra mim é nova, o máximo que já consegui foi fazer a comunicação entre dois PICs, mais não foi com muita precisão, mas foi graças ao site em espanhol que encontrei que consegui, segue abaixo: http://robotypic.blogspot.com.es/ Tal protocolo é um estudo que estou fazendo por fora, e por isso enfrento bastante dificuldades de sua implementação. Muitos exemplos na internet usam a linguagem C com assembly, na manipulação de registradores, que são ferramentas que não sei ainda manipular, consequentemente tenho dificuldades na leitura e compreensão dos códigos e também do datasheet. segue o datasheet do LSM303DLM (Acelerômetro e Magnetômetro): http://www.pololu.com/file/download/LSM303DLM.pdf?file_id=0J514 segue o datasheet do L3G4200D (Giroscópio): http://www.pololu.com/file/download/L3G4200D.pdf?file_id=0J491 No site da empresa, segue os links da biblioteca e códigos de amostras para leitura do sensor Biblioteca arduino Pololu L3G: https://github.com/pololu/l3g-arduino Biblioteca arduino Pololu LSM303: https://github.com/pololu/lsm303-arduino Resumindo: Já tentei interpretar todo o código do arduino e repassar para o PIC, copiar a biblioteca para implementa-la tambem e não consegui resultado algum, posso ter feito algo de errado (certamente), pois isso está sujeito a erros constamente. Não mexo com arduino, só tenho conhecimento superficial e tais códigos divulgados pela empresa, a ligação do circuito é tem toda a descrição nos links postado. Peço que me deem um norte, um código amostra, uma referência, algo que possa me dá uma boa orientação a seguir em frente. Abaixo biblioteca exemplo em arduino da empresa Pololu para sensor LSM303: #ifndef LSM303_h #define LSM303_h #include <Arduino.h> // for byte data type class LSM303 { public: template <typename T> struct vector { T x, y, z; }; enum deviceType { device_DLH, device_DLM, device_DLHC, device_D, device_auto }; enum sa0State { sa0_low, sa0_high, sa0_auto }; // register addresses enum regAddr { TEMP_OUT_L = 0x05, // D TEMP_OUT_H = 0x06, // D STATUS_M = 0x07, // D INT_CTRL_M = 0x12, // D INT_SRC_M = 0x13, // D INT_THS_L_M = 0x14, // D INT_THS_H_M = 0x15, // D OFFSET_X_L_M = 0x16, // D OFFSET_X_H_M = 0x17, // D OFFSET_Y_L_M = 0x18, // D OFFSET_Y_H_M = 0x19, // D OFFSET_Z_L_M = 0x1A, // D OFFSET_Z_H_M = 0x1B, // D REFERENCE_X = 0x1C, // D REFERENCE_Y = 0x1D, // D REFERENCE_Z = 0x1E, // D CTRL0 = 0x1F, // D CTRL1 = 0x20, // D CTRL_REG1_A = 0x20, // DLH, DLM, DLHC CTRL2 = 0x21, // D CTRL_REG2_A = 0x21, // DLH, DLM, DLHC CTRL3 = 0x22, // D CTRL_REG3_A = 0x22, // DLH, DLM, DLHC CTRL4 = 0x23, // D CTRL_REG4_A = 0x23, // DLH, DLM, DLHC CTRL5 = 0x24, // D CTRL_REG5_A = 0x24, // DLH, DLM, DLHC CTRL6 = 0x25, // D CTRL_REG6_A = 0x25, // DLHC HP_FILTER_RESET_A = 0x25, // DLH, DLM CTRL7 = 0x26, // D REFERENCE_A = 0x26, // DLH, DLM, DLHC STATUS_A = 0x27, // D STATUS_REG_A = 0x27, // DLH, DLM, DLHC OUT_X_L_A = 0x28, OUT_X_H_A = 0x29, OUT_Y_L_A = 0x2A, OUT_Y_H_A = 0x2B, OUT_Z_L_A = 0x2C, OUT_Z_H_A = 0x2D, FIFO_CTRL = 0x2E, // D FIFO_CTRL_REG_A = 0x2E, // DLHC FIFO_SRC = 0x2F, // D FIFO_SRC_REG_A = 0x2F, // DLHC IG_CFG1 = 0x30, // D INT1_CFG_A = 0x30, // DLH, DLM, DLHC IG_SRC1 = 0x31, // D INT1_SRC_A = 0x31, // DLH, DLM, DLHC IG_THS1 = 0x32, // D INT1_THS_A = 0x32, // DLH, DLM, DLHC IG_DUR1 = 0x33, // D INT1_DURATION_A = 0x33, // DLH, DLM, DLHC IG_CFG2 = 0x34, // D INT2_CFG_A = 0x34, // DLH, DLM, DLHC IG_SRC2 = 0x35, // D INT2_SRC_A = 0x35, // DLH, DLM, DLHC IG_THS2 = 0x36, // D INT2_THS_A = 0x36, // DLH, DLM, DLHC IG_DUR2 = 0x37, // D INT2_DURATION_A = 0x37, // DLH, DLM, DLHC CLICK_CFG = 0x38, // D CLICK_CFG_A = 0x38, // DLHC CLICK_SRC = 0x39, // D CLICK_SRC_A = 0x39, // DLHC CLICK_THS = 0x3A, // D CLICK_THS_A = 0x3A, // DLHC TIME_LIMIT = 0x3B, // D TIME_LIMIT_A = 0x3B, // DLHC TIME_LATENCY = 0x3C, // D TIME_LATENCY_A = 0x3C, // DLHC TIME_WINDOW = 0x3D, // D TIME_WINDOW_A = 0x3D, // DLHC Act_THS = 0x3E, // D Act_DUR = 0x3F, // D CRA_REG_M = 0x00, // DLH, DLM, DLHC CRB_REG_M = 0x01, // DLH, DLM, DLHC MR_REG_M = 0x02, // DLH, DLM, DLHC SR_REG_M = 0x09, // DLH, DLM, DLHC IRA_REG_M = 0x0A, // DLH, DLM, DLHC IRB_REG_M = 0x0B, // DLH, DLM, DLHC IRC_REG_M = 0x0C, // DLH, DLM, DLHC WHO_AM_I_M = 0x0F, // DLM WHO_AM_I = 0x0F, // D TEMP_OUT_H_M = 0x31, // DLHC TEMP_OUT_L_M = 0x32, // DLHC // dummy addresses for registers in different locations on different devices; // the library translates these based on device type // value with sign flipped is used as index into translated_regs array OUT_X_H_M = -1, OUT_X_L_M = -2, OUT_Y_H_M = -3, OUT_Y_L_M = -4, OUT_Z_H_M = -5, OUT_Z_L_M = -6, // update dummy_reg_count if registers are added here! // device-specific register addresses DLH_OUT_X_H_M = 0x03, DLH_OUT_X_L_M = 0x04, DLH_OUT_Y_H_M = 0x05, DLH_OUT_Y_L_M = 0x06, DLH_OUT_Z_H_M = 0x07, DLH_OUT_Z_L_M = 0x08, DLM_OUT_X_H_M = 0x03, DLM_OUT_X_L_M = 0x04, DLM_OUT_Z_H_M = 0x05, DLM_OUT_Z_L_M = 0x06, DLM_OUT_Y_H_M = 0x07, DLM_OUT_Y_L_M = 0x08, DLHC_OUT_X_H_M = 0x03, DLHC_OUT_X_L_M = 0x04, DLHC_OUT_Z_H_M = 0x05, DLHC_OUT_Z_L_M = 0x06, DLHC_OUT_Y_H_M = 0x07, DLHC_OUT_Y_L_M = 0x08, D_OUT_X_L_M = 0x08, D_OUT_X_H_M = 0x09, D_OUT_Y_L_M = 0x0A, D_OUT_Y_H_M = 0x0B, D_OUT_Z_L_M = 0x0C, D_OUT_Z_H_M = 0x0D }; vector<int16_t> a; // accelerometer readings vector<int16_t> m; // magnetometer readings vector<int16_t> m_max; // maximum magnetometer values, used for calibration vector<int16_t> m_min; // minimum magnetometer values, used for calibration byte last_status; // status of last I2C transmission LSM303(void); bool init(deviceType device = device_auto, sa0State sa0 = sa0_auto); byte getDeviceType(void) { return _device; } void enableDefault(void); void writeAccReg(regAddr reg, byte value); byte readAccReg(regAddr reg); void writeMagReg(regAddr reg, byte value); byte readMagReg(regAddr reg); void writeReg(regAddr reg, byte value); byte readReg(regAddr reg); void readAcc(void); void readMag(void); void read(void); void setTimeout(unsigned int timeout); unsigned int getTimeout(void); bool timeoutOccurred(void); float heading(void); template <typename T> float heading(vector<T> from); // vector functions template <typename Ta, typename Tb, typename To> static void vector_cross(const vector<Ta> *a, const vector<Tb> *b, vector<To> *out); template <typename Ta, typename Tb> static float vector_dot(const vector<Ta> *a,const vector<Tb> *; static void vector_normalize(vector<float> *a); private: deviceType _device; // chip type (DLH, DLM, or DLHC) byte acc_address; byte mag_address; static const int dummy_reg_count = 6; regAddr translated_regs[dummy_reg_count + 1]; // index 0 not used unsigned int io_timeout; bool did_timeout; int testReg(byte address, regAddr reg); }; #endif Abaixo código exemplo em arduino da empresa Pololu na leitura do sensor LSM303: #include <Wire.h> #include <LSM303.h> LSM303 compass; char report[80]; void setup() { Serial.begin(9600); Wire.begin(); compass.init(); compass.enableDefault(); } void loop() { compass.read(); snprintf(report, sizeof(report), "A: %6d %6d %6d M: %6d %6d %6d", compass.a.x, compass.a.y, compass.a.z, compass.m.x, compass.m.y, compass.m.z); Serial.println(report); delay(100); }
  14. Bom já venho quebrando cabeça a bom tempo tentando utilizar o protocolo i2c no pic.. minha ideia é simular um pic (escravo) como sensor mandando uma informação para outro pic (mestre), uma informação básica como um numero em hexadecimal (0x10 por exemplo) e mostrar atraves da comunicação serial rs232 tal informação por um printf("resultado: %i",result);. Mas já tentei de muitas formas aplicar tal protocolo e não consegui muitos resultados.. algumas referencias de circuitos me ajudaram a esclarecer bastante coisas: http://hades.mech.northwestern.edu/index.php/I2C_communication_between_PICs http://www.todopic.com.ar/foros/index.php?topic=34581.0 todos apresentam características muito semelhantes e tal, mas não consegui interpretar 100% o código inteiro, como por exemplo a interrupção #INT_SSP no escravo mesmo estando comentada. Aqui vai meu codigo do mestre: #include <18f4520.h> #fuses HS,NOLVP,NOPROTECT #use delay(clock=20000000) #use I2C(FAST, SCL=PIN_C3, SDA=PIN_C4, FORCE_HW) #use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7) int result=0; void main(void){ while(TRUE){ i2c_start(); i2c_write(0x14); i2c_write(0x02); i2c_stop(); i2c_start(); i2c_write(0x15);result=i2c_read(0); i2c_stop(); output_d(result); printf("resultado: %i",result); } }E aqui o codigo do escravo: #include <18f4520.h> #fuses HS,NOLVP,NOPROTECT #use delay(clock=20000000) #use i2c(SLAVE, FAST, SCL=PIN_C3, SDA=PIN_C4, address=0x14, FORCE_HW) int state; // I2C var int address, buffer[0x03]; #INT_SSP void ssp_interupt (){ state = i2c_isr_state(); if(state < 0x80){ if(state == 0){ } if(state == 1){ address = i2c_read(); } if(state == 2){ buffer[address] = i2c_read(); } if(state == 0x80){ i2c_write (buffer[address]); } } } void main(){ setup_adc_ports(AN0); setup_adc(ADC_CLOCK_INTERNAL); enable_interrupts(INT_SSP); enable_interrupts(GLOBAL); while(TRUE){ set_adc_channel(0); delay_us(10); buffer[0x02] = read_adc(); output_d(buffer[0]); } } Os códigos já estão mexidos um poucos, mas a segue o principio da minha ideia, o escravo ficar enviando uma tal informação quando o mestre pedir, futuramente minha ideia era utilizar o escravo como um voltimetro de 5V e ficar enviando o valor da tensão a medida que for alterando a resistencia para o mestre. Eu utilizo o Proteus 8.0 para simulação, a vez que cheguei mais perto, foi quando tentei implementar minha propria biblioteca i2c, me baseando pelo livro do fabio pereira, "PIC, programação em C". Utilizo o CSS 4.084 para compilar meus codigos. segue imagem do meu circuito de simulação no Proteus.http://imageshack.us/a/img826/684/fh0k.png Se alguem já fez algo parecido ou que tenha encontrado tal falha, agradeço desde já pessoal, sei que vocês são show! =D

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×