ASM51

Boa tarde pessoal, gostaria de uma opinião de vocês desenvolvi uma interface onde o usuário sem noção de programação colocaria escolhe de 30 pinos quais são entradas e saídas e faz a programação setando se a entrada vai estar em nível lógico alto ou baixo e quais saídas tenho que ligar isso tudo gráficamente.
Agora que vem a pergunta como isso pode ser colocado no micro controlador, ja tenho um programa que pode receber essas informações pela serial mas como deixar de uma forma fácil para execução.
Pensei em gerar essa configuração gráfica em linha de comando como:
cpp code

if (entrada1 == 1)
   {
   saida1 = 1;
   }
else
   {
   saída1 = 0;
   }

agora como colocar isso dentro do microcontrolador sem que o usuário escreva o programa para microcontrolador.
Pensei em gerar um arquivo hex através dos mnemonicos mas não sei o processo de conversão assim conseguiria gerar o arquivo inteiro e gravar via bootloader, ja pensei em converter esse IF em informações para guardar na memória ou mesmo em vetor mas creio que não vá funcionar.
Gostaria de saber se alguém ja fez algo parecido e como resolveu.
Muito obrigado.

Considerando que voce está usando o PIC, isso ficaria até mais fácil, pois o registrador TRIS é quem define a direção, e além disso, as saídas do PIC são mapeadas bit-a-bit, ou seja, voce pode definir o valor de uma saída independentemente de afetar os demais pinos da mesma porta. Partindo pro ado pratico, a sua abordagem me parece correta até o momento.

Tenho uma interface onde o usuário escolhe se ela vai ser um Joystick ou Teclado USB,caso seja um teclado USB,o usuário escolhe,atravez de um programa, quais teclas ou combinações de teclas cada botão da interface vai ser.
Neste caso o meu programa no PIC lê as primeiras posições da Eeprom interna e deste modo sabe qual vai ser o comportamento da interface.
Voce pode fazer o mesmo,faça uma rotina onde toda vez que o PIC é inicializado procure os bytes da Eeprom interna e carrega o registrado TRIS.

Veja este tcc que orientei
http://dsc.inf.furb.br/tcc/index.php?cd=6&tcc=1641
Pode te ajudar

Bom dia tcpipchip, vtrx, andre_teprom muito obrigado pelas orientações que postaram
andre_teprom, vtrx eu ja faço isso com os tris eu mando as configurações pela serial, gravo na eprom e o microcontrolador se reconfigura sem nenhum problema.
tcpipchip li o trabalho que por sinal é muito bom parabéns lá ele pega o ladder e converte para a linguagem C para depois compilar, seria uma possibilidade eu através da interface gerar toda a programação em C para recompilar, ai precisaria ter junto com a aplicação um compilador.
O que estava pensando era gerar só as linhas das regras que o usuário define como por exemplo

Código: Selecionar todos

if (entrada1 == 1)
{
     saida1 = 1;
}
else
{
      saida1 = 0;
}

gerar somente essa parte de cima e não compilar tudo novamente.
Mas mesmo assim obrigado pelas atenções

Acho que o amigo está a confundir eprom com eeprom. A 1ª, sim deve recompilar e reenviar/reprogramar e tal. A 2ª não necessariamente. Existe função pra manipulá-la. Algo como eepromread() eepromwrite(). Use algum byte do buffer da serial pra gravar na eeprom e/ou controlar o tris e enviar/receber pro/do port
Algo como...

Código: Selecionar todos

TRISB=buffer[0];
PORTB=buffer[1];
TRISA=buffer[2];
CMCON=buffer[3];
ADCON1=buffer[4];
a=PORTA; putc(a);
//e por aí vai


ou do gênero...
Obviamente sua aplicação gráfica controla bit a bit e o usuário é um bom conhecedor de cada 1...

No caso, acho que a questão é mais da parte do PC do que do PIC.
Do lado do microcontrolador, o código HEX gravado apenas lê o frame recebido.

No caso da interface gráfica, essa vai enviar o que deve ser acionado via uma sequencia pre-definida.
A muito tempo atrá fiz algo baseado num exemplo do site do Rogercom, de um programa se não me engano chamado "rcomacess", onde o usuário acendia/apagava LEDs de uma placa via clicando num botão com o mouse.

Boa tarde Zé muito obrigado pela informação, gravando na eeprom eu ja estou vamos imaginar o cenário 1:
O usuário na interface escolhe que o pino 1 é entrada e o pino 12 é saída imaginemos que o pino 1 esta na RB0 e o 8 esta na RD0, o mesmo usuário vai clicar no pino 1 e definir pino 1 = 1, pino 8 = 1 e vai arrastar um sobre o outro. A interface gera o seguinte código

Código: Selecionar todos

TRISB=0b00000001
TRISD=0b00000000
if (pino1 == 1)
{
    pino8 = 1;
}
else
{
    pino8 = 0;
}

esses tris gravar na eeprom para chamar depois de boa o problema é montar o código com o if, vamos ao cenário 2
O usuário na interface escolhe que o pino 1 e pino 2 é saída e o pino 8 é entrada imaginemos que o pino 1 esta na RB0 o pino 2 esta na RB1 e o pino 8 esta na RD0, o mesmo usuário vai clicar no pino 8 e definir pino 8 = 0, no pino 1 = 1 e pino 2 = 0 e vai arrastar um sobre o outro. A interface gera o seguinte código

Código: Selecionar todos

TRISB=0b00000000
TRISD=0b00000001
if (pino8 == 0)
{
    pino1 = 1;
    pino2 = 0;
}
else
{
   pino1 = 0;
   pino2 = 1;
}

