Enviando apenas um bit

iFireOxz · 9 de outubro de 2015

Olá pessoal, tudo bem? estou trabalhando em um projeto de PIC usando a USB no modo HID, meu código de envio ficou mais ou menos assim,

if ((aux_cont1 == 0) && (SENSOR1 == 1 ))

{

aux_cont1 = 1;

writebuff[1] = 1;

while(!Hid_Write(&writebuff, 64))

}

if ((aux_cont1 == 1) && (SENSOR1 == 0))

{

aux_cont1 = 0;

}

nesse caso o comando while(!Hid_Write(&writebuff, 64)) que é padrão pelo tutorial que achei, quando faço os testes ele envia os 64 bits, e queria que enviasse apenas o valor de writebuff[1] alguém pode me ajudar a fazer isso? Sou novo na linguagem C.

xyko-2020 · 9 de outubro de 2015

@iFireOxz

Bem vindo..

Não disse qual o PIC...

mas

http://www.pictronics.com.br/projetos/59-construindo-um-dispositivo-usb-pic.html

Poderia usar o seu próprio tópico também

http://forum.clubedohardware.com.br/forums/topic/1134964-pic-18f4550-usb-problemas-de-comunica%C3%A7%C3%A3o/

iFireOxz · 9 de outubro de 2015

@_xyko_

Obrigado pela resposta rápida, é um 18F4550, não entendi muito bem o que você quis me dizer nesses tópicos ai, a minha dúvida é mais sintática, fazer um dispositivo usb eu já fiz, mas estou trabalhando na forma de enviar dados.

vtrx · 10 de outubro de 2015

O padrão HID não envia 1 byte,mas 64 bytes no modo full speed ou 8 bytes no modo low speed,e não é 1 bit mas sim 1 byte.

Pense comigo,se voce precisa de apenas 1 bytes,horas,apenas use o Buffer1 e descarte o resto...

Leia e use apenas o resultado do primeiro buffer.

iFireOxz · 10 de outubro de 2015

@vtrx Desculpe a confusão dos bits e bytes haha, mas no caso eu não uso só um no projeto, ele é mais ou menos assim, eu tenho 30 sensores, e preciso que quando o sensor for ativado ele envie um número que será lido pelo computador fazendo a contagem, mas quando envio, ele acaba enviando todos, então quando um sensor é ativado, ele esta enviando todos os valores, incrementando todos os contadores.

vtrx · 11 de outubro de 2015

Refaça a lógica do programa.

HID é um padrão e não tem como alterar um padrão universal.

Toda comunicação HID vai trafegar os bytes padrão da comunicação.

Valor_Sensor_1 = ReadBuff[1].

O Buffer que envia/recebe os bytes tem que ter o mesmo tamanho (64 para FullSpeed).

Com 30 sensores sobra 33,não vejo o problema ainda.

Outro detalhe,a comunicação USB HID FullSpeed comunica com o PC no mínimo em 1 milissegundo,não tem como 'atropelar' este tempo(64K/S).

iFireOxz · 13 de outubro de 2015

Entendi mais ou menos, troquei a lógica e fiz desse jeito, mas agora ele só envia 0, quando faço a comutação do sensor, ele não envia o valor.

if (aux_cont2 == 0)

{

if (SENSOR2 == 0)

{

valor_sensor2 = 0;

}

if (SENSOR2 == 1)

{

valor_sensor2 = 2;

}

valor_sensor2 = writebuff[2];

}

if ((aux_cont2 == 1) && (SENSOR2 == 0))

{

aux_cont2 = 0;

}

while(!Hid_Write(&writebuff,64))

Já tentei muitas coisas, não sei como fazer, preciso enviar esse sinal de que um sensor foi ativado, mas se eu enviar pelo while ali, ele envia todos os valor que estão nos buffers, por isso a necessidade de transformar os valores em 0 mas tambem não estou conseguindo arrumar essa lógica, alguém pode me ajudar?

vtrx · 13 de outubro de 2015

@iFireOxz

Vamos ver se tenho a sorte de te ajudar.

Esta é uma comunicação que estudei e pratiquei a fundo,ja usei com PIC em ASM e 3 compiladores C diferente,e até implementei em ARM.

Mas preciso de umas informações par agilizar.

1-Qual compilador esta usando com o PIC?

2-Qual programa você usa para se comunicar com o PC?

3-voce ja tem um prototipo montado e este prototipo ja esta enumerando(sendo reconhecido e alocado) com o PC?

