TESTES COM MOTOR DE PASSO PM55L 048 Fiz uma programação para o Arduino trabalhar com o motor de passo unipolar (6 fios). Esse motor PM55L 048 encontrei na impressora HP 692. Mas a maioria dos motores de passo unipolar devem funcionar sem problemas. A única coisa que deve ser observada é a voltagem da bobina dele. Segue uma foto da manete feita em acrílico e MDF. Na foto abaixo ainda existe o servo motor, mas não vou mais utiliza-lo. Farei uma engrenagem para acoplar o motor de passo.
Assim que eu terminar de fixar o motor de passo, vou adicionar dois sensores de fim de curso, um cada lado da manete. para evitar problemas do motor girar sem para e quebrar minhas engrenagens. Logo vou fazer o circuito elétrico no Proteus e vou disponibilizar aqui, bem como o programa do Arduíno. Esquema elétrico para testes do motor de passo. Obs.: O circuito integrado UNL2003 suporte até 500ma de corrente. Este motor que estou utilizando precisa e 800ma. Portanto, em breve vou postar outro circuito com capacidade de gerenciar este motor. De qualquer forma usando o ULN2003 o motor funciona para testes.
Para esclarecer, o potenciometro utilizado deverá ser LINEAR, e é utilizado exclusivamente para verificar a posição da manete. O potenciometro para funcionar como joystick no Flight Simulator não esta neste projeto ainda. Eu quero dizer é que você precisará de um potenciometro para enviar as informações para o Flight simulator quando este não estiver em modo AUTO SPEED ligado. Há duas possibilidades para isso (vou trabalhar nisso mais adiante): 1- Utilizar um potenciometro duplo (mais facil), como se fosse dois em um. Neste caso você pode liga-lo no no seu joystick, ou utilizar desmontar um joystick e utilizar a placa com esses potenciometros. 2- Utilizar o mesmo potenciometro, porém o ardúino precisa ser programado para enviar os dados para o FS, e eu ainda não sei é possível utilizar isso no programa do LINK2FS. verificarei mais tarde. De qualquer forma estou me apegando apenas ao processo do motor.
Segue um video demonstrando o primeiro teste real com o servo motor S0009 comprado na DX.COM. Arduíno Uno R3, Flight Simulator X (FSX) e programa do JIM, LINK2FS.
Se você quiser testar precisa desses itens: Placa ARDUÍNO. Servo Motor. Arquivo de programação do ARDUÍNO + o programa LINK2FS, aqui. E o FSX é claro. Basta ligar o servo motor na alimentação 5v e GND, e o pino de controle no pino 12 do Arduíno. Ativar o LINK2FS_INOUT_V4J, e selecionar o THROTTLE 1. Mais um vídeo para testes do hardware, utilizando um servomotor e um potenciometro.
Hoje testei com uma manete mais completa, e como eu suspeitava, ficou um pouco pesado para o servo motor. Vou então partir para um motor passo de impressora HP 692. Aguardem.
TESTES COM MOTOR DE PASSO DE IMPRESSORA HP 692, modelo PM 55L -048-HPG9 UNIPOLAR.
Motor de passo modelo PM55L-048-HPG9 encontrado em sucatas de impressoras HP692. Unipolar
DATASHEET
A ideia inicial é utilizar este motor para mover as manetes de potência. Pretendo utiliza-lo em conjunto com um potenciometro para atuar como um servo motor.
Primeira coisa que vou fazer é pesquisar um pouco sobre engrenagens, passos, etc.
Construindo um home cockpit para uso com FSX ou FS9, utilizando o ARDUINO como base para comunicação com o hardware que se deseja.
Primeiramente quero deixar claro que este blog, mais é uma forma de manter os meus registros do que um tutorial em si. Portanto ele será construído conforme o andamento das minhas pesquisas.
O Sonho
A anos tenho o desejo de construir um home cockpit, em particular a cabine do 737NG. Gosto muito de aviação e acredito que um cockpit caseiro será para mim o auge da simulação.
Eu sei que o custo envolvido na construção de um cockpit caseiro é alto. Porém, podemos construir uma parte, voar, construir mais um pouco e assim por diante.
O impulso para começar.
Três motivos principais foram as causas de aguardar mais um pouco para começar a construir:
1 -Projetos incompletos, sem disponibilizar todas as informações para que o construtor possa começar e terminar, incluindo o dominio de todo o processo, impossibilitando modificações e adequações ao meu gosto.
2- A construção das placas de circuito impresso e a montagem das mesmas. Como eu trabalho com eletronica, sei muito bem como é trabalhoso e chato fazer placas de circuito impresso com qualidade. No final de tudo queremos é um circuito principal de qualidade e facil de manusear (principalmente para quem não tem muito tempo). Neste caso, agora temos o ARDUINO que já é bem conhecido, barato e facil de programar. É claro que os circuitos secundários terão que ser construídos.
3- E o principal, um programa interface que faça a ligação entre o Flight Simulator e o hardware. De fácil entendimento. Que neste caso é o LINK2FS, de autoria do JIM. Minha sugestão é entrarem no site dele e baixem os programas o quanto antes. É muito bom e gratuito. Também vou disponibilzá-los aqui.
Como funciona a base de tudo
Para ser breve e falando de maneira simples, o flight simulator tem um código para tudo o que acontece nele, se o Auto Pilot esta ativado, ele gera um código por exemplo A01, se esta desligado A00. O que o LINK2FS faz é apenas ler constantemente estes codigos e enviar para o Arduino. Então é só dizer (programar) ao arduino o que fazer com cada código. Simples não é? Isso serve tanto para receber informações do Flight Simulator quando enviar comando para ele fazer alguma coisa.
Requisitos mínimos para ir adiante.
Existem duas coisas importante que você não precisa dominar, mas precisa saber o básico. Também não se desespere pois a solução para tudo se encontra na Internet.
São elas:
- Programação do Arduino, baseado na linguagem C. Tem tudo pronto no site arduino.cc em reference.
- Eletrônica, talvez um pouco mais complicado, mas também tem tudo na Internet.
O restante é sua habilidade em construir coisas em madeira, metal, plástico, pintura, etc. E o principal, o desejo ver a coisa toda funcionando (não tem preço).
As placas ARDUINO. Pode ser o Arduino UNO ou o MEGA. A diferença entre os dois é que o MEGA tem mais conexões, você pode ligar mais coisas nele. A programação é igual para os dois.
ARDUINO UNO
ARDUINO MEGA
Conhecendo um pouco do ARDUÍNO.
Resumindo, ele foi desenvolvido para facilitar o aprendizado com eletrônica, programação e automação. Virou febre, e pode se fazer tudo com ele. Automatizar qualquer coisa. Fazer robôs, aviões, alarmes, automatizar casas e industrias, tudo o que você imaginar.
Ele é ligado via USB no computador, você pode utiliza-lo off-line, sou seja, programa-lo e depois utilizar ele desconectado do computador, ou ligado direto conforme sua aplicação (nosso caso).
Junto com o Arduíno, foram desenvolvidos acessórios (plaquinhas) para ele, como sensores de tudo que é tipo, display LCD ou 7 segmentos, placa de comunicação de Ethernet, Bluetooth, Wi-fi, infravermelho, ultra som, sensores de aceleração, GPS, umidade, temperatura, reles, motores, servo-motor, acelerometro, etc.
Lembrando que essas placas já são projetas para encaixar diretamente na placa do Arduino, facilitando tudo. Porém você não precisa ficar amarrado a elas, pode desenvolver o seu próprio circuito ( no meu caso).
Acessórios simples
Placa Display LCD que encaixa diretamente no Arduino
Mais acessórios
COMEÇANDO COM O ARDUÍNO.
Se você nunca usou o Arduíno antes, procure ler o site deles arduino.cc que contem tudo o que você precisa para começar. No próprio programa já vem muito exemplos de programas prontos. Inclusive o mais famoso que é fazer piscar um LED na própria placa de Arduíno (pino 13). Na internet também não faltam tutoriais. O mais importante é aprender o conceito de funcionamento do Arduíno. Vou tentar resumir o que sei. Na placa Arduíno existem pinos que você utiliza para ligar as coisas. Na hora de começar a programar a primeira coisa que você deve ter em mente é definir esses pinos, cada um deles, se será uma saída ou uma entrada. É claro que você vai definir isso baseado no que você vai ligar em cada pino. Por exemplo: Se você ligar um LED no pino 1, ele deverá ser definido como uma saída. Se for uma chave ou um botão ligado no pino 2, você define ele como entrada, e assim vai.
Uma coisa interessante é que você pode simular a placa arduíno sem possuir uma. Utilizando o software Proteus (simulador de circuitos eletronicos).
Veja este vídeo do Prof. Nélio Néves, muito bem explicado.
1º Hardware: AUTO THROTTLE
Desde que eu tive a ideia de construir um Home cockpit do 737, decidi que começaria pelo mais difícil, o auto throttle. Pelo menos para mim eu acho que é o mais difícil.
Pois bem, depois de dois dias trabalhando para criar um programa no arduino para gerenciar o auto throttle, hoje finalmente consegui.
Utilizei o simulador no Proteus, porta serial virtual, LINK2FS, FSX etc.
Fiquei muito feliz ao ver o bicho funcionando, uma alegria sem descrição.
Agora que já tenho a base de funcionamento do programa no Arduíno, vou partir para fazer os testes com equipamento real, Arduíno, Servo motor, etc.
É assim que possível vou fazer um filminho para mostrar.
Por enquanto segue uma screem shot de como estava meu computador no momento do teste.
Meu novo projeto agora é trazer o contador com a PIC 16F877a para o arduino uno R3 e o LCD keypad Shield. -Eu optei pelo arduino pelo simples fato de ter o hardware já pronto. Não havendo necessidade desenvolver e confeccionar placas de circuito impresso. Hardware necessário:
- Este LCD Keypad Shield possui 4 chaves ligadas em uma unica porta analógica do arduino. No meu projeto não vou utiliza-las, já que vou precisar de teclas maiores que ficarão em um painel maior.
- Ligação do LCD com o arduino. - Os pinos utilizados pelo LCD são os seguintes: 4,5,6,7,8,9 (São os pinos no arduino, não no LCD). É assim que ele vem ligado ao Arduino. O importante é o programa saber disso. Que neste caso será a seguinte instrução no começo do programa:
// select the pins used on the LCD panel LiquidCrystal lcd(8, 9, 4, 5, 6, 7); significa que estes pinos são do Arduino e estão reservados para o LCD. - Uma mudança importante neste projeto em relação ao antigo, é a inclusão do item PEÇAS GRAVADAS. Ou seja, além do valor TOTAL digitado e o valor da contagem, aparecerá no display o número de peças já gravadas. Exemplo do display:
T.: 1000 X1 F.: 999 G:1 Onde T.: é TOTAL de peças, X1, contará de uma-em-uma. F.: Peças que Faltam gravar e G: peças Gravadas. Pinos utilizados no arduino: 1 -> SAÍDA - RELÊ 1 - faz a mudança do botão de PULSO para o arduino controlar. Quando o arduino estiver desligado ou ligado mas sem estar programado, o botão PULSO estará ligado diretamente na máquina laser. Como se o Arduíno não existisse. Eu fiz isso para o caso de você querer gravar sem contar peças. Assim que o botão Enter é pressionado pela primeira vez, este relê ativa e transfere o botão PULSO direto para o Arduíno. Ou seja, ao pressionar o botão PULSO, o comando vai para o pino 12 do Arduíno, e o Arduíno vai acionar o RELÊ 2, que fará o papel do botão PULSO para a máquina Laser. 2 <- ENTRADA - Botão SOBE, ligado a chave e da chave ao GND. Aciona com nivel 0. 3 <- ENTRADA - Botão ENTER, ligado a chave e da chave ao GND. Aciona com nivel 0. 4,5,6,7,8,9 Reservado ao LCD. 10 - Back Light do LCD. 11 -> SAÍDA - BUZZ, aciona a busina do alarme. 12 <- ENTRADA - Sinal de PULSO, ativa em nivel 0. 13 -> SAÍDA - RELÊ 2 - ativa a gravação.
- Meu forte não é programação, porém vou explicar um pouco sobre o funcionamento deste aqui.
- Como todo mundo já deve saber, uma das primeiras coisas e, as mais importantes na programação é a definição de variáveis. É por onde tudo começa.
- Eu defini as seguintes variaveis:
- q1, q2, q3 e q4, serão utilizadas para armazenar o número que se deseja contar, cada uma representa uma casa decimal. Q1 é milhar, Q2 é centena, Q3 é dezenas e Q4 unidade.
No programa fica assim:
int long q1=0;
int long q2=0;
int long q3=0;
int long q4=0;
As outras são: conta, total e m.
O principio de funcionamento é começar utilizando a variável CONTA para escolher a casa do milhar (q1), assim que o valor é escolhido o valor de CONTA vai para q1. O próximo passo é escolher a centena (q2), novamente utilizando CONTA e passando para q2, e assim sucessivamente até chegar em q4.
Exemplo: Você escolheu a quantidade de 1000 peças a serem gravadas. Então as variáveis ficariam assim:
- Primeiramente CONTA=0, utilizando a tecla SOBE o valor de CONTA foi para 1, apertando ENTER, o valor CONTA foi para q1, q1=conta;
- Segundo passo, CONTA=0, aperando ENTER, q2=conta;
No final teremos:
-q1=1
-q2=0
-q3=0
-q4=0
Valor total 1000.
Agora precisamos colocar esse valor de 1000 na variável CONTA.
Usamos a seguinte expressão:
conta=(q4*1000)+(q3*100)+(q2*10)+q1;
Agora a variável CONTA tem o valor de 1000, e assim podemos começar a contagem.
A formula é bem simples, conta=conta-1; toda vez que temos o sinal de PULSO diminuímos 1 do valor de CONTA.
Porém eu utilizo um parâmetro a mais que é possibilidade de contar até de 4 em 4.
Você vai notar que ao iniciar o programa (ligar o Arduino), o primeiro parâmetro a ser definido é o MULTIPLO, por padrão ele já vem com o valor de 1, e vai até 4. Isso significa que eu posso querer gravar até quatro peças ao mesmo tempo, ou seja, toda vez que eu apertar o botão PULSO uma vez, ele vai descontar esse valor do total.
Usando como base o valor acima que é 1000, e com múltiplo setado em 4 a conta fica assim: conta=conta-4;
Neste caso eu utilizo a variável m para armazenar este valor.
conta=conta-m;
.....
Eu gostaria de comentar um pouco sobre uma rotina interessante, que na qual custei para desenvolver, porém é bem simples, mas como eu disse no começo, programação não é meu forte.
A questão é a seguinte: O programa dentro do chip do arduino roda muito rápido, milhões de ciclos por segundo, e como o programa fica lendo cada porta de entrada do chip em cada ciclo, temos um problema de repetição da tecla repetida.
Exemplo: Temos o botão SOBE ligado ao pino 2, cada vez que apertamos o botão o nivel do sinal deste pino vai para ZERO. O programa percebe isso e aceita como a tecla pressionada, no próximo ciclo de clock e vai ler novamente este pino e se estiver em ZERO, vai entender que a tecla foi pressionada novamente, mas na verdade não foi, pois o processo é tão rápido que nem deu tempo de soltar a tecla. Mesmo que você pressione rapidamente a tecla, a contagem no display será muito rápida.
Para resolver isso eu fiz uma rotina que após a tecla ser pressionada, ele não passa adiante enquanto ela não for solta.
1ªif (digitalRead(Btnsobe)==LOW)
2ª{
3ªconta=conta+1;
4ªsobe3:
5ª ;
6ªif (digitalRead(Btnsobe)==LOW)
7ª{
8ª goto sobe3;
9ª }
Funciona assim, na primeira (1ª) linha diz o seguinte: SE a entrada digital(digitalRead), pino 2 (Btnsobe) for igual a ZERO (que é o botão SOBE pressionado), então execute o que está dentro da chave { , que é somar 1 no valor da variavel CONTA (3ª) e vá adiante.
Na 4ª linha tem um ponto de GOTO, ele vai passar direto a primeira vez.
Na 6ª linha está o segredo, ele vai verificar novamente se o botão continua pressionado, e como está pressionado e vai executar a 8ª linha que é desviar para a rotina sobe3; na 4ª linha, e vai ficar neste loop até a o botão for solto, só então ele vai continuar o programa.
MONTAGEM - Imagem da finalização da caixa e botões. - A chave preta rotativa do lado direito e os dois botões pequenos, não fazem parte do projeto Arduino.
Video de funcionamento.
Só quero lembrar que a chave preta do lado direito e os dois botões pequenos (verde e vermelho) não fazem parte do esquema elétrico do projeto Arduíno.
#include <LiquidCrystal.h>
// Ultima alteração em 22/08/2014
// Foi alterado o valor do delay do botão pulso de 300 para 180 ms.
// select the pins used on the LCD panel
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
// define some values used by the panel and buttons
int lcd_key = 0;
int adc_key_in = 0;
long int q1=0 ; // Armazena o primeiro digito da contagem
long int q2=0 ;
long int q3=0 ;
long int q4=0 ;
long int total=0; // valor total de gravação
long int conta=0; //usado para contagem
int m=1; // multiplos
int t=1;
int Btnsobe=2; //botão sobe usará o pino 2
int BtnEnter=3; //Botão Enter usará o pino3
int BtnPulso=12; //Botão Pulso usará o pino 12
int buzz=13; // buzzer no pino 11
int relay1=1; //rele1
int relay2=11; //rele2 pulso
int sobe=0;
int enter=0;
int pulso=0;
int caso=0;
int pronto=0;
int gravados=0;
#define btnRIGHT 0
#define btnUP 1
#define btnDOWN 2
#define btnLEFT 3
#define btnSELECT 4
#define btnNONE 5
// read the buttons
int read_LCD_buttons()
{
adc_key_in = analogRead(0); // read the value from the sensor
// my buttons when read are centered at these valies: 0, 144, 329, 504, 741
// we add approx 50 to those values and check to see if we are close
if (adc_key_in > 1000) return btnNONE; // We make this the 1st option for speed reasons since it will be the most likely result
// For V1.1 us this threshold
if (adc_key_in < 50) return btnRIGHT;
if (adc_key_in < 250) return btnUP;
if (adc_key_in < 450) return btnDOWN;
if (adc_key_in < 650) return btnLEFT;
if (adc_key_in < 850) return btnSELECT;
// For V1.0 comment the other threshold and use the one below:
/*
if (adc_key_in < 50) return btnRIGHT;
if (adc_key_in < 195) return btnUP;
if (adc_key_in < 380) return btnDOWN;
if (adc_key_in < 555) return btnLEFT;
if (adc_key_in < 790) return btnSELECT;
*/
return btnNONE; // when all others fail, return this...
}
void setup()
{
pinMode(Btnsobe,INPUT_PULLUP); // Habilita o pullup do pino 2, significa que está em nivel alto sempre, mudara para 0 quando o botão SOBE ligar este pino ao terra(GND).
pinMode(BtnEnter,INPUT_PULLUP); // Enter
pinMode(BtnPulso,INPUT_PULLUP); // Pulso, origem do sinal que vai ativar a máquina. É este sinal que ele vai ler para diminuir o valor da contagem.
pinMode(buzz,OUTPUT); // Saida do buzzer
pinMode(relay1,OUTPUT); // saida rele 1
pinMode(relay2,OUTPUT); // Saida rele 2 - pulso
digitalWrite(buzz,LOW);
digitalWrite(relay1,LOW);
digitalWrite(relay2,LOW);
lcd.begin(16, 2); // Inicia a biblioteca do LCD
lcd.setCursor(0,0); // Coloca o cursor na primeira linha e primeira coluna.
lcd.print("Contador Arduino"); // Imprime a mensagem CONTADOR ARDUINO
lcd.setCursor(0,1); // Coloca o cursos na SEGUNDA linha e coluna 0
//lcd.print(millis()/1000); // display seconds elapsed since power-up
lcd.print("Multiplos:");
}
void loop()
{
delay (100);
lcd.setCursor(12,1); // move to the begining of the second line
lcd_key = read_LCD_buttons(); // read the buttons
sobe=digitalRead(Btnsobe); //faz a leitura da porta digital 2 (Botão Sobe)
enter=digitalRead(BtnEnter);
pulso=digitalRead(BtnPulso);
lcd.print(m);
if (sobe==0) // Verifica se o botão SOBE foi ativado, ativa em ZERO(LOW) - obs.: Aqui tb poderia se usado if (digitalRead(Btnsobe)==LOW)
{
m=m+1; // Soma mais um à variavel M que é a contagem dos MULTIPLOS
m1: // Ponto de retorno do GOTO, usado para verificar se a tecla permanece acionada
;
if (m>5)
{
m=1; // se o valor de M for maior que 5, volta a ser 1
lcd.setCursor(12,1);
lcd.print(m);
}
if (digitalRead(Btnsobe)==LOW) // verifica se o botao continua apertado, se continuar, vai para o loop M1 logo acima.
{
goto m1;
}
}
if (digitalRead(BtnEnter)==LOW) // Defini o valor do MULTIPLO e entra na rotina para definir a quantidade de peças.
{
digitalWrite(relay1,HIGH);
lcd.clear(); //Limpa o LCD
lcd.setCursor(10,0);
lcd.print("X");
lcd.print(m);
lcd.setCursor(0,1);
lcd.print("Qtda: ");
Enter:
;
if (digitalRead(BtnEnter)==LOW) //Verifica se a tecla Enter continua acionada.
{
goto Enter;
}
conta=0;
do //rotina para definir a quantidade
{
delay (100);
if (digitalRead(Btnsobe)==LOW)
{
conta=conta+1;
sobe4:
;
if (digitalRead(Btnsobe)==LOW)
{
goto sobe4;
}
}
if (conta >9)
{
conta=0;
}
lcd.setCursor(12,1);
lcd.print(conta);
if (digitalRead(BtnEnter)==LOW)
{
q4=conta; // armazena o valor escolhido para casa de milhar na variavel Q4
enter4:
;
if (digitalRead(BtnEnter)==LOW)
{
goto enter4;
}
pronto=1;
}
} while (pronto==0);
conta=0;
pronto=0;
do //rotina para definir a quantidade
{
delay (100);
if (digitalRead(Btnsobe)==LOW)
{
conta=conta+1;
sobe3:
;
if (digitalRead(Btnsobe)==LOW)
{
goto sobe3;
}
}
if (conta >9)
{
conta=0;
}
lcd.setCursor(13,1);
lcd.print(conta);
if (digitalRead(BtnEnter)==LOW)
{
q3=conta; // armazena o valor escolhido para casa de milhar na variavel Q4
enter3:
;
if (digitalRead(BtnEnter)==LOW)
{
goto enter3;
}
pronto=1;
}
} while (pronto==0);
conta=0;
pronto=0;
do //rotina para definir a quantidade
{
delay (100);
if (digitalRead(Btnsobe)==LOW)
{
conta=conta+1;
sobe2:
;
if (digitalRead(Btnsobe)==LOW)
{
goto sobe2;
}
}
if (conta >9)
{
conta=0;
}
lcd.setCursor(14,1);
lcd.print(conta);
if (digitalRead(BtnEnter)==LOW)
{
q2=conta; // armazena o valor escolhido para casa de milhar na variavel Q4
enter2:
;
if (digitalRead(BtnEnter)==LOW)
{
goto enter2;
}
pronto=1;
}
} while (pronto==0);
conta=0;
pronto=0;
do //rotina para definir a quantidade
{
delay (100);
if (digitalRead(Btnsobe)==LOW)
{
conta=conta+1;
sobe1:
;
if (digitalRead(Btnsobe)==LOW)
{
goto sobe1;
}
}
if (conta >9)
{
conta=0;
}
lcd.setCursor(15,1);
lcd.print(conta);
if (digitalRead(BtnEnter)==LOW)
{
q1=conta; // armazena o valor escolhido para casa de milhar na variavel Q4
enter1:
;
if (digitalRead(BtnEnter)==LOW)
{
goto enter1;
}
pronto=1;
}
do // Rotina para a contagem das peças
{
if(digitalRead(BtnPulso)==LOW) // verifica se chegou o pulso para gravação
{
delay(120); // tempo que o botão deve ficar pressionado
if(digitalRead(BtnPulso)==LOW) // O botão precisa ficar pressionado por mais tempo para ir adiante, evita ruido.
{
digitalWrite(relay2,HIGH);
delay(300);
digitalWrite(relay2,LOW);
digitalWrite(buzz,HIGH);
delay(100);
digitalWrite(buzz,LOW);
conta=conta-m; // diminui do total a ser gravado o valor do Multiplo
if ((conta-m<=0)||(conta-m>65500)) // Vai acionar o alarme quando estiver na penúltima gravação
{
digitalWrite(buzz,HIGH);
delay(250);
digitalWrite(buzz,LOW);
}
}
if ((conta<=0)||(conta>65500)) //qdo chegar a ZERO ou passar dele, encerra a contagem, FIM
{
conta=0; // deixa a contagem em ZERO
lcd.setCursor(13,0);
lcd.print("FIM");
//lcd.setCursor(4,1);
//lcd.print("0 ");
//lcd.setCursor(10,1);
//lcd.print(total);
digitalWrite(buzz,HIGH);
delay(3000);
digitalWrite(buzz,LOW);
digitalWrite(relay1,HIGH);
}
delay(250);
lcd.setCursor(4,1);
lcd.print(" ");
lcd.setCursor(4,1);
lcd.print(conta);
lcd.setCursor(10,1);
lcd.print("G:"); // G de peças já gravadas
gravados=total-conta; // coloca na variavel GRAVADOS a diferença do TOTAL, ou seja, as peças já gravadas
lcd.print(gravados); // imprime quantas peças já foram gravadas
p:
;
if(digitalRead(BtnPulso)==LOW) // verifica se o botão continua pressionado
{
goto p;
}
Como parte do meu projeto CONTADOR DE PEÇAS. Precisei utilizar duas funções via teclado para ajudar a automatizar o meu processo de gravação a laser. Estás duas funções(teclas) serão ligadas em dois botões na mesma caixa do Contador, para facilitar. No programa de gravação a laser as funções que eu vou ativar são: WORK MODE e RED LASER. Normalmente o operador da máquina utiliza o mouse para clicar, e isso não é nada eficiente. A solução é utilizar a placa interna do teclado e ligar apenas os dois botôes.
Nesta nova postagem eu vou mostrar o máximo possivel os passos da montagem da versão 3.6. Comegando pela caixa que vai abrigar o projeto. Vou utilizar a caixa PB 900 da PATOLA. R$ 26,81 As medidas da furação interna, ou seja, as distancias entre os pinos são: 87 mm e 109 mm. São 6 pinos na parte interna, usarei 4 para fixar a placa PCB.
- A furação farei na máquina de corte a laser. A precisão é melhor. - Vou utilizar uma placa de fenolite dupla face de 10X15 cm. - Conectores PCF para ligação da placa PCB. São bons de trabalhar, e baratos.
- Para ligação externa, utilizarei os conectores LS 3003 4 vias, LS 3004 5 vias e LS 3005 6 vias. São conectores metálicos e resistentes. A fixação será feita na parte trazeira da caixa. Usarei estes conectores para ligação da máquina a ser controlada.
- Continuando, a imagem abaixo mostra o recorte da tampa da caixa em MDF, papel, e plástico. Eu substituí a tampa original de plástico por esses materiais. Tudo cortado no laser CO2.
Note que a camada de plástico que é a primeira, não tem o corte do LCD, justamente para ser uma proteção para o LCD, mais o papel que tem as impressões.
Próximas fotos já com os botões push button instalados.
Na caixa.
Nesta foto a caixa está deitada, mas eu a utilizarei em pé, fixado na máquina.
Foto da placa PCB feita em serigrafia, dupla face, ainda sem furos, envernizada.
O verniz não ficou muito legal, mas funciona.
Tamanho 10X15 CM.
Desenho em 3D da placa montada. Esta placa foi confeccionada errada, sendo assim logo postarei o projeto correto.
Para corrigir a falha de desenvolvimento da placa, fiz uma placa separada para os relês.
No conector J2, os pinos 1 e 2 são ligados ao interruptor tipo push-button para acionar a gravação. Quando o Contador estiver desligado, ou ligado mas não programado para contar, o relê RL1 mantêm o botão de acionamento da gravação ligado diretamente na máquina laser. Como no projeto original sem o Contador.
Ao ligar a contagem, o RL1 é ativado desligando o botão da máquina laser e ligando diretamente no Contador no pino 5 da 16F877A. A PIC fica lendo o estado deste pino, quando o pino 5 passar do nivel 0 para 1 (+5v), botão pressionado, a PIC vai levar ao nivel 1 o pino 36 por uma fração segundos, e ativar o RL2, que por sua vez ativará a máquina laser. A verdadeira função do RL2 é fazer o papel do botão de acionamento da gravação.
Os conectores J1 e J2 são do tipo PCF, conforme foto acima.
Efetuei várias modificações no projeto inicial e agora estou na versão 3.5 Mudanças: -Removi o LED de aviso, já que não preciso dele, pois tenho todos os dados no display. -Removi o botão DESCE bem com as rotinas sobre ele no programa em C. -Adicionei um botão para ativar o motor de passo(projeto futuro). -Adicionei um sensor óptico para interagir com o motor de passo (fim de curso). Ainda em testes. -Adicionei um aviso sonoro curto apó a penúltima gravação. Para avisar o operador em caso de gravações múltiplas. Desta forma ele vai checar se precisa preencher o gabarito com todas as peças, ou somente o necessário. -Mudei o valor dos resistores dos transistor de acionamento dos reles para 100 Ohms. -Adicionei um capacitor eletrolítico de 100uf na entrada do PULSO. Para evitar ruídos. Aqui todos os arquivos desta última versão. Obs.: A parte de acionamento do motor de passo ainda será testada.
CONTADOR V2.5 - Devido a necessidade de melhorias no projeto, criei a versão 2.5. Mudanças: Hardware: - Adicionei mais um relê. Fiz essa mudança porque o botão de acionamento era duplo, as vezes dava mal contato e acionava apenas o Contador e não a máquina, e vice-versa.
- O que estou fazendo agora é a partir do momento que o contador entra em ação (quando o ENTER for pressionado pela última vez) o relê RL01 ativa e interrompe o acionamento manual da máquina Laser. Deste ponto em diante será o Contador quem vai acionar a máquina utilizando o relê RL02. O RL02 fará o papel do botão de acionamento. Desta forma não terei o risco de uma mal contato, gerando falhas na contagem. Afinal, precisa ser confiável. Se houver a necessidade de utilizar a máquina Laser sem contar peças, sem utilizar o Contador, basta pressionar o RESET. Neste esquema temos o botão B1 que é PULSO, e B2 que é da máquina laser. Note que eles não tem ligação elétrica entre si. Obs.: Esses dois botões são acionados juntos mecanicamente, ou seja, são duas chaves independentes mas acionadas por um único botão. Chamados Botão de Acionamento tipo Cogumelo.
Mudanças no programa:
- Eu mantive o botão DESCE, mas não estou utilizando, nem montei ele no protótipo, já que a contagem com o botão SOBE zera automaticamente depois de chegar no 9.
- MULTIPLOS é principal mudança, foi incluído logo no início do programa, e seu valor já começa com 1, e no meu caso vai até 4. Isso quer dizer que eu posso querer gravar até 4 peças ao mesmo tempo. Ou seja, cada aperto do botão quatro peças são gravadas ao mesmo tempo pela máquina.
Ex.: Eu costumo gravar chaveiros e as vezes a quantidade é grande, eu tenho um gabarito para 4 chaveiros. Eu posiciono os quatro e máquina grava todos de uma só vez, mas com único acionamento.
Neste caso o calculo é feito através da variavel M.
conta=conta-m;
Ex.: Eu defini MULTIPLOS de 4 e 100 peças para gravar.
No começo a variável CONTA tem o valor 100. Depois de apertar o botão PULSO, a variável CONTA ficará com 96. Conforme conta abaixo.
Um problema que eu tive no começo foi que ao pressionar um botão, o mesmo repetia como se estivesse sendo pressionado várias vezes rapidamente. Já que o programa corre muito rápido no processador, era um resultado esperado.
Eu resolvi esse problema desta forma:
- Verifica SE o BOTÃO foi pressionado, se foi, executa uma função, algo como acrescentar uma valor numa variável. Logo em seguida dentro do próprio laço existe mais uma verificação SE o BOTÃO foi pressionado. Neste laço enquanto o BOTÃO estiver pressionado, ele volta e faz um loop para verificar o botão novamente. Quer dizer que enquanto eu não soltar o botão ele não continuará. Isso o impedira de repetir.
Veja a rotina abaixo. Obs.: Isto é apenas uma parte do programa.
if (pulso==1) // verifica se o botão PULSO foi pressionado
{
rele2=1; //liga o relê que aciona a contagem da máquina, faz o papel do botão original
conta=conta-m;// diminui a contagem
delay_ms(100); // da um tempo antes de desligar o rele.
rele2=0; // desliga o relê
p: // sub-rotina, para detectar o botão PULSO pressionado continuamente
;
if (pulso==1) //se o boão continuar pressionado
{
goto p; // fica em loop até ser solto
}
}
Neste link tem um vídeo mostrando o funcionamento do protótipo. Incluindo o final da contagem.