Perceba que os tris foi só configurar a nova sequencia mas olha a linha do if como mudou é essa linha das condições que venho tentar ver com os senhores caso ja tenham passado por isso como chegaram a resolver.
Não queria fazer a interface recompilar para depois gravar no hardware (via gravador ou bootloader) essas linhas das novas condições vão por serial pois tenho varias placas ligadas formando uma rede e só a que for endereçada vai receber essa condição do usuário (mas esse processo já esta todo funcionando sem problema) o único problema é como gerar essa linha de condição dinamicamente.
Lembrando que acima foi um exemplo mas o usuário poderia montar várias condições

Código: Selecionar todos

if (pino5 == 1)
{
     pino8 = 1;
}
else
{
    pino8 = 0;
}
if (pino6 == 1 && pino7 == 1)
{
     pino10 = 0;
}
else
{
     pino10 = 1;
}

Lembrando que a interface já gera essa sequencia do código C mediante as configurações que ele fizer como embutir dinamicamente dentro do microcontrolador
Muito obrigado

Nessa linha, eu gostava do Parsic: http://www.parsicitalia.it/visual-parsi ... micro.html

Pode ser uma referência para teu projeto.

Mais ou menos isso Kraft, aquelas linhas do if deveriam ser processadas dinamicamente no hardware sem que o usuário gere o hex e grave na placa e sim vão através da serial. O que esta pegando é como gerar um processo dinâmico de uma sequencia de condições, não sei se é melhor armazenar em memória depois carrega em matriz para processar ou se tem uma forma mais simples.
Mas muito obrigado pela idéia desse software que passou

oi. acho que confundi sua confusão. O que quis dizer foi confusão entre flash eprom de programa com a eeprom interna que o mc manipula. A 1ª com bootloader ou programador, a 2ª em no runing time. Melhorou 1 pouco?
Desculpe minha burrice. De fato não sei se entendi direito.. vc está querendo arrastar coisas e gerar um código c pra rodar?
Minha proposta supramencionada seria algo bem minimalista como: ao ligar fica num loop inicial aguardando o "pacote de setup" por assim dizer. Depois um comando digamos "run" faria a conexão entre pc e mc. O pacote de setup imagino algumas caixas de verificação e/ou campos com bytes na tela do pc. Com os if´s vc pode até mesmo fazer miniprogramas customizáveis com delays, loops e alguma frescurinha qualquer., enfim...
Se vc estiver tentando fazer algo tipo isso http://www.microchip.com/mplab/mplab-code-configurator pra rodar um tempo real infelizmente não te alcanço

Me fez lembrar.. há muitos (e muitos) anos (mesmo) tive contato com um tal de code warrior que tinha uns feijõszinhos coisa bem fruta mesmo pra montar uma aplicação pruns mc da motorola. Ficava fácil mas gerava um código cavalar tanto em c como o que ia gravar. Acho que ainda existe este treco

Sandro,


Talvez a sua maior dificuldade é que voce está tentando implementar essa funcionalidade inline, mas o ideal seria criar funções proprias pra isso, sendo executadas sequencialmente. Suponhamos que o PIC receba do PC uma sequencia de 3 comandos, cujos pacotes ( frames ) vou batizar como abaixo :

• [CONFIGURA_AS_DIRECOES_DOS_PINOS]
• [ENVIA_VALOR_DE_SAIDAS]
• [REQUISITA_LEITURA_DAS_ENTRADAS]

E o PC deve aguardar pela resposta do PIC:

• [RECEBE_LEITURA_DAS_ENTRADAS]

Essa negociação é o que chamamos de protocolo de comunicação num nivel mais alto, independentemente de como tenha sido definido a formatação interna dos pacotes no nivel mais baixo ( STX/CMD/DATA/CRC/ETX/etc... ).

Já no lado o PIC, após receber esses comandos, voce estaria executando as seguintes funções:
cpp code

main()
   {
   Mapeia_IOs( valor_do_TRIS );
   Envia_valor_para_saidas( valor_das_Saidas );
   if ( comando_para_ler ) 
        valor_das_Entradas = Le_valor_das_Entradas();
   }

As 3 variaveis acima, valor_do_TRIS , valor_das_Saidas e comando_para_ler, voce deve extrair dos frames recebidos do PC. Já o valor valor_das_Entradas, o PIC deve empacotar e enviar adiante para o PC.

Enfim, o programa tem de ser separada em camadas para simplificar o projeto, e voce não se perder na programação, focando na lógica...

Sempre deixa a 'programação pesada' para o programa no PC fazer.

boa tarde vtrx tudo bom, isso mesmo esse protocolo de comunicação entre o micro e o pc para enviar os pacotes esta tudo funcionando a grande questão é como montar dinamicamente as linhas dos if no microcontrolador para que o mesmo teste esses pacotes que vem do computador já que o micro não vai ficar se comunicando com o pc on line simplismente o pc envia os pacotes e a partir dai não há mais comunicação. Entendi e concordo com os pacotes que falou, agora como montar as condições (ifs) de uma forma dinãmica em função desses pacotes recebidos essa a questão.
muito obrigado

olá amigo. Vou tentar dizer a mesma coisa com outras palavras. Pelo que percebo não precisa nada disso de if´s. Voce pode simplesmente transportar os dados dos campos do seu aplicativo diretamente pros registros e ports do mc. O pulo do gato é fazer um buffer que vem da serial com (p.ex.)
start, byte_do_TRISA, byte_do_TRISB, byte_do_TRISC, byte_do_CMCON, byte_do_ect, .... stop
O dinamismo estaria em monitorar por interrupção se o byte é start pra reprogramar tudo. De fato é 1 pouco + que isso mas penso ser esta a essência.

Bem .. pelo menos é isso que visualizo aqui do meu confortável ponto de vista

Faça um print da sua aplicação e cole aqui pra gente ver. Parece ser um projeto bem bacana