Académique Documents
Professionnel Documents
Culture Documents
Monograa de Ps-Graduao Lato Sensu apresentada ao Departamento de Cincia da Computao para obteno do ttulo de Especialista em Administrao em Redes Linux
Monograa de Ps-Graduao Lato Sensu apresentada ao Departamento de Cincia da Computao para obteno do ttulo de Especialista em Administrao em Redes Linux
Agradecimentos
A Deus por ter me dado foras nos momentos em que os obstculos pareciam intransponveis. Ao professor Wilian por ter me indicado um tema de estudo to fascinante.
vi
Resumo
Este trabalho apresenta todos os componentes de hardware e software necessrios para controle de um rob a partir de um computador tipo PC. A soluo, baseada em um sistema Linux, prov mecanismos de controle do rob Monty a partir da porta serial do computador. O rob ligado ao computador por meio de um cabo, que contm, em uma de suas extremidades, um circuito conversor de sinais entre os padres TTL e RS232. A comunicao entre o computador e o rob se d por meio do protocolo RS232. A linguagem utilizada para controlar o rob formada por um subconjunto de comando da linguagem LOGO. Esses comandos bsicos podem ser combinados de diversas maneiras, gerando, assim, um conjunto maior e mais complexo de aes por parte do rob. O sistema prev a execuo de comandos tanto de forma interativa quanto em bloco, de maneira que um conjunto de comandos pode ser previamente armazenado em um arquivo e submetido, em bloco, para execuo pelo rob.
vii
viii
minha esposa Gilzlia e minhas lhas Rebeca e Amanda, por todos os momentos que no pudemos estar juntos nos ltimos 16 meses.
ix
Sumrio
1 INTRODUO 1.1 Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . REVISO DA LITERATURA 2.1 O rob . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.1 Robs autnomos . . . . . . . . . . . . . . . 2.1.2 Robs controlados . . . . . . . . . . . . . . 2.1.3 O rob Monty . . . . . . . . . . . . . . . . . 2.2 Diferena entre microcontrolador e microprocessador 2.3 O microcontrolador PIC16F84 . . . . . . . . . . . . 2.4 Comunicao serial e os padres RS232 e TTL . . . 2.5 A linguagem LOGO . . . . . . . . . . . . . . . . . DESENVOLVIMENTO DO HARDWARE 3.1 O computador . . . . . . . . . . . . . . . . . 3.2 O rob . . . . . . . . . . . . . . . . . . . . . 3.3 Interface de comunicao . . . . . . . . . . . 3.3.1 Circuito conversor entre RS232 e TTL 3.4 Conexes . . . . . . . . . . . . . . . . . . . 1 1 3 3 3 4 5 7 9 11 13 15 15 16 16 16 17 19 19 20 20 21 22 24 26 28 29 30 30
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
DESENVOLVIMENTO DO SOFTWARE 4.1 O software do PIC16F84 . . . . . . . . . . . . . . . . 4.1.1 Acionamento dos motores . . . . . . . . . . . 4.1.2 Leitura dos sensores . . . . . . . . . . . . . . 4.1.3 Comunicao com o computador . . . . . . . . 4.1.4 Descrio dos principais trechos do programa . 4.2 O software do computador . . . . . . . . . . . . . . . 4.2.1 Mdulo de controle . . . . . . . . . . . . . . . 4.2.2 Mdulo interpretador . . . . . . . . . . . . . . 4.2.3 Mdulo de comunicao . . . . . . . . . . . . 4.3 Funcionamento do sistema . . . . . . . . . . . . . . . 4.3.1 Conexo do rob porta serial do computador xi
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
30 31 33 35 35 35 37 41 43 51
xii
Lista de Figuras
2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 2.10 2.11 3.1 3.2 3.3 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10 4.11 4.12 4.13 4.14 4.15 Exemplo de rob industrial . . . . Exemplo de rob aspirador . . . . Rob jardineiro . . . . . . . . . . Rob vigilante . . . . . . . . . . . Exemplo de rob cirurgio . . . . Rob Monty . . . . . . . . . . . . Diagrama bsico do computador . Componentes do microcontrolador Encasulamento do PIC16F84 . . . Arquitetura do PIC16F84 . . . . . Exemplo de gravador do PIC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 5 5 6 6 8 8 9 10 11 12 17 17 18 19 21 22 23 24 24 25 25 26 27 27 29 30 31 32
Tela do programa MPLAB . . . . . . . . . . . . . . . . . . . . . Circuito conversor baseado no MAX232 . . . . . . . . . . . . . . Cabo conversor . . . . . . . . . . . . . . . . . . . . . . . . . . . Arquitetura do programa do rob . . . . . . . . . . . . . . . . . . Resposta ao comando <s> . . . . . . . . . . . . . . . . . . . . . Diagrama de uxo do programa do rob . . . . . . . . . . . . . . Loop principal do programa . . . . . . . . . . . . . . . . . . . . Bloco RECEBE_COMANDO . . . . . . . . . . . . . . . . . . . Trecho do bloco EXECUTA_COMANDO . . . . . . . . . . . . . Trecho do bloco de tratamento do comando <S> . . . . . . . . . . Arquitetura do programa do computador . . . . . . . . . . . . . . Diagrama de uxo do programa do computador . . . . . . . . . . Loop principal do mdulo de controle do programa do computador Funes ExecutaPrograma e ExecutaComando . . . . . . . . . . Funo ExecPF . . . . . . . . . . . . . . . . . . . . . . . . . . . Funo EnviaPrimitiva . . . . . . . . . . . . . . . . . . . . . . . Menu principal do minicom . . . . . . . . . . . . . . . . . . . . . Congurao de Bps/Paridade/Bits da porta seiral . . . . . . . . . xiii
5.1 5.2
36 36 41 42
A.1 Circuito conversor RS232 x TTL . . . . . . . . . . . . . . . . . . A.2 Circuito impresso - lado da solda . . . . . . . . . . . . . . . . . .
xiv
Lista de Tabelas
2.1 2.2 4.1 4.2 4.3 4.4 4.5 4.6 Disciplinas do curso de robtica . . . . . . . . . . . . . . . . . . Caractersticas do PIC16F84 . . . . . . . . . . . . . . . . . . . . Controle do motor . . . . . . . . . . . . . . . Primitivas para controle dos motores do rob Sinais dos sensores retornados pelo rob . . . Comandos internos . . . . . . . . . . . . . . Primitivas . . . . . . . . . . . . . . . . . . . Comandos da linguagem LOGO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 10 20 20 21 33 33 33
xv
xvi
Captulo 1
INTRODUO
H muito que se fala em robtica e todas as facilidades e avanos que essa cincia pode trazer para o dia-a-dia da sociedade. Atualmente, algumas discusses ainda utuam em torno do mito do rob totalmente autnomo, com inteligncia prpria e at, em alguns casos, com capacidade de expressar sentimentos prprios. Entretanto, o que se tem realmente consolidado ultimamente o uso da robtica em situaes prticas de alta periculosidade ou insalubridade para o ser humano, ou em tarefas que exigem extrema preciso em sua execuo, ou simplesmente em atividades com um alto grau de repetitividade. Dentro desse espectro de possveis atuaes, os robs atualmente so utilizados, por exemplo, para desarmar bombas, limpar dutos de ar condicionado, montar placas de circuito impresso com alto ndice de integrao ou participar da linha de montagem de automveis. A partir desses exemplos possvel perceber que a aplicao prtica dos robs nos dias de hoje ainda est muito longe da viso romntica dos livros e lmes de co cientca. Apesar disso, esses incrveis equipamentos tornaram-se indispensveis em diversos setores produtivos em todo o mundo.
1.1 Objetivos
O objetivo principal do trabalho fornecer comunidade Linux uma descrio detalhada de todos os elementos necessrios para a construo de um sistema de controle remoto de um rob a partir de uma estao Linux. Como objetivos especcos podem ser citados: Construir um programa para o rob que possibilite receber os comandos do computador, execut-los e fornecer ao programa controlador o resultado da execuo desses comandos. Construir um cabo conector capaz de interconectar o rob e o computador. 1
Construir um programa controlador que seja capaz de interpretar comandos, fornecidos pelo usurio em uma linguagem de alto nvel, e envi-los ao rob, para execuo.
Captulo 2
REVISO DA LITERATURA
2.1 O rob
Conforme denio do dicionrio Aurlio, em sua 1 a edio, o termo rob originase do francs robot, que por sua vez vem do tcheco robota, palavra criada pelo escritor tchecoeslovaco, Karel Chapek, e que signica "trabalho forado". Segundo Aurlio, um dos signicados do termo rob : Mecanismo automtico, em geral com aspecto semelhante ao de um homem e que realiza trabalhos e movimentos humanos. Os robs podem ser divididos em dois grandes grupos: autnomos e controlados.
Figura 2.1: Exemplo de rob industrial Fonte: Revista Robs, n. 25, ano 2002
rob possa optar por uma determinada seqncia de passos de acordo com o valor captado pelo sensor. Um exemplo desse tipo de rob o aspirador de p automtico (Figura 2.2), j disponvel em lojas de eletrodomsticos. Esse rob atua em um espao delimitado e muda de direo sempre que encontra um obstculo no ambiente em que est atuando. Ou seja, o valor recebido dos sensores determina a direo que o rob deve tomar nos prximos movimentos. Salienta-se que esse apenas um exemplo das inmeras possibilidades dentro dessa categoria de robs. Outros exemplos de robs autnomos podem ser vistos nas guras 2.3 e 2.4.
ados por uma unidade controladora remota. Nesse caso, o meio de conexo entre o rob e a estao controladora pode ser de diversos tipos, por exemplo: cabo, ultra-som, infravermelho ou rdio. Um exemplo desse tipo o rob cirurgio, visto na Figura 2.5, onde est sendo controlado a partir de comandos dados pelos mdicos cirurgies.
Figura 2.5: Exemplo de rob cirurgio Fonte: http://www.dw-world.de/brazil/0 3367 7115_A_1184292_1_A 00.html
o publicou, em vrios pases, por meio de uma obra em forma de fascculos semanais. Essa obra, que discorre em profundidade sobre as disciplinas listadas na Tabela 2.1, foi a principal base bibliogrca para este trabalho. O Monty (ver Figura 2.6), usando toda a fora do PIC16F84, conta com os dispositivos listados a seguir, montados em um conjunto de cinco placas de CI totalmente integradas. Dois sensores de toque, posicionados na parte dianteira, um em cada lateral do rob, estando conectados s linhas RB2 e RB3. Dois sensores ticos de raios infravermelhos por reexo capazes de distin6
Fundamentos de eletrnica Microprocessadores Sensores e atuadores Comunicaes Motores Microcontroladores Robtica industrial e inteligncia articial Programao Prticas de laboratrio
Tabela 2.1: Disciplinas do curso de robtica
guir entre superfcies claras e escuras, estando conectados s linhas RB0 e RB1. Um sensor de ultra-som, conectado linha RB6. Um sensor de limiar sonoro, conectado linha RB7. Dois sensores de luz, conectados em paralelo linha RB4. Um motor acionador da pina controlado a partir da linha RB5. Dois motores conectados s linhas RA0,RA1,RA2 e RA3, responsveis pelo movimento do rob. A linha RA4 foi reservada para a utilizao de um encoder, que poderia ser usado para controlar a velocidade do rob.
Figura 2.6: Rob Monty Fonte: Revista Robs, n. 53, ano 2002
Figura 2.7: Diagrama bsico do computador Fonte: Revista Robs, n. 4, ano 2002
Figura 2.8: Componentes do microcontrolador Fonte: Revista Robs, n. 52, ano 2002
Os microcontroladores esto muito presentes no dia-a-dia das pessoas. Em (FGEDITORES, 2002), apresentada uma estimativa segundo a qual no ano de 2000, em uma residncia americana padro, encontravam-se cerca de 240 microcontroladores. Esses pequenos computadores so encontrados, por exemplo, em mquinas de lavar, fornos microondas, aparelhos de TV, celulares, controles de iluminao, alarmes contra roubo, elevadores, alarmes de incndio, ar-condicionados, em vrios componentes de um automvel e dentro do prprio computador ou em seus perifricos.
Recurso Memria de programa Memria de dados RAM Memria de dados EEPROM Nveis de pilha Jogo de instrues Tempo de execuo das instrues normais Tempo de execuo de salto Fontes de interrupo Frequencia mxima de trabalho Linhas de E/S digitais Temporizadores Voltagem de alimentao Voltagem de gravao Encapsulamento
Valor 1K x 14, tipo FLASH 68 bytes 64 bytes 8 35 de 14 bits 4 ciclos 8 ciclos 4 10MHz 13 um de usurio e um co de guarda de 2 a 6VDC de 12 a 14 VCD DIP de 18 pernas
de mquina. Porm, graas ao seu paralelismo, o microcontrolador consegue executar duas fases simultaneamente, o que faz com que uma instruo normal seja executada em apenas 4 ciclos, enquanto que as instrues de salto s podem ser executadas realmente em 8 ciclos. O programa a ser executado pelo PIC16F84 armazenado em sua memria ash, que pode ser gravada a partir de um computador, no qual o PIC deve ser conectado atravs da interface serial ou da interface paralela. O processo de gravao exige ainda um software gravador, que executado no computador, bem como um 10
circuito eletrnico responsvel por efetivamente gerar os comandos de gravao da memria ash. Na Internet possvel encontrar vrias solues de hardware para gravao dos microcontroladores da famlia PIC. Em (MADSEN, 2000) podem ser encontrados alguns exemplos. Um desses exemplos pode ser visto na Figura 2.11. Em (PALONEN, 2003) podem ser encontradas mais informaes sobre a utilizao dos microcontroladores PIC a partir do sistema operacional Linux. Nesse site possvel encontrar softwares de gravao para Linux, compilador Assembly, alm de uma srie de informaes no formato passo-a-passo sobre como gravar o PIC ou como compilar um programa.
congurados de forma idntica em ambas as pontas, sob pena da comunicao no se realizar. Ambas as pontas devem utilizar a mesma quantidade de bits de dados e de stop, assim como o mesmo tipo de bit de paridade. Um exemplo de congurao poderia ser 8N2, que signica: 8 bits de dados, 2 bits de stop e nenhum bit de paridade. Um outro parmetro muito importante no processo de comunio de dados a velocidade de transmisso. Esse valor medido em bauds, que a quantidade de bits transmitida em cada intervalo de tempo em que trasmissor e receptor esperam que seja transmido de um novo conjunto de bits (CORREIA; SILVA, 2002). Para efeitos prticos, esse valor pode ser interpretado como 1 bit por segundo, considerando-se, portanto, que cada variao de tenso representar um nico bit de dados. No padro RS232, a velocidade de transmisso deve ser escolhida dentre um dos valores padres em bits por segundo ou, simplesmente, bps: 330, 660, 1200, 2400, 4800, 9600, 19200, 38400, 57600 ou 115200 bps. O RS232 dene os seguintes nveis de voltagem para representar cada bit transmitido: Sinais de sada: +5 a +15VCD para o nvel lgico alto e -5 a -15DCV para o nivel lgico baixo. Sinais de entrada: +3 a +15VCD para o nvel lgico alto e -3 a -15DCV para o nivel lgico baixo. 12
O TTL, por sua vez, usado pelo rob, normalmente trabalha com os nveis de sinais mostrados abaixo. Sinais de sada: mnimo de +2 para o nvel lgico alto e mximo de +0.8 para o nivel lgico baixo. Sinais de entrada: mnimo de +3.5 para o nvel lgico alto e mximo de +0.8 para o nivel lgico baixo. Em (CUGNASCA, 2002) so encontradas informaes sobre comunicao serial apresentadas de forma bastante prtica e objetiva. Mais informaes podem ser encontradas em (LACERDA, 2002).
13
14
Captulo 3
DESENVOLVIMENTO DO HARDWARE
A parte de hardware do sistema de controle remoto do rob apresentado neste trabalho, consiste basicamente de trs mdulos: Computador do tipo PC: onde ser a implementado o programa de controle do rob. Rob: construdo sobre um microcontrolador PIC16F84. Cabo conversor: responsvel por interconectar sicamente os dois mdulos anteriores, alm de converter os nveis de sinais entre o padro RS232, utilizado pelo computador, e o padro TTL, utilizado pelo PIC16F84. Nas sees a seguir sero descritos cada um desses trs mdulos.
3.1 O computador
O computador utilizado nas experincias foi um Pentium 133 MHz, com 48 Mb de memria RAM, gerenciado pelo sistema operacional Linux na sua distribuio Conectiva verso 8. Para efeito do controle propriamente dito, os parmetros velocidade e memria, mencionados no pargrafo anterior, no tm muita relevncia, uma vez que a comunicao entre o computador e o rob se d em baixa velocidade e, portanto, mesmo mquinas com pouca capacidade de processamento estaro aptas a fazer o controle. Para a estao controladora apresentada neste modelo, indispensvel que ela possua: teclado, monitor e uma sada serial padro RS232. Para comunicao com o rob a porta serial do computador foi congurada no modo assncrono, com a congurao 9600 8N2: 15
Velocidade: 9600 bps bit de dados: 8 bit de paridade: Nenhum bit de stop: 2
3.2 O rob
Para atingir os propsitos do presente trabalho, algumas alteraes se zeram necessrias nas conexes eltricas do rob. Foram desabilitados o controle de pina e os sensores de luz. Essas entradas passaram, ento, a ser utilizadas para as linhas de recepo e transmisso de dados entre o rob e o computador. No projeto aqui apresentado, a gravao do programa na memria ash do PIC16F84 se deu atravs da prpria placa controladora do rob Monty. Essa placa acumula duas funes que podem ser selecionadas a partir de uma chave comutadora especca. Com a chave de seleo na posio RUN, o PIC16F84 apenas executa o programa nele gravado. Por outro lado, com a chave na posio PROG, o microcontrolador passa a gravar em sua memria os dados recebidos da porta paralela do computador. O MPLAB, software gravador fornecido juntamente com o rob Monty, funciona no sistema operacional DOS. Na Figura 3.1 pode-se ver uma imagem da tela principal desse programa. O processo de gravao do MPLAB se d por meio da porta paralela do computador.
3.4 Conexes
No lado do computador foi utilizado um conector DB9, do qual somente foram utilizados os pinos 2, 3 e 5, conectados, no circuito conversor, aos pinos de transmisso, recepco e terra, respectivamente. Essa inverso dos pinos 2 e 3 neces17
sria, visto que a linha de transmisso da sada do computador deve ser ligada linha de recepo do MAX232 e vice-versa. No lado do rob, os os de transmisso e recepo foram ligados diretamente s linhas RB5 e RB4 da placa de controle, promovendo, assim, a mesma inverso que foi realizada no conector do computador. De forma que, do ponto de vista do PIC16F84, a linha RB4 de transmisso, enquanto que a linha RB5 de recepo. Na Figura 3.3 pode ser vista uma representao esquemtica do cabo conversor, onde pode-se perceber, inclusive, que a alimentao do circuito conversor foi retirada do prprio rob.
18
Captulo 4
DESENVOLVIMENTO DO SOFTWARE
4.1 O software do PIC16F84
O programa do PIC16F84, cuja arquitetura pode ser vista na Figura 4.1, foi desenvolvido em Assembly e apresenta trs funcionalidades que sero detalhadas nas trs subsees seguintes. No programa do rob foi utilizado o conceito de primitiva: um conjunto simples e reduzido de comandos que devidamente agrupados podem criar aes mais complexas. So reconhecidas pelo rob as seguintes primitivas: <A>, <P>, <E>, <D>, <R>, <S>, <s> e <V>. A primitiva <V> retorna a verso corrente do programa do PIC. As demais primitivas sero detalhadas a seguir.
19
As primitivas aceitas pelo rob, para controle dos motores, podem ser vistas na Tabela 4.2. Primitiva <A> <E> <D> <R> <P> Comando Avanar Esquerda Direita Retornar Parar Descrio Os dois motores giram para frente O motor esquerdo gira para trs enquanto o motor direito gira para frente O motor direito gira para trs enquanto o motor esquerdo gira para a frente Os dois motores giram para trs Os dois motores param
sar sobre uma superfcie de cor preta, ser gerado o valor 1 em sua sada. Este sensor indispensvel na tarefa de seguir uma determinada trajetria marcada no solo. 3. Ultrasom. Sensor capaz de detectar movimentos. Sempre que houver movimento frente do rob, este sensor gerar o valor 0 em sua sada. 4. Limiar sonoro. Sensor responsvel por detectar um sinal sonoro acima de uma determinada intensidade. Quando detectado um determinado volume de som, este sensor retornar o valor 1. O programa do rob capaz de informar os valores desses sensores. Isso se d atravs das primitivas <S> e <s>. Os possveis valores retornados em resposta diretiva <S> podem ser vistos na Tabela 4.3. Havendo mais de um valor, eles sero separados por ",". Na Figura 4.2 pode ser vista a string retornada aps o recebimento da diretiva <s> e o signicado de cada dgito nessa string. Sinal BEsq BDir CEsq CDir USom Som Sensor O bumper esquerdo O bumper direito Contraste Esquerdo Contraste Direito Ultra-som Limiar sonoro Linha do PIC B1 B0 B2 B3 B6 B7
se deu pelo fato do PIC16F84 no possuir em seu hardware uma porta especca para comunicao serial. A implementao desse mdulo foi baseada na biblioteca rs232low, distribuda com rob Monty. A congurao dos parmetros de comunicao serial do rob foi xada dentro do prprio fonte. Os parmetros utilizados foram 8N2, ou seja, 8 bits de dados, nenhum bit de paridade e 2 bits de stop. O mdulo rs232low exporta simplesmente duas funes, alm de algumas variveis. As duas funes, RxD e TxD, so responsveis, respectivamente, por receber e enviar um caractere para o computador.
Aps a inicializao dos registradores de interrupo e de temporizao, o programa entra em seu loop principal, cujo cdigo fonte mostrado na Figura 4.4. Na 22
linha 1, o temporizador "co de guarda" zerado para evitar que o PIC16F84 seja reinicializado em situao normal de execuo. Nas linhas 2 a 4, enviado o caractere de pronto para a estao controladora. Na linha 5, o programa aguarda at que receba um caractere qualquer do computador. Nas demais linhas, o programa verica se o primeiro caractere recebido um <, signicando incio de comando. Em caso armativo, desvia para bloco RECEBE_COMANDO, caso contrrio, retorna ao incio do loop.
Na funo RECEBE_COMANDO (Figura 4.5), o programa recebe do computador o restante do comando. Caso seja um comando vlido, chama a funo EXECUTA_COMANDO. Inicialmente, nas linhas 1 a 3, h a preparao do controle do buffer de recepo. Na linha 4, o programa aguarda a chegada de um novo caractere. Nas linhas 5 a 8, vericado se o caractere recebido o indicador de m de comando (caractere >). Em caso positivo, desvia para o bloco EXECUTA_COMANDO. Nesse momento, o comando estar armazenado na varivel Buffer. Nas linhas 9 a 12 vericado o limite do buffer. Caso esteja tudo certo, nas linhas 13 e 14 o caractere armazenado no buffer. Finalmente, nas linhas 15 a 17, o ponteiro do buffer incrementado e o programa passa a esperar um novo caractere. Na Figura 4.6 pode ser visto um trecho do bloco EXECUTA_COMANDO, onde, para cada primitiva reconhecida pelo programa, executado um conjunto de comandos similares queles que se encontram nas linhas 1 a 4. Uma exceo o bloco de tratamento do comando <S>, que pode ser visto na Figura 4.7. Nas linhas 5 a 16 so testadas todas os sinais de entrada do PIC16F84, sendo chamada a rotina correspondente a cada sinal ativo. 23
25
o ExecutaPrimitiva. Isso permite que as funes vistas na Figura 4.11 chamem a funo ExecutaPrimitiva em forma de callback. Dessa maneira, toda a inteligncia de execuo das primitivas ca restrita ao mdulo de controle, que atuar em conjunto com o mdulo de comunicao para comandar a efetiva execuo da primitiva pelo rob. 27
1. A superfcie onde o rob est atuando: caso a superfcie se apresente demasiadamente lisa, poder haver deslisamento das rodas, o que provocar uma diferena no valor. 2. A intensidade da fonte de alimentao: dependendo da fora da alimentao, os motores podero girar mais ou menos rpido, gerando, assim, considerveis diferenas nos tempos. De igual forma, para gerar o delay necessrio s funes ExecPE e ExecPD, cujo parmetro um ngulo, foi utilizada a frmula 4.2: T empoDelay = (N K) 360 (4.2)
Onde N o ngulo passado no parmetro de chamada da funo, em graus, e K uma constante que representa o tempo necessrio para o rob girar 360 o .
EnviaPrimitiva: Chamada pelo mdulo de controle quando este receber uma solicitao de execuo de uma primitiva. Esta funo deve enviar a primitiva para o rob e, em seguida, receber a resposta do rob para repassla ao mdulo de controle. Finaliza: Chamada na nalizao normal do programa. Pode ser usada para executar procedimentos de nalizao da comunicao assim como liberao de variveis alocadas dinamicamente. Na Figura 4.13 pode ser vista a funo EnviaPrimitiva. Na linha 4, a primitiva enviada para o rob, que dever estar conectado porta serial apontada pelo handle hPorta. Se tudo correu bem no envio da primitiva (linhas 5 a 9), ento o programa aguardar a resposta do rob (linha 10), que ser repassada ao mdulo de controle.
A congurao do minicom muito simples. Uma vez iniciado o programa, basta digitar "CTRL-A O" para acessar o menu de congurao. A partir desse menu, selecionar a opo "Congurao da Porta Serial" (Figura 4.14). Nesse menu, devem ser conguradas: Dispositivo Serial (Opo A): Para a serial 2, informar "/dev/ttyS1". Bps/Paridade/Bits (Opo E): Devem ser selecionados os valores mostrados na Figura 4.15. Controle de Fluxo por Hardware (Opo F): Dever ser escolhida a opo "No". Controle de Fluxo por Software (Opo G): Dever ser escolhida a opo "No".
Depois de congurado o minicom, basta ligar o rob, colocando a chave "ONOFF" na opo "ON". Salienta-se que a chave "RUN-PROG" deve estar na posio "RUN". Se tudo estiver corretamente congurado, dever aparecer na tela do minicom a saudao inicial do rob, que consiste de duas linhas. Na primeira linha dever surgir a verso do programa do rob, enquanto que na segunda linha dever aparecer a string <OK>. Finalmente, dever aparecer o sinal de pronto (caractere >). A partir desse momento, o rob estar apto a receber comandos.
robo [ling logo][prot serial:/dev/ttyS1] Os dois parmetros so opcionais. Entretanto, caso o parmetro prot no seja informado na execuo do programa, o usurio dever executar o comando prot, dentro do programa, visto que, enquanto no for denido um protocolo vlido, no ser possvel estabelecer comunicao com o rob. Com relao ao parmetro ling, que dene o interpretador a ser utilizado pelo programa, o usurio poder interagir com o rob, mesmo sem deni-lo, uma vez que, por default, assumida a linguagem LOGO. Nessa primeira verso do programa, o nico protocolo aceito o serial, enquanto que a nica linguagem suportada o LOGO. No caso da linguagem, foi implementado apenas um subconjunto dos comandos do LOGO. Dessa forma, aps executar o programa, o usurio poder digitar: Um dos comandos internos mostrados na Tabela 4.4, Uma das primitivas do rob, mostradas na Tabela 4.5 ou Um dos comandos suportados pelo interpretador carregado no momento. No caso do interpretador LOGO implementado aqui, somente so suportados os comandos listados na Tabela 4.6.
32
Signicado Dene um protocolo Dene uma linguagem Solicita que o interpretador execute o programa contido em <arquivo> Finaliza o programa
Signicado Avana Gira para a esquerda Gira para a direita Retorna Para os motores Informa a verso Retorna a lista de sensores que est recebendo um evento externo Retorna o status de todos os sensores
Tabela 4.5: Primitivas
Signicado Avana N centmetros Gira N graus para a esquerda Gira N graus para a direita Retorna N centmetros Repete <comando> N vezes Escreve o resultado da primitiva X (V, S ou s)
P ausa = (InstrN ormT empoInstrN orm)+(InstrSaltoT empoInstrSalto) (4.3) onde: InstrNorm: Quantidade de instrues normais no bloco de tratamento de um caractere. TempoInstrNorm: Tempo necessrio para execuo de uma instruo normal. InstrSalto: Quantidade de instrues de salto no bloco de tratamento de um caractere. TempoInstrSalto: Tempo necessrio para execuo de uma instruo de salto. Para se obterem os valores a serem aplicados na equao 4.3, foram assumidas as seguintes constantes: Velocidade de processamento do PIC16F84: 4MHz. Ciclos necessrios para execuo de uma instruo normal: 4. Ciclos necessrios para execuo de uma instruo de salto: 8. Quantidade de instrues normais no bloco de recepo: 11. Quantidade de instrues de salto no bloco de recepo: 2. Aplicando-se ento as constantes acima no equao 4.3, foi obtido o seguinte valor para a varivel Pausa: P ausa = (10 1) + (3 2s) = 16s (4.4)
A esse valor foi acrescentada uma margem de segurana de 2s. Dessa forma, cada primitiva, cujo tamanho de 3 caracteres, ser transmitida para o rob em aproximadamente 54s.
34
Captulo 5
CONCLUSO
5.1 Resultados
Nos vrios testes realizados, o sistema de controle remoto do rob mostrou-se bastante estvel. Inicialmente foram utilizados programas emuladores de terminal serial. No ambiente grco do Linux (KDE) foi utilizado o terminal do kppp, enquanto no modo texto utilizou-se o minicom. Ambos se mostraram bastante fceis de congurar. Nesses primeiros testes, as diretivas foram digitadas diretamente no terminal, que as enviava para o rob. As respostas do rob eram capturadas e exibidas pelo prprio terminal. Esse mtodo de testes possibilitou identicar a necessidade de vrios ajustes na programao do rob. Nessa fase, foram realizadas cerca de 50 gravaes no microcontrolador. Na segunda fase de testes, j com o programa do computador em funcionamento, foram realizados testes de execuo em bloco, interpretao da linguagem de comandos e, principalmente, o envio de caracteres em uma alta taxa de transmisso de forma a determinar a real capacidade de recepo do rob. Nessa fase, conforme detalhado no captulo 4, foi necessrio acrescentar uma pausa aps a transmisso de cada caractere, o que no inviabilizou o funcionamento do sistema. Na Figura 5.1 pode ser visto o rob conectado ao computador, mas ainda sem a carcaa. Na Figura 5.2, j com o rob dentro da carcaa, est sendo feita a medio dos tempos para o clculo da sua velocidade.
5.2 Discusso
A partir deste trabalho, constatou-se a relativa facilidade de se construir um sistema de controle de um rob, desde que este seja capaz de se comunicar por meio de um protocolo de comunicao padro, tal como o protocolo serial. 35
As ferramentas necessrias para se construir o programa de controle so facilmente encontradas na forma de software livre. Neste trabalho, por exemplo, foi utilizada a linguagem C, cujo compilador normalmente acompanha as distribuies Linux. A construo do programa do rob baseado no microcontrolador PIC, embora 36
mais complexa do que a programao do computador, tambm amplamente documentada tanto na Internet como em livros especializados. Uma combinao dessas duas fontes o livro (MATIC, 2000), que pode ser encontrado em meio eletrnico gratuitamente na Web. A construo de um circuito eletrnico para gravar o microcontrolador pode ser o ponto considerado mais complexo na implementao do sistema apresentado, mas tambm podem ser encontrados vrios exemplos desse circuito na Internet. Uma alternativa para fugir do desenvolvimento do programa para o PIC e, consequentemente, da sua gravao, buscar solues tais como o BasicStep, do fabricante brasileiro Tato Equipamentos. Esse produto, cuja descrio bsica pode ser vista em (ANGNES, 2003), uma soluo integrada de microcontrolador, circuito de hardware para gravao, linguagem de programao e IDE para desenvolvimento e gravao do software.
O projeto do rob poderia ainda evoluir para um controlador PLC. Assim, o programa do computador poderia ser, na verdade, um painel de controle de equipamentos industriais. Mais informaes sobre controladores PLC podem ser encontradas em (MATIC, 2001). Como pode-se observar, as possibilidade so inmeras se consideradas todas as combinaes possveis entre os elementos do sistema. O conjunto de implementaes possveis no hardware e no software podem, enm, conduzir a aplicaes completamente distintas, cabendo, portanto, ao pesquisador, apenas decidir que rumo dever seguir.
38
Referncias Bibliogrcas
AID. Links para projetos baseados no PIC. http://www.interaccess.org/aid/links.html: [s.n.], 2003. ANGNES, D. L. Introduo ao Microontrolador Basic Step. 2003. CHELLA, M. T. Ambiente de Robtica Educacional com Logo. http://www.nied.unicamp.br/~siros/doc/artigo_sbc2002_wie_nal.PDF: [s.n.], 2002. CORREIA, L. H. A.; SILVA, R. M. de A. Redes de Computadores. 1. ed. Lavras: UFLA/FAEPE, 2002. CUGNASCA, C. E. Comunicao Serial - Reviso. 2002. FGEDITORES. Robs. 1. ed. Madrid: FG Editores, 2002. LACERDA, W. S. Arquitetura de Computadores. 1. ed. Lavras: UFLA/FAEPE, 2002. MADSEN, J. D. PIC-Programmer 2 for PIC16C84 etc. http://www.jdm.homepage.dk/newpic.htm: [s.n.], 2000. MATIC, N. PIC microcontrollers. 1. ed. Belgrade: mikroElektronika, 2000. MATIC, N. Introduction to PLC controllers. 1. ed. Belgrade: mikroElektronika, 2001. PALONEN, H. Penguin PICn. http://www.yty.net/pic/index.html: [s.n.], 2003. SALVADOR, M. B. L. Introduo ao Superlogo. http://www.dma.ufs.br/slogo.ppt: [s.n.], 2001. SWEET, M. R. Serial Programming Guide for POSIX Operating Systems. http://www.easysw.com/ mike/serial/: [s.n.], 2003. TEXASINSTRUMENT. MAX232, MAX232I DUAL EIA-232 DRIVERS/RECEIVERS. 2002. SLLS047I - FEBRUARY 1989 - REVISED OCTOBER 2002. 39
40
Apndice A
41
42
Apndice B
cblock 0x31 PontTab IdEvento Contador Eventos Buffer endc TamMaxBuffer equ (0x3F-Buffer+1)
43
ORG 0x00 goto INICIO ORG 0x04 goto INTER ORG 0x05 Tabela sCRLF dt sBE sBD sCE sCD sUS sS EQU dt EQU dt EQU dt EQU dt EQU dt EQU dt movwf EQU 0x0D,0x0A,0x00 \$ "BEsq",0x00 \$ "BDir",0x00 \$ "CEsq",0x00 \$ "CDir",0x00 \$ "USom",0x00 \$ "Som",0x00 PCL \$
EQU \$ dt "<OK>",0x0D,0x0A,0x00 EQU \$ dt "<ERR>",0x0D,0x0A,0x00 EQU \$ dt "<MONTY - Linux v1.0.2>",0x0D,0x0A,0x00 INCLUDE "RS232LOW.INC"
INICIO clrf PORTA bsf STATUS,RP0 movlw movwf ; ; movlw movwf movlw movwf movlw movwf movlw movwf b10001111 OPTION_REG b00000000 INTCON b00000000 TRISA b11101111 TRISB b00000111 TMR0
bcf STATUS,RP0 call DELAY1S call DELAY1S call Call EnviaVersao EnviaOk
44
AGUARDA_COMANDO clrwdt movlw movwf call call movlw subwf btfsc goto ; atualiza cao de guarda ; envia sinal de pronto ; ; aguarda primeiro caractere ; o caractere de inicio de comando?
goto RECEBE_COMANDO clrf movlw movwf RECEBE_CAR call movlw subwf btfsc goto movf movwf call call movf sublw btfsc goto movf movwf incf incf goto EXECUTA_COMANDO movlw movwf movf sublw btfsc goto movf sublw btfsc goto
AGUARDA_COMANDO
Contador Buffer FSR RxD > Rxdreg,W STATUS,Z EXECUTA_COMANDO Rxdreg,w Txdreg TxD EnviaEnter Contador,W TamMaxBuffer STATUS,Z ERRO Rxdreg,W INDF Contador,F FSR,F RECEBE_CAR ; Estourou o buffer? ; aguarda caractere ; o caractere de fim de comando?
45
movf sublw btfsc goto movf sublw btfsc goto movf sublw btfsc goto movf sublw btfsc goto movf sublw btfsc goto movf sublw btfsc goto goto AVANCA movlw movwf call goto ESQUERDA movlw movwf call goto DIREITA movlw movwf call goto PARA movlw movwf call goto
INDF,W D STATUS,Z DIREITA INDF,W P STATUS,Z PARA INDF,W R STATUS,Z RETROCEDE INDF,W S STATUS,Z SENSORES INDF,W s STATUS,Z sensores INDF,W V STATUS,Z ENVIA_VER ERRO
; avana
; para
46
RETROCEDE movlw movwf call goto SENSORES ; incf ; movf ; sublw ; btfsc ; goto ; bsf ; call
; retrocesso
clrf Eventos call EnviaEnter movlw < movwf Txdreg call TxD btfsc call btfsc call btfsc call btfsc call btfss call btfsc call PORTB,1 EvContrasteEsq PORTB,0 EvContrasteDir PORTB,2 EvBumperEsq PORTB,3 EvBumperDir PORTB,6 EvUltraSom PORTB,7 EvSom
movlw > movwf Txdreg call TxD call EnviaEnter goto ;----sensores ; call EnviaEnter AGUARDA_COMANDO
movlw < movwf Txdreg call TxD movlw 0 btfsc PORTB,1 movlw 1 movwf Txdreg call TxD movlw 0 btfsc PORTB,0
;EvContrasteEsq
;EvContrasteDir
47
movlw 1 movwf Txdreg call TxD movlw 0 btfsc PORTB,2 movlw 1 movwf Txdreg call TxD
;EvBumperEsq
movlw 0 btfsc PORTB,3 ;EvBumperDir movlw 1 movwf Txdreg call TxD movlw 0 btfss PORTB,6 movlw 1 movwf Txdreg call TxD movlw 0 btfsc PORTB,7 movlw 1 movwf Txdreg call TxD movlw > movwf Txdreg call TxD call goto ;----DESLIGA bcf PORTB,7 call goto ENVIA_VER call goto ERRO call goto EnviaErro AGUARDA_COMANDO EnviaOk AGUARDA_COMANDO EnviaEnter AGUARDA_COMANDO
;EvUltraSom
;EvSom
EnviaVersao AGUARDA_COMANDO
;-----------------------------------------EnviaEnter movlw sCRLF movwf PontTab goto EnviaString ;----------Subrotinas de Tratamento de Eventos --------
48
EvContrasteEsq call incf movlw movwf goto EvContrasteDir call incf movlw movwf goto EvBumperEsq call incf movlw movwf goto EvBumperDir call incf movlw movwf goto EvUltraSom call incf movlw movwf goto EvSom call incf movlw movwf goto
EnviaSeparador movf Eventos,W andwf Eventos,F btfsc STATUS,Z return movlw , movwf Txdreg call TxD return ;----Subrotina EnviaOk ----------------------------EnviaOk movlw movwf goto sOk PontTab EnviaString
49
;----Subrotina EnviaVersao ----------------------------EnviaVersao movlw sVer movwf PontTab goto EnviaString ;----Subrotina EnviaString ----------------------------EnviaString call movwf andwf btfsc return call incf movf goto return
;-----------------------------------------------DELAY1S: bcf STATUS,RP0 movlw .100 movwf Contador DELAY10MS: movlw movwf TMR0 clrwdt DEL10: btfss goto DEL10 bcf INTCON,2 decfsz Contador,F goto DELAY10MS return 0xD8 ; atualiza cao de guarda INTCON,2
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; INTER movlw . movwf Txdreg call TxD bcf INTCON,INTF retfie ; ;
end
50
Apndice C
#include "main.h" int main(int argc, char * argv[]) { char Comando[TAM_MAX_CMD+1]; char Param[TAM_MAX_CMD+1]; char Resp[TAM_MAX_CMD+1]; int Result; int CodCmd; if (!ProcessaParam(argc,argv)) { Help(argv[0]); exit(1); } do { Comando[0]=0; Result=PegaComando(Comando);
51
if (Comando[0]==<) { ExecutaPrimitiva(Comando,Resp); Mensagem(MSG_AVISO,Resp); } else { CodCmd=IdentificaComando(Comando,Param); switch(CodCmd) { case C_LING: DefineLinguagem(Param); break; case C_PROT: DefineProtocolo(Param); break; case C_EXEC: if (!ExecutaProg(Param)) Mensagem(MSG_ERRO,"ERRO!"); break; case C_FIM: Finaliza(); return(0); break; default: if (!ExecutaComando(Comando)) Mensagem(MSG_ERRO,"ERRO!"); break; } } } while (1);
return(0); } int IdentificaComando(char *Comando, char * Param) { char *TabelaCmd[]={C_S_LING, C_S_PROT, C_S_EXEC, C_S_FIM}; return(PegaIndTabela(Comando,TabelaCmd,QTD_CMDS,Param)); } int ExecutaComando(char *Comando) { switch(gLinguagem) { case LING_LOGO: return(LOGO_ExecutaComando(Comando,0)); break; } return(0); } int ExecutaProg(char *Prog) { switch(gLinguagem)
52
{ case LING_LOGO: return(LOGO_ExecutaProg(Prog)); break; } return(0); } int ExecutaPrimitiva(char *Primitiva,char *Resposta) { int IdPrimitiva,Retorno; char Resp[TAM_MAX_RESP+1]; IdPrimitiva=IdentificaPrimitiva(Primitiva); switch(gProtocolo) { case PROT_SERIAL: Retorno=SERIAL_EnviaPrimitiva(Primitiva,Resp); if (Resposta) strcpy(Resposta,Resp); return(Retorno); break; } return(0); } void Finaliza() { switch(gLinguagem) { case LING_LOGO: LOGO_Finaliza(); break; } } int DefineLinguagem(char *Ling) { int IdLing; IdLing=IdentificaLinguagem(Ling); switch(IdLing) { case LING_LOGO: if (LOGO_Inicializa(&ExecutaPrimitiva)) { Mensagem(MSG_AVISO,"O interpretador atual o %s.",Ling); gLinguagem=IdLing; return(1); } else Mensagem(MSG_ERRO,"Inicializando interpretador."); break; } return(0); }
53
int DefineProtocolo(char *Prot) { char Device[100]; char Resposta[TAM_MAX_RESP+1]; int IdProt; IdProt=IdentificaProtocolo(Prot,Device); switch(IdProt) { case PROT_SERIAL: if (SERIAL_Inicializa(Device,Resposta)) { Mensagem(MSG_AVISO,Resposta); Mensagem(MSG_AVISO, "O protocolo atual %s, no device %s.", PROT_S_SERIAL,Device); gProtocolo=IdProt; return(1); } else Mensagem(MSG_ERRO,"Inicializando porta serial"); break; } return(0); } int IdentificaPrimitiva(char *Primitiva) { char *TabelaDir[]={P_S_PARAR, P_S_AVANCAR, P_S_ESQUERDA, P_S_DIREITA, P_S_RETORNAR, P_S_SENSORES, P_S_SENS_RED, P_S_VERSAO}; return(PegaIndTabela(Primitiva,TabelaDir,QTD_PRIM,NULL)); }
int IdentificaLinguagem(char *Linguagem) { char *TabelaLing[]={LING_S_LOGO}; return(PegaIndTabela(Linguagem,TabelaLing,QTD_LING,NULL)); } int IdentificaProtocolo(char *Protocolo, char *Device) { char *TabelaProt[]={PROT_S_SERIAL}; return(PegaIndTabela(Protocolo,TabelaProt,QTD_PROT,Device)); } int ProcessaParam(int argc, char *argv[]) { int i; gProtocolo=-1; gLinguagem=-1; for (i=1; i<argc; i++) {
54
if (strcmp(argv[i],C_S_LING)==0) { if (!DefineLinguagem(argv[++i])) return(0); } else if (strcmp(argv[i],C_S_PROT)==0) { if (!DefineProtocolo(argv[++i])) return(0); } else if (strcmp(argv[i],--help")==0) { return(0); } } if (gLinguagem<0) { if (!DefineLinguagem(LING_S_LOGO)) return(0); } return(1); }
/* Projeto: robo - programa de controle do rob Monty Autor: Alxis Rodrigues de Almeida main.h: include do mdulo principal data: 01/09/2004 */
//definies gerais #define TAM_MAX_CMD 256 #define TAM_MAX_DIR 256 #define TAM_MAX_RESP 256 //definies das linguagens suportadas #define LING_LOGO 0 #define QTD_LING 1 #define LING_S_LOGO "logo" //definies dos protocolos suportados #define PROT_SERIAL 0 #define QTD_PROT 1 #define PROT_S_SERIAL "serial" //definies dos comando globais #define C_LING 0 #define C_PROT 1 #define C_EXEC 2 #define C_FIM 3 #define QTD_CMDS 4 #define C_S_LING "ling" #define C_S_PROT "prot" #define C_S_EXEC "exec"
55
#define C_S_FIM "fim" //definies das primitivas #define P_PARAR #define P_AVANCAR 1 #define P_ESQUERDA #define P_DIREITA 3 #define P_RETORNAR #define P_SENSORES #define P_SENS_RED #define P_VERSAO 7 #define QTD_PRIM 8 #define #define #define #define #define #define #define #define P_S_PARAR "<P>" P_S_AVANCAR "<A>" P_S_ESQUERDA "<E>" P_S_DIREITA "<D>" P_S_RETORNAR "<R>" P_S_SENSORES "<S>" P_S_SENS_RED "<s>" P_S_VERSAO "<V>"
0 2 4 5 6
//#define P_STR(i) P_S(i) //variveis globais int gLinguagem; int gProtocolo; //Declaraes da funes int ExecutaPrimitiva(char * Primitiva,char *Resp); int ExecutaProg(char *Prog); int DefineLinguagem(char *Ling); int DefineProtocolo(char *Prot); int EnfileiraComando(char *Comando); int ExecutaComando(char *Comando); int IdentificaComando(char *Comando, char *Param); int ProcessaParam(int argc, char *argv[]); void Finaliza();
/* Projeto: robo - programa de controle do rob Monty Autor: Alxis Rodrigues de Almeida util.c: mdulo com funes utilitrias data: 01/09/2004 */ #include <string.h> #include "util.h"
int PegaIndTabela(char *Elemento,char *Tab[],int QtdElem,char *Param) { char Elem[256]; char *pElem, *pParam; int i; strcpy(Elem,Elemento);
56
pElem=strtok(Elem,":"); if (!pElem) return(-1); pParam=strtok(0L,); if (pParam && Param) strcpy(Param,pParam); for (i=0; i<QtdElem; i++) { if (strcmp(pElem,Tab[i])==0) return(i); } return(-1); }
/* Projeto: robo - programa de controle do rob Monty Autor: Alxis Rodrigues de Almeida util.h: include do mdulo utilitrio data: 01/09/2004 */ int AbreArquivos(); void Erro(); int PegaIndTabela(char *Elemento,char *Tab[],int QtdElem,char *Param);
/* Projeto: robo - programa de controle do rob Monty Autor: Alxis Rodrigues de Almeida int_logo.c: mdulo interpretador da linguagem LOGO data: 01/09/2004 */ #include #include #include #include #include <string.h> <stdio.h> "int_logo.h" "main.h" "interface.h"
int (*pExecPrim)(char *Dir,char *p); int IdentificaCmdLogo(char *Comando); char *ProxToken(char *Ini,char *Token,char Car);
int LOGO_Inicializa(int (*ExecPrimitiva)(char *Dir,char *p)) { pExecPrim=ExecPrimitiva; return(1); } int LOGO_Finaliza() { return(1); }
57
int LOGO_ExecutaComando(char *Comando, int IndLoop) { char Cmd[TAM_MAX_CMD]; char Param[TAM_MAX_CMD]; char *pCont; int Id; if (strlen(Comando)==0) return(0); if (strncmp(Comando,"//",2)==0) return(0); pCont=ProxToken(Comando,Cmd, ); while (Cmd[0]) { Id=IdentificaCmdLogo(Cmd); switch(Id) { case LOGO_INV: ; //return(0); case LOGO_PF: pCont=ProxToken(pCont,Param, ); ExecPF(Param); break; case LOGO_PT: pCont=ProxToken(pCont,Param, ); ExecPT(Param); break; case LOGO_PE: pCont=ProxToken(pCont,Param, ); ExecPE(Param); break; case LOGO_PD: pCont=ProxToken(pCont,Param, ); ExecPD(Param); break; case LOGO_DIGA: pCont=ProxToken(pCont,Param, ); ExecDIGA(Param); break; case LOGO_REPITA: { char *FimBl,*IniBl,*Pont,*Bloco; int i,Vezes; pCont=ProxToken(pCont,Param, ); sscanf(Param,"%d",&Vezes); IniBl=strchr(pCont,[); while(*IniBl== || *IniBl==[) IniBl++; FimBl=strrchr(IniBl,]); pCont=FimBl+1; Bloco=(char *)malloc(strlen(IniBl)+1); strncpy(Bloco,IniBl,FimBl-IniBl); Bloco[FimBl-IniBl]=0; for (i=0; i<Vezes; i++) LOGO_ExecutaComando(Bloco,i);
58
free(Bloco); } break; } if (pCont) pCont=ProxToken(pCont,Cmd, ); else Cmd[0]=0; } return(1); } int LOGO_ExecutaProg(char *Prog) { FILE *hArq; char Linha[TAM_MAX_CMD+1]; hArq=fopen(Prog,"rt"); if (!hArq) return(0); Linha[0]; fgets(Linha,TAM_MAX_CMD,hArq); while (!feof(hArq)) { char *p; if (strlen(Linha)>0) { p=Linha+strlen(Linha); while (p>Linha && (*p==\n || *p==\r || *p==0)) p-; *(++p)=0; LOGO_ExecutaComando(Linha,0); } Linha[0]; fgets(Linha,TAM_MAX_CMD,hArq); } fclose(hArq); return(1); } int ExecPF(char * Param) { int Qtd; char Resp[TAM_MAX_RESP]; if (Param) { sscanf(Param,"%d",&Qtd); Resp[0]=0; (*pExecPrim)(P_S_AVANCAR,Resp); if (strncmp(Resp,"<OK>",4)!=0) return(0); sleep(DELAY_DIST(Qtd)); (*pExecPrim)(P_S_PARAR,Resp); if (strncmp(Resp,"<OK>",4)!=0) return(0); return(1); } return(0);
59
} int ExecPE(char * Param) { int Qtd; char Resp[TAM_MAX_RESP]; if (Param) { sscanf(Param,"%d",&Qtd); Resp[0]=0; (*pExecPrim)(P_S_ESQUERDA,Resp); if (strncmp(Resp,"<OK>",4)!=0) return(0); sleep(DELAY_ANG(Qtd)); (*pExecPrim)(P_S_PARAR,Resp); if (strncmp(Resp,"<OK>",4)!=0) return(0); return(1); } return(0); } int ExecPD(char * Param) { int Qtd; char Resp[TAM_MAX_RESP]; if (Param) { sscanf(Param,"%d",&Qtd); Resp[0]=0; (*pExecPrim)(P_S_DIREITA,Resp); if (strncmp(Resp,"<OK>",4)!=0) return(0); sleep(DELAY_ANG(Qtd)); (*pExecPrim)(P_S_PARAR,Resp); if (strncmp(Resp,"<OK>",4)!=0) return(0); return(1); } return(0); } int ExecPT(char * Param) { int Qtd; char Resp[TAM_MAX_RESP]; if (Param) { sscanf(Param,"%d",&Qtd); Resp[0]=0; (*pExecPrim)(P_S_RETORNAR,Resp); if (strncmp(Resp,"<OK>",4)!=0) return(0); sleep(DELAY_DIST(Qtd)); (*pExecPrim)(P_S_PARAR,Resp); if (strncmp(Resp,"<OK>",4)!=0) return(0); return(1); } return(0); } int ExecDIGA(char * Param)
60
{ int Qtd; char Resp[TAM_MAX_RESP]; if (Param) { Resp[0]=0; switch(Param[0]) { case S: (*pExecPrim)(P_S_SENSORES,Resp); break; case s: (*pExecPrim)(P_S_SENS_RED,Resp); break; case V: (*pExecPrim)(P_S_VERSAO,Resp); break; } if (Resp[0]==<) { Mensagem(MSG_AVISO,Resp); return(1); } else return(0); } return(0); }
int IdentificaCmdLogo(char *Comando) { char *Tabela[]={LOGO_S_PF, LOGO_S_PT, LOGO_S_PE, LOGO_S_PD, LOGO_S_REPITA, LOGO_S_DIGA}; return(PegaIndTabela(Comando,Tabela,QTD_CMD_LOGO,NULL)); } char *ProxToken(char *Ini,char *Token,char Car) { char *p; Token[0]=0; if (!Ini) return(0L); while(*Ini==Car) Ini++; p=strchr(Ini,Car); if (p) { int Tam; Tam=p-Ini; strncpy(Token,Ini,Tam); Token[Tam]=0; return(p+1); } else { strcpy(Token,Ini); return(0L);
61
} }
/* Projeto: robo - programa de controle do rob Monty Autor: Alxis Rodrigues de Almeida int_logo.h: include do mdulo interpretador LOG data: 01/09/2004 */ // Comandos LOGO #define #define #define #define #define #define #define LOGO_INV -1 LOGO_PF 0 LOGO_PT 1 LOGO_PE 2 LOGO_PD 3 LOGO_REPITA 4 LOGO_DIGA 5
#define QTD_CMD_LOGO 6 #define #define #define #define #define #define LOGO_S_PF "PF" LOGO_S_PT "PT" LOGO_S_PE "PE" LOGO_S_PD "PD" LOGO_S_REPITA "REPITA" LOGO_S_DIGA "DIGA"
#define K_DIST 14 #define K_ANG 11 #define DELAY_DIST(Qtd) (Qtd * K_DIST)/50 #define DELAY_ANG(Qtd) (Qtd * K_ANG)/360 // Funes exportadas int LOGO_Inicializa(int (*ExecPrimitiva)(char *Dir,char *p)); int LOGO_Finaliza(); int LOGO_ExecutaComando(char *Comando, int IndLoop); int LOGO_ExecutaProg(char *Prog);
/* Projeto: robo - programa de controle do rob Monty Autor: Alxis Rodrigues de Almeida com_serial.c: mdulo driver do protocolo serial data: 01/09/2004 */ #include #include #include #include #include #include #include <stdio.h> /* Standard input/output definitions */ <string.h> /* String function definitions */ <unistd.h> /* UNIX standard function definitions */ <fcntl.h> /* File control definitions */ <errno.h> /* Error number definitions */ <termios.h> <fcntl.h>
62
#include "com_serial.h" #include "main.h" int hPorta=-1; int ConfiguraPorta(int hPorta); int EnviaStr(char *Str); int teste(); int SERIAL_Inicializa(char *Device,char *Resposta) { int n; if (hPorta>=0) close(hPorta); hPorta=AbrePorta(Device); if (hPorta>=0) { if (!ConfiguraPorta(hPorta)) return(0); //teste(); n = EnviaStr(P_S_VERSAO); if (n==strlen(P_S_VERSAO)) { n = RecebeStr(Resposta); if (strncmp(Resposta,"<MONTY",6)==0) return(1); } } return(0); } int SERIAL_Finaliza() { if (hPorta>=0) close(hPorta); return(1); } int SERIAL_EnviaPrimitiva(char *Primitiva, char *Resposta) { int n; n = EnviaStr(Primitiva); if (n < 0) return(0); n = RecebeStr(Resposta); if (n>0) return(1); return(0); }
/************************************************ AbrePorta(char *Dev) - AbrePorta informada em "Dev". - Retorna handler do arquivo ou -1 se houve erro.
63
*************************************************/ int AbrePorta(char *Device) { int hArq; hArq = open(Device, O_RDWR | O_NOCTTY | O_NDELAY); if (hArq != -1) fcntl(hArq, F_SETFL, 0); return (hArq); } int ConfiguraPorta(int hPorta) { struct termios op; tcgetattr(hPorta, &op); op.c_ispeed op.c_ospeed op.c_ispeed op.c_ospeed &= &= |= |= ~CBAUD; ~CBAUD; B9600; B9600;
/* raw, timeout=1 segundo */ op.c_cflag |= (CLOCAL | CREAD); op.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); op.c_oflag &= ~OPOST; op.c_iflag |= IGNPAR; op.c_cc[VMIN] = 0; op.c_cc[VTIME] = 10; //timeout 1 segundo tcsetattr(hPorta, TCSANOW, &op); return(1); } int EnviaStr(char *Str) { int i,k,m; struct timespec Delay,Aux; for(i=0;i<strlen(Str);i++) { if (write(hPorta, &Str[i], 1) < 1) return(i); //Delay.tv_sec=1; //Delay.tv_nsec=0; Delay.tv_sec=0; Delay.tv_nsec=1; nanosleep(&Delay,&Aux); } return(i); } int RecebeStr(char *Str) { int Tent,Qtd; char *PontBuf,Buffer[TAM_MAX_RESP+1]; char Car; int i,Cap;
64
PontBuf = Str; Cap=0; Buffer[0]=0; while ((Qtd=read(hPorta, &Buffer, 50)) > 0) //3,10 ok { for (i=0;i<Qtd; i++) { Car=Buffer[i]; if (Car ==<) Cap=1; if (Cap) *(PontBuf++)=Car; if (Car ==>) Cap=0; } Buffer[0]=0; } *PontBuf = \0; return(PontBuf-Str); }
/* Projeto: robo - programa de controle do rob Monty Autor: Alxis Rodrigues de Almeida com_serial.h: include do mdulo do protocolo serial data: 01/09/2004 */ int SERIAL_Inicializa(char *Device,char *Resposta); int SERIAL_Finaliza(); int SERIAL_EnviaPrimitiva(char *Primitiva, char *Resposta);
/* Projeto: robo - programa de controle do rob Monty Autor: Alxis Rodrigues de Almeida interface.c: mdulo de interface com o usurio data: 01/09/2004 */ //#include <varargs.h> #include <stdio.h> #include <stdarg.h> #include "interface.h" #include "main.h" int PegaComando(char *Comando) { int Tam; write(1,">",1); Tam=read(0,Comando,TAM_MAX_CMD); if (Tam>0) Comando[-Tam]=0; // Tam=fgets(Comando,TAM_MAX_CMD,STDIN); return(Tam); }
65
void Help(char *NomeProg) { printf("Execute: %s [ling <Linguagem>] [prot <Protocolo>]\n",NomeProg); printf("\nLinguagem: logo\n"); printf("Protocolo: serial:<device da porta serial>\n\n"); printf("Exemplo: %s ling logo prot serial:/dev/ttyS1\n",NomeProg); } void Mensagem(int Tipo,char *Mens,...) { va_list PontArg; char MensExp[250]; va_start( PontArg, Mens ); // va_start( PontArg); vsprintf( MensExp, Mens, PontArg ); va_end( PontArg); switch(Tipo) { case MSG_ERRO: printf("Erro: %s\n",MensExp); break; case MSG_ADV: printf("Ateno: %s\n",MensExp); break; case MSG_AVISO: printf("%s\n",MensExp); break; } } /* Projeto: robo - programa de controle do rob Monty Autor: Alxis Rodrigues de Almeida interface.h: include do mdulo de interface data: 01/09/2004 */ #define MSG_ERRO 0 #define MSG_ADV 1 #define MSG_AVISO 2 int PegaComando(char *Comando); void Help(char *); void Mensagem(int Tipo,char *Mens,...);
66