Translate

sábado, 24 de agosto de 2013

KEYPAD - Senha de acesso

Galera, depois de algum tempo, consegui!!! Nem acreditei quando funcionou.

A programação não é difícil, o difícil foi fazer sem copiar, eu peguei a ideia e apliquei no que eu queria, esta sketch passou por 18 versões até rodar, penso em melhorar o programa criando algumas sub-rotinas e até usando a biblioteca de keypad do arduino, mas o meu desafio era justamente este, usar o minimo de recursos prontos.

Bom mas vamos lá. Se trata de um keypad sendo monitorado pelo Serial Monitor (em breve será um display de LCD) e que respeita a senha para ativar um dos pinos de saída.

Abaixo tem 2 vídeos o primeiro com o monitor e o segundo com a montagem.

Recomenda-se o uso de fones de ouvido.







Segue abaixo o código fonte:

const int N_ line = 4;                          // define a quant de linhas      
const int N_ column = 3;                        // define a quant de colunas
int check = 0;                                 // garante que só 3 tecla compõe a senha
char password_default [3] = {'1', '5', '9'};     //senha de acesso
#define actionPin 10                               // ativa acionamento se password ok
#define wrongPin 12                             // LED de erro na senha
#define test_ led 13
#define start 11
int pause = 1000;
int solenoide = 3000;
int reset;
int count;
int debounce_Time = 25;


const char keymap[N_line][N_column] = {     // montagem da matriz OBS.: const(constante) char(caracteres)
  { '1', '2', '3'  } ,
  { '4', '5', '6'  } ,
  { '7', '8', '9'  } ,
  { '*', '0', '#'  }
};

const int Pins_line[N_line] = { 2, 3, 4, 5 };     // define quais os pinos representam linha
const int Pins_column[N_column] = { 6, 7, 8 };    // define quais os pinos representam colunas

void setup()
{
    Serial.begin(9600);
       for (int row = 0; row < N_line; row++)      //| configura as linhas com entrada
       {                                           //|a cada loop do for, um valor é incrementado, ou seja row = 3
            pinMode(Pins_line[row],INPUT);         //|o Pins_line[3] será configurado com entrada
            digitalWrite(Pins_line[row],HIGH);     //|ativação do resistor de pull up
        }
     
        pinMode(actionPin,OUTPUT);
        pinMode(wrongPin,OUTPUT);
        pinMode(test_led,OUTPUT);
        pinMode(start,INPUT);
        pinMode(start,HIGH);
             
       for (int column = 0; column < N_column; column++)     //| configura as linhas com saída
       {                                                     //|a cada loop do for, um valor é incrementado, ou seja column = 3
           pinMode(Pins_column[column],OUTPUT);              //|o Pins_column[3] será configurado com saída                              
           digitalWrite(Pins_column[column],HIGH);           //|ativação o pinMode correspondente
       }
}


void loop()
{
  if(digitalRead(start) == 1 && check == 0)
    {
     digitalWrite(test_led,HIGH);
     Serial.println("  ");
     Serial.println("Waiting Password");
     count=1;
     reset=0;
    }

  if(count == 1)
    {
       while(check < 3 && reset == 0)
          {
         
               
                 char key = getKey();     // criou sub rotina
               
                    if(key != 0)
                    {
                      if(key == password_default [check])
                         {
                           check += 1;
                           Serial.print(" X ");
                                       
                         }
                       else if(key != password_default [check])
                         {
                           Serial.println("                                  ");
                           Serial.println("Password Wrong ->  wait 5 seconds . . .");
                           digitalWrite(test_led,LOW);
                           digitalWrite(wrongPin,HIGH);
                           delay(pause);
                           digitalWrite(wrongPin,LOW);
                           check = 0;
                           count = 0;
                           reset = 1;
                         }
                    }
       
          }
   
     }
  if(check == 3)
    {
       digitalWrite(test_led,LOW);
       digitalWrite(actionPin,HIGH);
       delay(solenoide);
       digitalWrite(actionPin,LOW);
       check = 0;
       count = 0;
     }
}
           

////////////////////////////////////sub rotina 1//////////////////////////////////////////////