4-O que os sensores tem que enviar,um valor ou apenas se foram ativados?

5-Tenho que saber como definiu as variáveis e como sua rotina se comunica com a USB,se usa uma interrupção ou via Looping.

iFireOxz · 13 de outubro de 2015

@vtrx

1- Estou usando o compilador MikroC.

2 - Não entendi muito bem a sua pergunta, mas criei uma interface em visual studio, ela reconhece a conexão do dispositivo mas ainda não consegui acertar a parte da contagem, pra ver os bytes sendo recebidos pelo Pc estou utilizando o HID Terminal.

3- Sim, o protótipo está pronto e está sendo reconhecido pelo PC.

4- A minha ideia de lógica seria a seguinte, o computador faz a contagem de cada sensor, então quando um sensor é ativado, ele envia um sinal, dizendo que é o sensor "x", o computador lê esse valor, e incrementa a variável correspondente.

5- Bom, segue abaixo meu código, pelo jeito você entende muito mais do que eu haha, fui pesquisando em alguns sites e achei essa forma, não sei te dizer, mas acredito que seja looping, deixei a contagem com o while(1)

//************************* Variaveis globais **********************************unsigned char readbuff[64] absolute 0x500;unsigned char ritebuff[64] absolute 0x540; //USB RAM//****************************************************************************// DEFINES para simplificar a programação.#define SENSOR1 RD2_bit#define SENSOR2 RD3_bit//***** VARIÁVEIS ***** //   // variáveis declaradas paraint aux_cont1 = 0;int aux_cont2 = 0;int valor_sensor1 = 0;int valor_sensor2 = 0;void interrupt(){       USB_Interrupt_Proc();}void main(void){ADCON1 |= 0x0F;                // Configure all ports with analog function as digital  CMCON  |= 7;  //****************************************************************************  //                           SETA PORTAS DE I/O  //****************************************************************************  TRISD = 0b11111111;HID_Enable(&readbuff,&writebuff);    //Habilita a comunicação USBwhile(1){if (aux_cont1 == 0){       if (SENSOR1 == 0)       {        valor_sensor1 = 0;       }       if (SENSOR1 == 1)       {        valor_sensor1 = 1;       }        valor_sensor1 = writebuff[1];}if ((aux_cont1 == 1) && (SENSOR1 == 0))       {        aux_cont1 = 0;       }if (aux_cont2 == 0){       if (SENSOR2 == 0)       {        valor_sensor2 = 0;       }       if (SENSOR2 == 1)       {        valor_sensor2 = 2;       }        valor_sensor2 = writebuff[2];}if ((aux_cont2 == 1) && (SENSOR2 == 0))       {        aux_cont2 = 0;       }while(!Hid_Write(writebuff, 64));       }      } // END MAIN  //****************************************************************************

Agradeço a resposta rápida e a disposição, não sou todos que tem esse conhecimento e compartilham com tanta vontade haha.

vtrx · 14 de outubro de 2015

@iFireOxz

Sabia que iria ter algum incomodo nessa historia,neste caso é o MikroC.

Ainda não entendi seu esquema.

Quem faz a leitura para saber se um sensor foi ativado é o PC?

voce escreveu;

o computador faz a contagem de cada sensor

e depois continuou;

o computador lê esse valor, e incrementa a variável correspondente

Quem é o PIC e quem é o PC?

Acho que os sensores são ligados ao PIC,então o PIC 'le' qual sensor foi ativado e envia ao PC,mas o PC não tem que contar as vezes mas sim o PIC!

Na comunicação HID,o dispositivo,no caso o PIC,só pode enviar algo se for solicitado,então o PC envia alguma coisa,tipo um caractere,mesmo tendo que enviar 64 bytes(o padrão full speed),você carrega o primeiro buffer,no PC,com um caractere que o PIC entenda que é para executar alguma rotina.

Exemplo,o PC envia o caractere a.

Se fosse em C;

HidWriteBuff[0] = 'a';

