quarta-feira, 23 de agosto de 2017

LCD Siemens A75 Mod:LPH9116-1 101x80 colorido

Olá pessoal na falta de dinheiro para comprar um LCD Nokya 511, achei na minha sucata um Display usados nos Siemens o modelo que tinha em mãos é o LPH-9116-1.
Depois de muita pesquisa na net achei um driver para o modelo LPH8731-1C que são compatíveis.
O site do qual encontrei o driver é Russo, deu um pouco de trabalho para traduzir algumas coisas, mas o google translation deu uma ajuda..
links de referencias Russo:
http://cxem.net/mc/mc218.php
http://cxem.net/mc/mc221.php

Link Sketch Arduino:
Sketch Arduino compactado









Vídeo do Display funcionando:
https://youtu.be/ysg0fALJKfk




Espero que ajude alguém! se gostou compartilhe e deixe seu comentário!
Compartilhe do canal no Youtube de um like e se inscrea-se
https://www.youtube.com/user/MultiLumens

sábado, 22 de outubro de 2016

Bobinador Caseiro

Montando engenhocas essa foi para enrolar bobinas usando material de sucata da oficina.
A intenção aqui é passar o código  usado para controlar o driver L298. que serve como um ponte H











/*
sistema automatizado de enrolamento

de bobinas
TCC Automação Industrial 4º Modulo
Desenvolvido por Paulo R. R. Furlan
*/
#include <16f877a.h>
#use delay(clock=2000000)
#fuses HS,NOWDT,PUT,LVP,NOCPD
//#include <regs_16f87x.h>
#include <timer0.h>


#include <mod_lcd_877a.c>
//#include <mod_lcd_4x20.c>
#define BT_STOP_START      pin_C0

//botao liga/desliga
#define BT_BOBINA         

pin_C1 //botao bobina
#define BT_FIADOR         

pin_C2 //botao fiador
#define BT_INC             

pin_C3 //botao incrementa
#define BT_DEC             

pin_C4 //botao decrementa
#define BT_ESPIRAS         

pin_C5 //botao decrementa
#define FIM_CURSO_M2      pin_B0

//Chave fim de curso motor M2
#define ENCODER_M1         

pin_B1 //Entrada encoder motor M1
#define ENA               

  pin_B2 //Pino Enable L298 M1
#define ENB               

  pin_B3 //Pino Enable L298 M2
#define IN1               

  pin_B4 //Pino IN1 L298 M1
#define IN2               

  pin_B5 //Pino IN2 L298 M1
#define IN3               

  pin_B6 //Pino IN3 L298 M2
#define IN4               

  pin_B7 //Pino IN4 L298 M2
#define LED_FIM_CURSO      pin_D0

//Led fim de curso sinalizacao
#define LED_BOTOES         pin_D1

//Led Botoes presionados


unsigned long int hor=0;
int min=0;
int seg=0;
int seg2=0;
int min2=0;
int conta=0, conta1=0;
long int num_voltas_cont,num_espiras;
long int temp_bobina,temp_fiador;

static boolean led;
static boolean flag_desligado;
static boolean flag_ligado;
static boolean

flag_sentido_rotacao_M1;
static boolean

flag_sentido_rotacao_M2;
static boolean flag_stop_start;
static boolean

flag_encoder_M1,flag_encoder_M1_ativo

;

float resultado1;
//***********************************

*************************************

***
//tratamento do timer contagem de

tempo
#int_timer0
void trata_t0()
{
//****INICIO CONTAGEM DE

SEGUNDOS****************

static int conta;
    set_timer0(131+get_timer0

());//contagem de tempo 1 segundo
    conta++;
if(conta==125)
{
    conta=0;
    led=!led;
    //output_bit(PIN_b3,led);
    }

if(conta==0)seg=seg+1;

if(seg>59)
{
    seg=0;
    min=min+1;
    }
    if(min>59)
    {
        min=0;
        hor=hor+1;
        }
}

