Pic 18f4550, usb e supervisório c#

Jonathan Gonzaga · 24 de abril de 2016

Olá amigos,

Bom vou ser objetivo: gostaria de saber se alguém conhece alguma forma ou sabe se é possível utilizar a comunicação USB do PIC18F4550 e a RS485 ao mesmo tempo. Seria através de um supervisório feito em Visual C#. Através do software eu comandaria um escravo a alguns metros de distancia interligado ao mestre por um par de fios e o mestre interligado ao computador pela USB. No meu projeto eu tenho essas aplicações separadas funcionado, porém de forma isolada. Ou seja, ou entro no Modo USB e comando via supervisório ou no Modo Rede (RS 485). Programei no Mikro C, mas gostaria de incrementar, mostrar o que o projeto pode proporcionar ao usuário. Porém não encontrei nada na internet a respeito da utilização dessas três ferramentas juntas. Se alguém puder me auxiliar ficarei grato.

Desde já agradeço

Att,

Jonathan Gonzaga

ViniciusKruz · 5 de maio de 2016

O 18f4550 deverá se comunicar com o computador por USB/RS485 ao mesmo tempo? seria isto?

Jonathan Gonzaga · 6 de maio de 2016

Não amigo, não é possível comunicar pc por RS485, teria que converter para RS232. Seria comunicar o pc via usb com o mestre da rede, enviar dados pelo supervisorio (essa parte esta pronta), o mestre recebe e envia via RS485 para o escravo. Estou tentando fazer aqui, mas a comunicação falha. O mestre envia um comando para acionar uma saída do escravo e funciona na primeira vez, porém no segundo comando o sistema trava, a conexão usb se perde, o supervisorio trava, porém o escravo fica normal. Gostaria de saber se é necessário algum esquema de ligação especifico ou comando na programação para impedir esse erro, ou não recomenda-se usar esses dois protocolos juntos.

Se precisar eu envio o código e prints do esquema feitos no Proteus. No momento não posso, estou pelo celular.

ViniciusKruz · 6 de maio de 2016

Manda o print por favor, outra coisa, qual linguagem de programação esta usando nos microcontroladores?

Jonathan Gonzaga · 6 de maio de 2016

Mikro C usa linguagem C como o próprio nome diz

Tem alguma ideia do que possa estar ocorrendo? Ah, outra coisa, o escravo também envia dados ao mestre, que são recebidos pela interrupção e lidos normalmente. Os prints envio hoje a noite.

ViniciusKruz · 6 de maio de 2016

Pelo que você está dizendo, o problema está é no mestre, tem como você postar o trecho do código que envia os dados para o escravo?

Jonathan Gonzaga · 10 de maio de 2016

Bom, desculpa a demora na postagem, tive outros problemas pra resolver e teve o dia das mães então fiquei um pouco ocupado. Bom segue parte do código, primeiro o início da main para visualizarem como o PIC inicializa (esse parte é a mesma para o mestre e o escravo) Depois somente a da conexão USB e logo abaixo o laço do RS485 dentro da USB (também do mestre):