char getKey()                          // inicializando a subrotina
{
     char key = 0;                     // define key em valor 0                    
     for(int column = 0; column < N_column; column++) // teste o valor de N_column  
     {
         digitalWrite(Pins_column[column],LOW);          // DLG os pinos conforme valor column
     
             for(int row = 0; row < N_line; row++)  // teste o valor de N_column
              {
                      if(digitalRead(Pins_line[row]) == LOW)  // faz comparação, caso verdadeiro, inicia o comando
                      {
                          delay(debounce_Time);              //delay 20ms
                          while(digitalRead(Pins_line[row]) == LOW);   // valor lógico baixo,                            
                          key = keymap[row][column];                 //mapeia a matriz                            
                       }
               }
         digitalWrite(Pins_column[column],HIGH);   // aciona o pino corresp da coluna
    }
      return key;     // traz o valor encontrado
}

///////////////////////////////////////////end//////////////////////////////////////////////////////

Comando "for"


Pessoal, recentemente me perguntaram como funciona o comando "for" ... após algum tempo pensando eu percebi que não sabia explicar; por isso, resolvi fazer esta portagem.

Antes de falarmos sobre o comando for, podemos aproveitar a opotunidade para esclarecer mais alguns pontos do sketch apresentado abaixo.

Vamos começar pelo comando "#define start 11"; este comando é a mesma coisa que "int start = 11;".

Ou seja, estamos determinando que o pino 11 do arduino, vai assumir a identificação de "start", assim, não corremos o risco de confundir o numero 11 dentro da programação com o pino 11 do arduino.

No caso da variável flip_flop, ela assumi o valor 1 assim que é chamada no nosso programa.

Observe que não há diferença entre definir se a variável representa um pino ou um valor numérico; isso pode causar dúvidas aos menos experientes na hora de entender um programa que ele não tenha elaborado. Fazer as definições de pinos do arduino utilizando o comando "#define xxxx" pode ajudar a deixar o programa mais claros.

A outra forma de visualizar, é observando dentro do "void setup" as configurações que alternam entre INPUT e OUTPUT, onde INPUT são os pinos de entrada e OUTPUT os pinos de saída.

Os pinos de entrada devem receber um resistor para limitar o pico de tensão no hardware; esse resistor pode ser ativado via programação utilizando o comando :

  pinMode(start,INPUT); // define pino como entrada
  pinMode(start,HIGH);  // ativa resistor de pull up

Mais abixo temos a inicialização da comunicação serial entre o monitor do IDE e as atividades do hardware.

Serial.begin(9600);  // inicia a comunicação serial

Enfim o comando "for". Neste programa, o comando "for" só será inicializado quando o teste lógico do comando "if" for TRUE, ou seja, o pino start tiver um valor lógico alto. Logo após esta confirmação, o pino action será acionado, como próximo passo, chama o comando "for" que permanecerá executando até que os valores definidos sejam alcançados; ou seja, o pino action permanecerá com valor lógico alto enquanto o comando "for" não terminar a execução.

Dentro do comando "for" temos que definir o valor inicial da variável, o valor limite, e o encremento, veja abaixo com fica o comando:

 for(check=0 (valor inicial); check<=10 (valor limite); check++ (encremento))

Enquanto o valor de check não chegar a 10, começando a contagem de 0 o comando "for" ficará executando, enquanto isso nada mais é executado, apenas o "for".

Bom nada é melhor para tirar as dúvidas do que ver o que lemos em execução, para aqueles que farão a montagem e o teste, segue o esquema de ligação:

PINO 11 -->> Este deve ser ligado inicialmente ao zero volt
PINO 13 -->> Não requer ligação, pois na placa do arduino já possui um led no pino 13

Após carrgar o programa inicie o Serial Monitor do IDE (link para baixar o IDE) e acione o start, ligando o PINO 11 (start) no 5 Vcc.

Observe os detalhes que devem ser configurados para o funcionamento do Monitor Serial:

numero da COMM e BAUD RATE (link's para entender o que é baud rate: 1 e 2

O video abaixo o video apresenta o que deve ser apresentado no Monitor Serial.



Logo abaixo o sketch que executa este programa.

/*

ELABORADO POR: TONI
DATA         : 24/08/13

*/

// INICIO DO PROGRAMA
#define start 11    // definindo a variavel como pino 11 do arduino
#define action 13
int check;          // declarando uma variavel
int flip_flop = 1;  // declarando uma variavel com valor definido inicialmente
int z = 1000;
int w = 332;

void setup()
{
  pinMode(start,INPUT); // define pino como entrada
  pinMode(start,HIGH);  // ativa resistor de pull up

  pinMode(action,OUTPUT); // define pino como saída

 Serial.begin(9600);  // inicia a comunicação serial

}

void loop()
{
  if(digitalRead(start) == 1) // testa o pino
  {
    digitalWrite(action,flip_flop); //ativa o pino com valor na variável
    for(check=0; check<=10; check++) // faz uma contagem de 0 a 10
    {
      Serial.print("wait ");
      delay(w);
      Serial.print(". ");
      delay(w);
      Serial.print(". ");
      delay(w);
      Serial.print(". ");
      delay(z);
      Serial.println(check);
      delay(z);
    }
    digitalWrite(action,!flip_flop);  // submete ao pino o valor inverso da variável
 
  }

}

//////////////FIM DO PROGRAMA/////////////////////////

sexta-feira, 16 de agosto de 2013

Linguagem de programação

Atualmente, encontramos uma grande variedade de linguagens de programção, entre as mais comuns, podemos citar:

- C
- C++
- Assembly
- Basic
- LADDER entre outras ...

cada fabricante tem uma ou mais opções, principalmente os CLP's. Vale lembrar que o LADDER nada mais é do que uma forma de dar uma cara para o ambiente de programação; no final tudo vira linguagem de maquina.

Este post vai apresentar uma nova aplicação para um equipamento. Basicamente estamos falando de um controlador de demanda, que nada mais é do que um CLP que recebeu um firmware dedicado para uma determinada função. O ambiente de programação fica mais simples e amigavel, com isso o uso é especifico.


Para quem conhece o funcionamento de um controlador de demanda, sabe que basicamente, a plicação é a seguinte:

Leitura dos pulsos da concessionária;
Mensurar a demanda com base nas informações anteriores;
Atuar com o descarte de carga se necessário.


Com o passar do tempo, apresentou-se a necessidade de ter mais informações, tais como, medições setorial para rateio, leituras de utilidades, seja por sinal digital ou analógico. Para tal fim, os controladores de demanda foram agregando funções. Alem de um canal de comunicação ABNT-CODI e um cartão de saídas de controle, é possível encontrar equipamentos com entradas digitais e analógicas, porta ETH, RS-232, RS-485, GSM entre outras. A aplicação que veremos no video abaixo, é com o equipamento HX900.

 Este hadware possui um ambiente de programação avançado, que disponibiliza uma linguagem escrita conhecida como HXVM. Esta aplicação extra, permite avivar a criatividade e personalizar a aplicação do equipamento.

Neste caso em especial, a ideia foi a seguinte: 

Utilizar as entradas de pulso para ler status e definir um novo parametro de controle para a demanda, com isso, foi possível alternar o controle de demanda entre a concessionária e o grupo gerador. Com um detalhe, quando falamos em grupo gerador, estamos considerando cinco maquina de 200KW cada uma, desta forma o controlador vai ter que identificar a quantidade de geradores em operação e definir um novo set point de demanda para controle.

O código fonte está no video.

Para facilitar o entendimento veja o video abaixo:




Abaixo a tabela exemplifica a lógica utilizada no programa.


Configurando um device MODBUS


Em um outro post deste blog já falamos um pouco sobre o funcionamento da rede serial RS-485, porem nada de prático foi apresentado.

Nesta postagem o foco é apresentar os componentes físicos e o passo a passo como exemplo; para isso será necessário alguns dispositivos:

-> um dispositivo com RS-485 (para leitura de registros é necessário que o dispositivo seja MODBUS-RTU);

-> desktop ou notebook com saída serial RS-232 (já é possível encontrar conversores USB / RS-485, pois a porta serial RS-232 esta caindo em desuso);

-> conversor RS-232 / RS-485;

-> conhecer o dispositivo a ser configurado;

-> software de programação e/ou leitura;

-> conceito básico da rede serial RS-485.


>>>>   link das postagens: rede serial rs-485 /  transmissao de dados em rede serial


Por comodidade os equipamento utilizados nesta atividade são da Schneider Electric, sendo este:

-> Módulo ERREP (conversor de protocolo ABNT-CODI p/ RS-485);
-> Software AtosBrio Soft.


Para facilitar o entendimento teremos dois vídeos, um para apresentar o passo a passo no software, e outro da montagem dos hardwares

 Recomenda-se o uso de fones de ouvido caso o som esteja baixo.

Manuseio do software - 1º Video



                           



Montagem dos hardwares - 2º video