//************FIM INCREMENTO DE

TEMPO*************

//MENSAGEM DE APRESENTACAO
void mensagem_apresenta()
{
    int pos;
   
    pos=16;
   
lcd_escreve('\f');
    while(pos>=1 && pos<=16 ||

pos>=239 && pos<=255)
    {
    lcd_pos_xy(pos,1);
    printf

(lcd_escreve,"*EMBUBINADOR****\r");
    delay_ms(500);
    pos=pos-1;
    }
    return;
    }

//***********************************

*************************************

***

*************************************

***
//*******************MENSAGEM

CONTAGEM DE

TEMPO***************************
void mensagem_tempo()
{
    int pos=0;
    pos=1;
    lcd_pos_xy(1,3);
    printf(lcd_escreve,"Tempo=

%lu:%u:%u",hor,min,seg);   
   delay_ms(500);
   delay_ms(500);
    return;
    }
//***********************************

*************************************

***
//===buzzer====================
void buzzer()
{
int i;

 for (i=0; i<=100; i++)
{
output_high(pin_a5);//sinal Alto

buzzer
delay_us(400);
output_low(pin_a5);//sinal baixo

buzzer
delay_us(400);
output_high(pin_a5);//sinal Alto

buzzer
delay_us(400);
output_low(pin_a5);//sinal baixo

buzzer

}

return;
}
//inicio do programa
void main()
{
long int valor;
int pos, linha;
int32 val32;
int i;
//int b1= 1;
delay_ms(10);
set_tris_a(0x02);//Entrada sensor

ampraragem do CI L268
set_tris_b(0x00);//Saida para o CI

L198
set_tris_c(0x3F);//entradas Botoes
set_tris_e(0x00);
set_tris_d(0x00);
setup_timer_0(RTCC_INTERNAL|

RTCC_DIV_128);
enable_interrupts(GLOBAL|int_timer0);
setup_adc(ADC_CLOCK_INTERNAL);
set_adc_channel(1);
set_timer0(131);
num_espiras=0;//zera numeros de

espira
output_b(0x00);//zera saida port B
output_c(0x00);//zera saida port C
output_d(0x00);//zera saida port D
output_e(0x00);//zera saida port E
flag_encoder_M1=0;//desativa encoder

M1
flag_encoder_M1_ativo=1;//seta

encoder em ativo
num_voltas_cont=0;//zera o contador

de espiras
num_espiras=200;// inicia numero

minimo de espiras
flag_sentido_rotacao_M1=1; //inicia

rotação do motor M1 sentido horario
flag_stop_start=0; //inicia sistema

com stop ativado
temp_bobina=40;// seta minimo de

tempo para partida do motor M1
temp_fiador=80;// seta mnimo de tempo

para partida do motor M2
flag_desligado=0;
flag_ligado=0;
seg2=59;
min2=1;
lcd_ini();
delay_ms(10);
mensagem_apresenta();
//lcd_escreve("\f");
// loop enquanto true
output_low(ENA);//sinal Alto enable1

RB2
output_low(ENB);//sinal Alto enable2

RB3
output_low(IN1);//sinal baixo M1 RB4
output_low(IN2);//sinal baixo M1 RB5
output_low(IN3);//sinal baixo M2 RB6
output_low(IN4);//sinal baixo M2 RB7
delay_ms(300);

  while(true)
   {
/*      
if(pos<=0 || pos>=20)pos=1;
if(linha<=0 || linha>=4)pos=1;
set_adc_channel(1);
valor=read_adc();
if(valor)valor+=1;
val32=valor * 5 +((int32)valor *

113)/128; //converte tensao em

temperatura
resultado1=val32;
*/
//******Entrada encoder

M1*******************
if(input(ENCODER_M1))
{
if(!flag_encoder_M1 &

flag_encoder_M1_ativo)
{   
flag_encoder_M1=0;// desativa flag

encoder M1
delay_ms(300);   
}
else
{
flag_encoder_M1=1;// ativa flag

encoder M1
flag_encoder_M1_ativo=1;   
    }
           
delay_ms(30);   
    }

if(!input(ENCODER_M1))

flag_encoder_M1_ativo=0;
delay_ms(30);

//******** Entrada Fim de curso Motor

M2*******************
if(!input(FIM_CURSO_M2))
{

flag_sentido_rotacao_M2=!

flag_sentido_rotacao_M2;
output_high(LED_FIM_CURSO);// Liga

led fim de curso
delay_ms(300);
output_low(LED_FIM_CURSO);// Desliga

led fim de curso
   
    }
       
if(flag_sentido_rotacao_M2) // Seta o

sentido do Motor M2 horario
{
output_high(IN3);//sinal Alto IN3

L298 RB6
output_low(IN4);//sinal baixo IN4

L298 RB7       
    }
    else                   //

Seta o sentido do Motor M2 anti-

horario
    {
output_high(IN4);//sinal Alto IN4

L298
output_low(IN3);//sinal baixo IN3

L298       
        }
if(!input(FIM_CURSO_M2))
{
output_high(ENB);   
if(flag_sentido_rotacao_M2) // Seta o

sentido do Motor M2 horario
{
output_high(IN3);//sinal Alto IN3

L298 RB6
output_low(IN4);//sinal baixo IN4

L298 RB7       
    }
    else                   //

Seta o sentido do Motor M2 anti-

horario
    {
output_high(IN4);//sinal Alto IN4

L298
output_low(IN3);//sinal baixo IN3

L298       
        }           
delay_ms(temp_fiador);       
output_low(ENB);

}
output_low(LED_FIM_CURSO);       

   
//***********************************

*******************   
//*******Entrada Botao

Stop/Start********************   
if(!input(BT_STOP_START))// Testa

botao start/stop se pressionados
{
   
flag_stop_start=!flag_stop_start;//

Altera estado Liga/Desliga sistema
delay_ms(500);
loop1:
output_high(LED_BOTOES);// Liga Led

botoes
delay_ms(500);           
if(!input(BT_STOP_START))// Testa

botao start/stop se presionado
{
    if(flag_stop_start)// Testa

flag start/stop se ativado
    {
        flag_stop_start=1;
    }   
    if(!flag_stop_start) // Testa

flag start/stop se Desativado
    {
        flag_stop_start=0;
    }
    delay_ms(500);   
goto loop1;
}
output_low(ENA);//sinal Alto enable1

RB2
output_low(ENB);//sinal Alto enable2

RB3
output_low(IN1);//sinal baixo M1 RB4
output_low(IN2);//sinal baixo M1 RB5
output_low(IN3);//sinal baixo M2 RB6
output_low(IN4);//sinal baixo M2 RB7
output_low(LED_BOTOES);
delay_ms(50);   
    }   
//***********************************

****************************       

   
if(flag_sentido_rotacao_M1)//Testa

flag sentido do motor
{
    //sentido horario
output_high(IN1);//sinal Alto IN1 RB4
output_low(IN2);//sinal baixo IN2 RB5   

   
    }
    else
    {
        //sentido anti

horario
output_high(IN2);//sinal Alto IN2 RB5
output_low(IN1);//sinal baixo IN1 RB4

       
        }       
       
//****Compara numeros de espiras se

igual para sistema************       
if(num_espiras==num_voltas_cont)//

Compara numeros de espiras x voltas

dadas
{
    flag_stop_start=0;
    num_voltas_cont=0;
//lcd_escreve("\f");
lcd_pos_xy(1,1);
printf(lcd_escreve," Esp.=%lu

\r",num_espiras);
delay_ms(500);   
}
//*****Verifica status de para

movimentação dos motores***********
if(flag_stop_start)//Testa flag

start/stop se ligado
{
    if(num_voltas_cont!=0)
    {
//lcd_escreve("\f");
lcd_pos_xy(1,1);
printf(lcd_escreve," Esp.=%lu M1 Rod

\r",num_voltas_cont);
delay_ms(300);
    }
// enable motor

M1**********************   
output_high(ENA);//sinal Alto ENA

L298 RB2
delay_ms(temp_bobina);
output_low(ENA);//sinal baixo ENA

L298 RB2
flag_ligado=1;

if(flag_encoder_M1)//Deu uma volta no

motor M1 então movimenta M2
{
   
// enable Motor

M2**************************
output_high(ENB);//sinal Alto ENB RB3
delay_ms(temp_fiador);//tempo do

pulso
output_low(ENB);//sinal baixo ENB RB3
//delay_ms(40);
flag_encoder_M1=0; // desativa Flag

encoder M1
//lcd_pos_xy(1,1);
//printf(lcd_escreve," Espiras=%lu   

\r",num_voltas_cont);
num_voltas_cont=num_voltas_cont+1;
delay_ms(30);
}
//***********************************

**************************
}
else
{
    if(num_voltas_cont!=0)
    {
//lcd_escreve("\f");
lcd_pos_xy(1,1);
printf(lcd_escreve,"Esp.=%lu M1 Par.

\r",num_voltas_cont);
delay_ms(300);
}
// travar motores
if(!flag_encoder_M1 & flag_ligado)
{
   
   
/*    for(i=0;i<2;i++)//PARAR M1
{   
//sentido anti horario
output_high(IN2);//sinal Alto IN2 RB5
output_low(IN1);//sinal baixo IN1 RB4
// enable motor

M1**********************   
output_high(pin_B2);//sinal Alto ENA

RB2
delay_ms(temp_bobina);
output_low(pin_B2);//sinal baixo ENA

RB2
}*/
flag_ligado=0;
}
output_low(ENA);//sinal Alto enable1
output_low(ENB);//sinal Alto enable2
output_low(pin_B4);//sinal baixo M1
output_low(pin_B5);//sinal baixo M1
output_low(pin_B6);//sinal baixo M2
output_low(pin_B7);//sinal baixo M2
delay_ms(300);
}
//********botao seta tempo bobina
if(!input(BT_BOBINA))
{
    output_high(LED_BOTOES);//

Liga Led botoes
if(!input(BT_INC))
{   
temp_bobina=temp_bobina+1;
delay_ms(300);
}
if(!input(BT_DEC))
{   
temp_bobina=temp_bobina-1;
delay_ms(300);
}
lcd_pos_xy(1,2);
printf(lcd_escreve,"Temp bob.=%lu

\r",temp_bobina);
delay_ms(300);
}

//********botao seta tempo fiador
if(!input(BT_FIADOR))
{
    output_high(LED_BOTOES);//

Liga Led botoes
if(!input(BT_INC))
{   
temp_fiador=temp_fiador+1;
delay_ms(300);
}
if(!input(BT_DEC))
{   
temp_fiador=temp_fiador-1;
delay_ms(300);
}
lcd_pos_xy(1,2);
printf(lcd_escreve,"Temp Fia.=%lu

\r",temp_fiador);
delay_ms(300);
}

//********botao seta quantidade de

espiras
if(!input(BT_ESPIRAS))
{
    output_high(LED_BOTOES);//

Liga Led botoes
if(!input(BT_INC))
{   
num_espiras=num_espiras+1;
delay_ms(300);
}
if(!input(BT_DEC))
{   
num_espiras=num_espiras-1;
delay_ms(300);
}
lcd_pos_xy(1,2);
printf(lcd_escreve,"NUM ESP.=%lu

\r",num_espiras);
delay_ms(300);
}
//lcd_escreve("\f");
//delay_ms(500);
if(BT_ESPIRAS & BT_FIADOR &

BT_BOBINA)output_LOW(LED_BOTOES);//

Desliga Led botoes
}
}


É isso ai pessoal se gostaram deixem seus comentários,
Deem seu like nos vídeos do youtube e se inscrevam no canal.




terça-feira, 11 de outubro de 2016

Controlador de RPM Motor AC 127V

Olá pessoal!
Neste projetinho foi usado um PIC16F877A, fazendo a leitura do rpm de um motor AC e corrigindo a velocidade com o chaveamento de um triac BTA12
No calculo para a correção foi usado o sistema de malha fechada e controle PI (proporcional e Integral).

segue um link do primeiro teste:



Suporte do Sensor óptico:

Confecção da Placa











Partes do código:


//------------------------Disparo no triac-----------------------------------
void disparo()
{

         if(zc)
         {
             if(flag_ld)
             {
                 if((v_rpm==0)&&(hz>=120))
                 {
                     tempo=54;                 //aplica 30% da potencia na saida
                     }
        if((tempo==5) &&(Sp>Pv))
        {
            output_high(pin_a0);
            }
            else
            {            
            for(m=0;m<tempo;m++)
            {
                delay_us(100);
                }
               
            output_high(pin_a0);
            delay_us(200);
            output_low(pin_a0);
            }
            }
            zc=0;
        RESTART_WDT();               
          }
          return;
}
//----------------Interrupção externa pino RB0-----------------------------
#int_ext
void Trata_ac()

{
     if(INTF)
     {
         hz++;
         zc=1;
         INTF=0;
         }
         disparo();
}

//----------------------------fim interrupção externa------------------------

//---------------------trata RPM------------------------------------
void trata_rpm()
{
            if(input(pin_a1))                //ler pino RA0 se 1
            {
                if(flag_rpm)                    //testa flag1 se 1
                {
                rps++;                        //soma rpm +1
                flag_rpm=0;                    //seta flag1 em 0
                }
            }       
            if(!input(pin_a1))                //ler pino RA0 se 0
            {
            flag_rpm=1;                        //seta flag1 em 1
            }
return;
}
//------------------------Calculo ganho-----------------------------
void calcula(void)
{
        sp=set_rpm*60;                //carrega a variável sp para calculos
        pv=v_rpm;                    //carrega a variável pv para calculos
    if(sp>pv)                    // set_point maior que leitura de rpm
    {                            // a rotacao esta abaixo do valor desejado
    dv=sp-pv;                    //calcula o desvio entre set_point e rpm lido
    dv=dv/100;                    //divide por 100 segundos   
    mv=erro-(kp*(dv+(ki*dv)));    //calcula a diferença que será subtraida do tempo de disparo
    erro=mv*0.2;                //calcula o erro como taxa de amortecimento para o próximo semi-ciclo
    }
    if(sp<pv)                    // set_point menor que leitura de rpm
    {                            // a rotacao esta acima do valor desejado
    dv=pv-sp;                    //calcula o desvio entre set_point e rpm lido
    dv=dv/100;                    //divide por 100 segundos
    mv=erro+(kp*(dv+(ki*dv)));    //calcula a diferença que será somada ao tempo de disparo
    erro=mv*ta;                    //calcula o erro com taxa de amortecimento para o próximo semi-ciclo
    }
   

        tempo=tempo+mv;            //tempo de dsiparo atualizado
           
        if(tempo>80)tempo=tempo-mv;    //verifica a variável tempo se esta dentro dos limites de disparo
        if(tempo<5)
        {
            tempo=5;        //verifica a variável tempo se esta dentro dos limites de disparo
            if(sp>pv)                    // set_point maior que leitura de rpm
    {
        output_high(pin_a0);
        }   
           
           
            }
    return;
    }

    void main()
    {
   
       output_a(0x00);  
       output_b(0x00);
       output_c(0x00);
       output_d(0x00);
       output_e(0x00);
       SET_TRIS_a(0x0A);
       SET_TRIS_b(0x01);
       SET_TRIS_c(0x0C);
       SET_TRIS_d(0x00);
       SET_TRIS_e(0x00);
      
       setup_adc_ports(NO_ANALOGS);//libera portas para digital
       setup_adc(ADC_OFF);//desliga conversor ad
       setup_timer_1(T1_DISABLED);//desliga timer 1  
       setup_comparator(NC_NC_NC_NC);//desliga comparadores
       setup_vref(FALSE);//desliga vref    
       SETUP_CCP1(CCP_OFF);     //desliga comparador1
        SETUP_CCP2(CCP_OFF);        //desliga comparador2
        SETUP_PSP(PSP_DISABLED);    //desliga comunicação paralela
       
        INTF=0;
        INTE=1;
        GIE=1;
        tempo=79;
        set_rpm=100;
        flag_ld=0;
        kp=0.2;
        ki=0.1;
        ta=0.2;
        output_high(pin_b5);
       lcd_init();
       delay_ms(100);       
        lcd_putc('\f');
        lcd_gotoxy(1,1);
        printf(lcd_putc,"Dimmer Teste\b");       
        delay_ms(100);
trata_memoria();
        lcd_gotoxy(1,2);                                    //direciona display coluna 1 linha 1
        printf(lcd_putc,"SET RPM:%lu rpm\b",memoria_rpm*60);    //apresenta no display valor set_rpm
        delay_ms(800);      
         while(1)
        {
           

              
    if(hz>=120)                    //testa se ocorreu 120 pulsos entrada AC
    {
        v_rpm=(rps/2)*60;        //tranforma valor de rps em rpm para calculos
        if(v_rpm==set_rpm*60)    //testa se valor setado = valor lido RPM
        {
             tempo=tempo;        //tempo recebe tempo
       
        }
        led=!led;
        output_bit(pin_b5,led);
       
if(flag_ld)                        //verifica se flag liga desliga= ligado
{
           
    calcula();                       

    }      

        lcd_putc('\f');                                        //limpa display
        lcd_gotoxy(1,1);                                    //direciona display coluna 1 linha 1
        printf(lcd_putc,"SET RPM:%lu rpm\b",set_rpm*60);    //apresenta no display valor set_rpm
        lcd_gotoxy(1,2);                                    //direciona display coluna 1 linha 2
        printf(lcd_putc,"RPM:%lu Disparo:%lu\b",v_rpm,tempo);//apresenta no display valor v_rpm e tempo
        lcd_gotoxy(1,4);                                //direciona display coluna 1 linha 4
        printf(lcd_putc,"MV:%2.1f erro:%2.1f\b",mv,erro);//apresenta no display
                                                        //valor de mv e erro
   
               
        if(flag_ld)                        //testa flag liga/desliga
        {
        lcd_gotoxy(1,3);                //direciona display coluna 1 linha 3
        printf(lcd_putc,"Ligado\b");    //apresenta no display ligado
        output_high(pin_c0);           
            }
            else
        {
        lcd_gotoxy(1,3);                //direciona display coluna 1 linha 3
        printf(lcd_putc,"Desligado\b");    //apresenta no display desligado
        tempo=80;        //carrega variável tempo com "80"x100us=8ms
        mv=0;            //zera variável mv
        erro=0;            //zera variável erro
        output_low(pin_c0);
            }
           
        hz=0;            //zera variável para contagem dentro de 1 segundo
        rps=0;            //zera variável para contagem dentro de 1 segundo
        }
       
       
    testa_sw();            //chama função do teclado
    trata_rpm();        //chama função leitura RPM
    RESTART_WDT();
        }
     }
//-----------------------------------------------------------------------------------------


Esquemático em arquivo .PDF


Espero que esta postagem ajude aos colegas que estão pesquisando na net!
Se gostou deixe o seu comentário.


Um teste final controle instalado na CNC

sábado, 20 de agosto de 2016

Apresentação

Sejam bem vindos ao Blog Lumens-Tel
Vamos compartilhar conhecimentos e experiências na área de eletrônica e programação.