/-----------------------------FUNÇÃO MAIN--------------------------------------
void main ()
{

//Setup dos pinos, registradores e variáveis comuns
{
ADCON1       =  0x0D;              // Conversor AD, habilita AN0 e AN1 como analogicas
TRISA        =  0b111111;          // Seta RA0 e RA1 como entradas analógicas
TRISA3_bit   =  1;
TRISD        =  0x00;              // Todo o PORTD como saida
CMCON        =  0x07;              // To turn off comparators
TRISB        =  0x00;              //Todo portB como saída
PORTB        =  0xff;              // Todo o PORTB em nivel logico alto (módulo rele aciona em 0)
TRISC2_bit   =  0;
RC2_bit      =  1;
RC1_bit      =  1;
TRISC1_bit   =  0;
}
// Setup das interrupções
{
RCIF_bit    =  0x00;              // Flag testada na função interrupt, quando em 0 buffer vazio
GIE_bit     =  0x01;              //Global Interrupt Enable bit, habilita a interrupção global
PEIE_bit    =  0x01;              //Peripheral Interrupt Enable bit, habilita a interrupção por perifericos
RCIE_bit    =  0x01;              //Habilita a interrupção por recepção da UART
RCIP_bit    =  0x00;              //Habilita baixa prioridade da porta serial
IPEN_bit    =  0x01;              //Habilita a prioridade de interrupção
TXIE_bit    =  0x00;              //Desabilita a interrupção por transmissão

//T1CON       =  0x31;

//------------BITS DO T1CON-------------
TMR1ON_bit  =  0x01;              //Habilita o TIMER 1
TMR1IE_bit  =  0x01;              //Habilita interrupção do TIMER 1
TMR1IF_bit  =  0x00;              //Flag testada na interrupção do TIMER 1
TMR1IP_bit  =  0x01;              //Habilita alta prioridade do TIMER 1

TMR1CS_bit    =  0x00;              //Seleciona clock interno
T1CKPS1_bit   =  1;                 // Configura prescaler 1:2...
T1CKPS0_bit   =  1;                 //...interrupção a cada 102,4us
T1RUN_bit     =  0;
T1OSCEN_bit   =  1;
RD16_bit      =  1;
T1SYNC_bit    =  1;
T1OSCEN_bit   =  0;


}
//-------INICIALIZAÇÃO DO TECLADO-------

Keypad_Init();

UART1_Init(9600);
RS485Master_Init();

//______________________________________________________________________________
//---------------------INICIALIZAÇÃO DO LCD I2C---------------------------------
{
I2C1_Init(100000);
Lcd_I2C_Init();
Lcd_I2C_Cmd(_LCD_CLEAR);
Lcd_I2C_Cmd(_LCD_CURSOR_OFF);
Lcd_I2C_Out(1,3, "SYSTEM READY");
}

//______________________________________________________________________________
//------------------CHAMADAS DA FUNÇÃO SETA O TEMPO-----------------------------

//settime ();

//______________________________________________________________________________
//----------------INICIALIZAÇÃO DO MÓDULO ANALÓGICO-----------------------------

ADC_Init();
    
//______________________________________________________________________________
//--------------------------------LOOP------------------------------------------
for(;;)

(..... resto do código)

Modo USB do mestre:

//______________________________________________________________________________
//------------ENTRAR NO MODO USB QUANDO SOLICITADO (B PRESSIONADO 2 SEG.)-------

    if (kp  == 66)
    {
    delay_ms(2000);
    if (kp == 66)


        {
        HID_Enable(&HidReadBuff, &HidWriteBuff);
        delay_ms(5000);
        HID_Write("START ",64);
        Lcd_I2C_Cmd(_LCD_CLEAR);
        Lcd_I2C_Out_CP ("    MODO USB");
        kp = 0;
        }
        while (kp != 66)
        {
        Key_pad();
        Buttons();

            if(HID_Read() != 0)        //Verifica se recebeu algum dado.

              {
                  if(HidReadBuff[0] == '1')
                    {
                    SAIDA_1 = ~SAIDA_1;
                    }
                  else if(HidReadBuff[0]  == '2')
                    {
                    SAIDA_2 = ~SAIDA_2;
                    }
                  else if(HidReadBuff[0] == '3')
                    {
                    SAIDA_3 = ~SAIDA_3;
                    }
                  else if(HidReadBuff[0]  == '4')
                    {
                    SAIDA_4 = ~SAIDA_4;
                    }
                  else if(HidReadBuff[0]  == '5')
                    {
                    SAIDA_5 = ~SAIDA_5;
                    }
                  else if(HidReadBuff[0]  == '6')
                    {
                    SAIDA_6 = ~SAIDA_6;
                    }
                  else if(HidReadBuff[0]  == '7')
                    {
                    SAIDA_7 = ~SAIDA_7;
                    }
                  else if(HidReadBuff[0]  == '8')
                    {
                    SAIDA_8 = ~SAIDA_8;
                    }
                  else if (HidReadBuff[0]  == 'S')
                    {

                       dat[4] = 0;                               //limpa flag
                       dat[5] = 0;                               //limpa flag
                       Lcd_I2C_Out (2,1, "    RS-485 ON");
                       delay_ms(2000);
                       kp = 0;
                       HidReadBuff[0] = 0;

                       while (HidReadBuff[0]  != 'S' && kp != 42)
                           {
                           Key_pad();

                             if (HidReadBuff[0]  ==  1)  //Aciona Saida 1 do escravo
                                 {

                                 dat[0] = 48 ;
                                 dat[1] = 49;
                                 dat[2] = 32;
                                 RS485Master_Send (dat,3,'C');
                                 Lcd_I2C_Cmd(_LCD_CLEAR);
                                 Lcd_I2C_Out (1,1,"    MODO USB");
                                 Lcd_I2C_Out (2,1, "ENVIOU ");
                                 Lcd_I2C_Out_Cp (dat);
                                 HidReadBuff[0] = 0;
                                 }

                             if (HidReadBuff[0]  == 2)  //Aciona Saida 2 do escravo
                                 {
                                 dat[0] = 48 ;
                                 dat[1] = 50;
                                 dat[2] = 32;
                                 RS485Master_Send (dat,3,'C');
                                 Lcd_I2C_Cmd(_LCD_CLEAR);
                                 Lcd_I2C_Out (1,1,"    MODO USB");
                                 Lcd_I2C_Out (2,1, "ENVIOU ");
                                 Lcd_I2C_Out_Cp (dat);
                                 HidReadBuff[0] = 0;
                                 }

                             if (HidReadBuff[0]  ==  3)  //Aciona Saida 3 do escravo
                                 {
                                 dat[0] = 48 ;
                                 dat[1] = 51;
                                 dat[2] = 32;
                                 RS485Master_Send (dat,3,'C');
                                 Lcd_I2C_Cmd(_LCD_CLEAR);
                                 Lcd_I2C_Out (1,1,"    MODO USB");
                                 Lcd_I2C_Out (2,1, "ENVIOU ");
                                 Lcd_I2C_Out_Cp (dat);
                                 HidReadBuff[0] = 0;
                                 }

                             if (HidReadBuff[0]  ==  4)  //Aciona Saida 4 do escravo
                                 {
                                 dat[0] = 48 ;
                                 dat[1] = 52;
                                 dat[2] = 32;
                                 RS485Master_Send (dat,3,'C');
                                 Lcd_I2C_Cmd(_LCD_CLEAR);
                                 Lcd_I2C_Out (1,1,"    MODO USB");
                                 Lcd_I2C_Out (2,1, "ENVIOU ");
                                 Lcd_I2C_Out_Cp (dat);
                                 HidReadBuff[0] = 0;
                                 }

                             if (HidReadBuff[0]  ==  5)  //Aciona Saida 5 do escravo
                                 {
                                 dat[0] = 48 ;
                                 dat[1] = 53;
                                 dat[2] = 32;
                                 RS485Master_Send (dat,3,'C');
                                 Lcd_I2C_Cmd(_LCD_CLEAR);
                                 Lcd_I2C_Out (1,1,"    MODO USB");
                                 Lcd_I2C_Out (2,1, "ENVIOU ");
                                 Lcd_I2C_Out_Cp (dat);
                                 HidReadBuff[0] = 0;
                                 }

                             if (HidReadBuff[0]  ==  6)  //Aciona Saida 6 do escravo
                                 {
                                 dat[0] = 48;
                                 dat[1] = 54;
                                 dat[2] = 32;
                                 RS485Master_Send (dat,3,'C');
                                 Lcd_I2C_Cmd(_LCD_CLEAR);
                                 Lcd_I2C_Out (1,1,"    MODO USB");
                                 Lcd_I2C_Out (2,1, "ENVIOU ");
                                 Lcd_I2C_Out_Cp (dat);
                                 HidReadBuff[0] = 0;
                                 }

                             if (HidReadBuff[0]  ==  7)  //Aciona Saida 7 do escravo
                                 {
                                 dat[0] = 48;
                                 dat[1] = 55;
                                 dat[2] = 32;
                                 RS485Master_Send (dat,3,'C');
                                 Lcd_I2C_Cmd(_LCD_CLEAR);
                                 Lcd_I2C_Out (1,1,"    MODO USB");
                                 Lcd_I2C_Out (2,1, "ENVIOU ");
                                 Lcd_I2C_Out_Cp (dat);
                                 HidReadBuff[0] = 0;
                                 }

                             if (HidReadBuff[0]  ==  8)  //Aciona Saida 8 do escravo
                                 {
                                 dat[0] = 48;
                                 dat[1] = 56;
                                 dat[2] = 32;
                                 RS485Master_Send (dat,3,'C');
                                 Lcd_I2C_Cmd(_LCD_CLEAR);
                                 Lcd_I2C_Out (1,1,"    MODO USB");
                                 Lcd_I2C_Out (2,1, "ENVIOU ");
                                 Lcd_I2C_Out_Cp (dat);
                                 HidReadBuff[0] = 0;
                                 }

                             if (dat[4] != 0)
                                 {
                                  Lcd_I2C_Cmd(_LCD_CLEAR);
                                  Lcd_I2C_Out (1,1,"    MODO USB");
                                  Lcd_I2C_Out(2,1,"RECEBEU");
                                  Lcd_I2C_out(2,9, dat);

                                  delay_ms(1000);
                                  flag485 = 0;
                                  dat[4] = 0;
                                  RCIF_bit = 0;
                                 }//Fim do If
                           
                           }//Fim do While do Modo Rede USB

                      Lcd_I2C_Cmd(_LCD_CLEAR);
                      Lcd_I2C_Out_cp ("    MODO USB");
                    }

Modo Rede do escravo, aguardando comando do mestre pela RS485 normal ou por intermédio da USB.

//______________________________________________________________________________
//-----ENTRAR NO MODO REDE QUANDO SOLICITADO (5 PRESSIONADO POR 2 SEG.)---------

    if (kp == 53)
    {
    delay_ms(2000);
    if (kp == 53)
       {
      
       dat[4] = 0;                               //limpa flag
       dat[5] = 0;                               //limpa flag
       
       Lcd_I2C_Cmd(_LCD_CLEAR);
       Lcd_I2C_Out_Cp ("   MODO REDE");
       delay_ms(2000);
       
       Lcd_I2C_Cmd(_LCD_CLEAR);
       Lcd_I2C_Out_Cp    ("  Aguardando");
       Lcd_I2C_Out (2,1, "    comando");

       kp = 0;
       
       while (kp != 42)
           {
           Key_pad();
           Buttons();
           
           if( dat[4] == 255 ) //Recebeu alguma mensagem
           {
            Lcd_I2C_Cmd(_LCD_CLEAR);
            Lcd_I2C_Out_Cp("  RECEBEU");
            Lcd_I2C_Out (2,4, dat);
            delay_ms(1000);
            dat[4] = 0; //limpa a flag

            if ((dat[0] == 48) && (dat[1] == 49) && (dat[2] == 32))
            {
            SAIDA_1 = ~SAIDA_1;
            }

            else if ((dat[0] == 48) && (dat[1] == 50) && (dat[2] == 32))
            {
            SAIDA_2 = ~SAIDA_2;
            }

            else if ((dat[0] == 48)&& (dat[1] == 51) && (dat[2] == 32))
            {
            SAIDA_3 = ~SAIDA_3;
            }

            else if ((dat[0] == 48)&& (dat[1] == 52) && (dat[2] == 32))
            {
            SAIDA_4 = ~SAIDA_4;
            }

            else if ((dat[0] == 48)&& (dat[1] == 53) && (dat[2] == 32))
            {
            SAIDA_5 = ~SAIDA_5;
            }

            else if ((dat[0] == 48)&& (dat[1] == 54) && (dat[2] == 32))
            {
            SAIDA_6 = ~SAIDA_6;
            }

            else if ((dat[0] == 48)&& (dat[1] == 55) && (dat[2] == 32))
            {
            SAIDA_7 = ~SAIDA_7;
            }

            else if ((dat[0] == 48)&& (dat[1] == 56) && (dat[2] == 32))
            {
            SAIDA_8 = ~SAIDA_8;
            }

            }

            if (kp == 35)
            {
            dat[0] = 89;
            dat[1] = 69;
            dat[2] = 83;
            Lcd_I2C_Cmd(_LCD_CLEAR);
            Lcd_I2C_Out_Cp("ENVIOU AO MASTER");
            Lcd_I2C_Out (2, 1, dat);
            delay_ms(2000);
            RS485Slave_Send(dat, 3); //Envia 3 bytes ao master
            Lcd_I2C_Cmd(_LCD_CLEAR);
            Lcd_I2C_Out_Cp    ("  Aguardando");
            Lcd_I2C_Out (2,1, "    comando");
            }
              }//Fim do While do Modo Rede

         }
    Lcd_I2C_Cmd(_LCD_CLEAR);
    Lcd_I2C_Out(1,3, "SYSTEM READY");

    }//Fim da Execução do Modo Rede

A variável kp é um char da biblioteca Keypad4x4 do próprio Mikro C para leitura do teclado matricial e retornar um código em ASCII. Dat[] é para recebimento dos dados pela serial 485 e hidbuffer é o buffer da USB que por padrão funciona em modo HID.

Se estiver confuso por favor me avisem.

Anexei os prints somente da conexão RS 485, que está funcionando sem a USB junta em outra parte do código.

Se precisar posto o resto do código ou do circuito, mas creio que as parte de LCD, teclado e saída digitais não seja necessário postar.

Fico no aguardo, abraço.

ViniciusKruz · 11 de maio de 2016

Bom, vamos lá, lembrando que eu não programo em Mikro C, mas como em programação "todos os gatos são pardos", vamos tentar encontrar uma solução.

Pelo que você mencionou, o supervisório envia para o mestre que por sua vez envia para o escravo e segundo informou o escravo fica ok mas o mestre fica travado juntamente com o supervisório. Assim podemos deduzir que o problema está entre o supervisório e o mestre.

No seu programa, encontrei dois pontos que podem estar causando o travamento:

1º - quando o mestre envia para o escravo ele fica preso em um while:

while (HidReadBuff[0] != 'S' && kp != 42) { }

É preciso verificar com certeza se esta condição está realmente sendo desfeita ou então ficará travado aqui dentro

2º - Sua conexão com a porta USB está sendo reiniciada a cada vez que se pressiona determinada tecla:

17 horas atrás, Jonathan Gonzaga disse:

HID_Enable(&HidReadBuff, &HidWriteBuff); delay_ms(5000); HID_Write("START ",64);

De repente por causa disso a configuração com o Host pode estar sendo perdida, tenta abrir a conexão uma vez só e deixa ela aberta o tempo todo pra ver.

Bom, por hora é isto, checa aí e depois dá um feedback valeu.

Jonathan Gonzaga · 11 de maio de 2016

Bom, nos testes anteriores o mestre sai desse loop normalmente quando a variável kp é igual a 42, mesmo o supervisorio travando. Eu fiz esse Modo USB com um sub modo PWM e funciona também, vou mandar os prints do layout do software em C#. E sobre a conexão ficar inicializando sempre, eu tinha colocado antes pro RS485 inicializar sempre, depois que tirei reduziu o travamento. Vou testar da forma que disse, mas creio que não seja, pois logo na primeira tentativa de entrar no Modo USB e sub modo Rede ele trava. Bom, agradeço desde já, e abraço.

cpexpert · 14 de maio de 2016

não conheço muito programacao mais conheço clp, aqui na empresa os sensores e válvulas se comunica com um tal de tecnolog via corrente de 4 a 20 a http://www.tecnolog.ind.br/transdutores-para-celulas-de-carga/436-controlador-de-pesagem-tecnolog-amlc-.html que tem um micro MC como processador e vai pro clp via 485 e no clp se comunica a outro escravo via 232 e ao PC com supervisorio via rede ethernet.

Jonathan Gonzaga · 17 de maio de 2016

Bom cara eu testando aqui consegui diminuir o travamento alterando o loop dentro da leitura dos comandos enviados via USB, ou seja, só executaria os if's referentes ao buffer se ouvesse interrupção. Com isso já deu uma boa reduzida. Então testei com outra placa como escravo, e eis que quase não trava. Estava usando um protótipo feito placa universal como escravo, ai peguei a do meu colega emprestado (pois somos em 5 no grupo e mandamos fazer a placa industrialmente mesmo, ficou até bonita, azul) e funcionou bem melhor. Infelizmente tive que devolver pra ele então não terminei de testar 100%, quero simular o máximo que puder as possíveis situações ao qual o sistema possa ser submetido e com riscos de falhas. Amanhã pegarei a placa dele novamente pra mais testes. Não postei o código pois estou no trabalho. Por enquanto é isso, valeu.

ViniciusKruz · 17 de maio de 2016

Amigo, tem uma forma bem simples de se fazer um debug, coloca em certos pontos do seu programa, um comando para piscar um led, assim você sabe realmente onde no seu código o sistema está rodando. Já no supervisório, coloca uma tela para monitorar os recebimentos e transmissões, assim tem como ver exatamente onde parou.

Abraço.

Jonathan Gonzaga · 2 de julho de 2016

Bom desculpem a demora, estava finalizando e o TCC e me preparando para a apresentação. Consegui fazer funcionar ambas as comunicaçãoes normalmente, utilzei as duas placas industrializadas e não deu erro. Aprensentei o projeto normalmente.

Muito obrigado a todos que ajudaram.

Podem encerrar o tópico.