No PIC,sua rotina estaria esperando este a para executar algo;

  while(1){    if(HID_Read() > 0) //Verifica se recebeu algum dado.    {      if(HidReadBuff[0]=='a') //Faz a leitura do primeiro byte recebido e compara com a      {             HidWriteBuff[0] = valor_sensor1; //valor_sensor seria a variavel do sensor 1       while(!Hid_Write(HidWriteBuff, 64)); //Envia algo atraves da USB para o PC.              }    }}

Usando o HID terminal,voce digitaria a e receberia o valor da variável valor_sensor1.

Para agilizar o programa,voce poderia ter feito;

  while(1){    if(HID_Read() > 0) //Verifica se recebeu algum dado.    {      if(HidReadBuff[0]=='a') //se for a,envia logo os 63 sensores      {             HidWriteBuff[0] = valor_sensor1;        HidWriteBuff[1] = valor_sensor2;        HidWriteBuff[2] = valor_sensor3;        HidWriteBuff[3] = valor_sensor4;        HidWriteBuff[4] = valor_sensor5;        HidWriteBuff[5] = valor_sensor6;        HidWriteBuff[6] = valor_sensor7;        HidWriteBuff[7] = valor_sensor8;        HidWriteBuff[8] = valor_sensor9;        HidWriteBuff[9] = valor_sensor10;        HidWriteBuff[10] = valor_sensor11;        HidWriteBuff[11] = valor_sensor12;        HidWriteBuff[12] = valor_sensor13;        HidWriteBuff[13] = valor_sensor14;        HidWriteBuff[14] = valor_sensor15;        HidWriteBuff[15] = valor_sensor16;        HidWriteBuff[16] = valor_sensor17;        HidWriteBuff[17] = valor_sensor18;        HidWriteBuff[18] = valor_sensor19;        HidWriteBuff[19] = valor_sensor20;        HidWriteBuff[20] = valor_sensor21;        HidWriteBuff[21] = valor_sensor22;        HidWriteBuff[22] = valor_sensor23;        HidWriteBuff[23] = valor_sensor24;        HidWriteBuff[24] = valor_sensor25;        HidWriteBuff[25] = valor_sensor26;        HidWriteBuff[26] = valor_sensor27;        HidWriteBuff[27] = valor_sensor28;        HidWriteBuff[28] = valor_sensor29;        HidWriteBuff[29] = valor_sensor30;        HidWriteBuff[30] = valor_sensor31;        HidWriteBuff[31] = valor_sensor32;       HidWriteBuff[32] = valor_sensor33;        HidWriteBuff[33] = valor_sensor34;        HidWriteBuff[34] = valor_sensor35;        HidWriteBuff[35] = valor_sensor36;        HidWriteBuff[36] = valor_sensor37;        HidWriteBuff[37] = valor_sensor38;        HidWriteBuff[38] = valor_sensor39;        HidWriteBuff[39] = valor_sensor40;        HidWriteBuff[40] = valor_sensor41;        HidWriteBuff[41] = valor_sensor42;        HidWriteBuff[42] = valor_sensor43;        HidWriteBuff[43] = valor_sensor44;        HidWriteBuff[44] = valor_sensor45;        HidWriteBuff[45] = valor_sensor46;        HidWriteBuff[46] = valor_sensor47;        HidWriteBuff[47] = valor_sensor48;        HidWriteBuff[48] = valor_sensor49;        HidWriteBuff[49] = valor_sensor50;        HidWriteBuff[50] = valor_sensor51;        HidWriteBuff[51] = valor_sensor52;        HidWriteBuff[52] = valor_sensor53;        HidWriteBuff[53] = valor_sensor54;        HidWriteBuff[54] = valor_sensor55;        HidWriteBuff[55] = valor_sensor56;        HidWriteBuff[56] = valor_sensor57;        HidWriteBuff[57] = valor_sensor58;        HidWriteBuff[58] = valor_sensor59;        HidWriteBuff[59] = valor_sensor60;        HidWriteBuff[60] = valor_sensor61;        HidWriteBuff[61] = valor_sensor62;        HidWriteBuff[62] = valor_sensor63;        HidWriteBuff[63] = valor_sensor64;        while(!Hid_Write(HidWriteBuff, 64)); //Envia algo atraves da USB para o PC.              }    }}

Isso porque independentemente de voce usar um byte ou 64,tanto o PC como o PIC vão enviar/receber 64 de uma só vez.

Por padrão,a comunicação HID se inicia com o primeiro byte com valor zero(0),o compilador trata isso automaticamente.

Na minhas comunicações HID,eu sempre uso o primeiro Buffer para dizer ao circuito que rotina usar,tipo;

  while(1){    if(HID_Read() > 0) //Verifica se recebeu algum dado.    {      if(HidReadBuff[0]=='a') //se for a,inverte a saida de um pino do PIC      {	 PORTB.B0 = ~PORTB.B0;      }    }}

Poderia ser uma rotina.

Isso ja é um começo para voce.

Faça o teste;

  while(1){    if(HID_Read() > 0) //Verifica se recebeu algum dado.    {      if(HidReadBuff[0]=='a')       {       HidWriteBuff[0] = 'o';        HidWriteBuff[1] = 'k';       }            while(!Hid_Write(HidWriteBuff, 64));     }}}

Digite a no HID terminal e deve retornar 'ok'.

iFireOxz · 14 de outubro de 2015

Nossa, obrigado pela ajuda, vou tentar esse esquema ai, no meu caso é assim, uso um PIC 18F4550 os sensores são ligados nele e ele faz a leitura dos mesmos, quando o sensor for ativado, envia um sinal para o pc falando que foi ativado, meu programa se trata de um supervisório, contando o número de peças, então envio para o PC e la faço um programa em Visual Studio C# do qual ja estou desenvolvendo e incremento a variável que corresponde a determinado sensor, entendeu? Você conhece um pouco dessa comunicação PIC -> Visual Studio?

Obrigado por tudo

Consegui fazer essa parte de quando o pic receber alguma coisa, enviar um número e tudo mais, mas isso é realmente necessário? Terei que ficar enviando do programa no visual studio, toda hora? o código que funcionou fiz ficou assim:

 while(1){    if(HID_Read() > 0) //Verifica se recebeu algum dado.    {      if(HidReadBuff[0]=='a')       {       if((aux_cont1 == 0) && (SENSOR1 == 1))       {       valor_sensor1 = 1;       HidWriteBuff[1] = valor_sensor1;       aux_cont1 = 1;       }       if((aux_cont1 == 1) && (SENSOR1 == 0)       {        aux_cont1 = 0;       }       if((aux_cont1 == 0) && (SENSOR1 == 0))       {        valor_sensor1 = 0;        HidWriteBuff[1] = valor_sensor1;       }        }            while(!Hid_Write(HidWriteBuff, 64));     }}

Pelos testes que fiz ele só esta recebendo 0, nao consigo colocar e tirar o sensor para tentar enviar. Estou usando uma conexão de 24V na entrada para simular o sensor por enquanto para não precisar ficar mexendo com muitos cabos e tudo mais...

iFireOxz · 14 de outubro de 2015

@ Edit

Tive mais um problema, refiz uma parte do programa para ver se ele estava comutando o byte para 1 mesmo, tirei a rotinca que transformava em 0 e deixei apenas de modo que quando o sensor estivesse ativo fosse enviado um valor, não acontece nada, ele simplesmente não funciona, será que pode ser por que eu estou usando uma linha de 24v em vez do sensor?

vtrx · 14 de outubro de 2015

terei que ficar enviando do programa no visual studio, toda hora?

Sim,sabe porque?

Na verdade o PIC não envia nada,é o PC que tem acesso a memória Ram do PIC onde fica os dados,logo se o PC não ler,nunca vai saber se tem dados novo.

voce tem certeza que seu Hardware esta funcionando OK?

iFireOxz · 14 de outubro de 2015

@vtrx

Sim, foi feito testes nele, está tudo ok. Bom saber disso, você ja trabalhou com o visual studio? Sabe algum exemplo pra me dar?

vtrx · 15 de outubro de 2015

@iFireOxz

Visual Studio não pois gosto de executáveis independentes de complementos.

Para voce testar seu aplicativo feito no Visual Studio,faça uma comunicação simples,se funcionar,sua lógica dos sensores pode estar errada.

Comunicação simples poderia ser envie 'a' receba 'ok'.

Para saber se seu aplicativo esta recebendo caracteres,conecte um Joystick USB,aperte algumas teclas e veja se tem leitura em um Edit ou Memo.

Sobre Hardware,o PIC 18F2550 tem um 'bug' de Hardware usando USB quando faz a gravação do Firmware usando baixa tensão (LVP).

Isto desabilita o pino RB5 e deixa o circuito USB sensível a estática,só de encostar o dedo em cima do PIC ja é o suficiente para 'desconectar' o USB e reiniciar,não sei se o 18F4550 também é assim.

Para estabilizar e evitar isso,no 18F2550,deixo o pino RB5/PGM como entrada e aterro este pino.

iFireOxz · 15 de outubro de 2015

Bom pessoal, depois de muita luta, consegui haha, conectei o sensor ao protótipo e consegui fazer funcionar, o HID Terminal apresentou certinho, agora a luta é fazer a parte do Visual Studio, se alguém tiver alguma dica, agradeço. Meu muito obrigado a todos que ajudaram pela vontade de ajudar e principalmente a paciência kkk.

@vtrx

Valeu cara, se é *****.