#Desafio 5

Software: Proteus versão 7.9

Software: PicsimLab

Código feito em CCS C Compiler

Biblioteca: mod_lcd.c

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

/*  MOD_LCD.C - Biblioteca de manipulação d módulo LCD                 */                                                                    */

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

// As definições a seguir são utilizadas para acesso aos pinos do display

// caso o pino RW n�o seja utilizado, comente a defini��o lcd_rw

#ifndef lcd_enable

   #define lcd_enable       pin_e1      // pino enable do LCD

   #define lcd_rs         pin_e0      // pino rs do LCD

   //#define lcd_rw      pin_e2      // pino rw do LCD

   #define lcd_d4         pin_d4      // pino de dados d4 do LCD

   #define lcd_d5         pin_d5      // pino de dados d5 do LCD

   #define lcd_d6         pin_d6      // pino de dados d6 do LCD

   #define lcd_d7         pin_d7      // pino de dados d7 do LCD

#endif

#define lcd_type 2           // 0=5x7, 1=5x10, 2=2 linhas

#define lcd_seg_lin 0x40    // Endere�o da segunda linha na RAM do LCD

// a constante abaixo define a seq��ncia de inicializa��o do m�dulo LCD

byte CONST INI_LCD[4] = {0x20 | (lcd_type << 2), 0xf, 1, 6};

byte lcd_le_byte(){

// l� um byte do LCD (somente com pino RW)

   byte dado;

   // configura os pinos de dados como entradas

   input(lcd_d4);

   input(lcd_d5);

   input(lcd_d6);

   input(lcd_d7);

   // se o pino rw for utilizado, coloca em 1

   #ifdef lcd_rw

      output_high(lcd_rw);

   #endif

   output_high(lcd_enable); // habilita display

   dado = 0;   // zera a vari�vel de leitura

   // l� os quatro bits mais significativos

   if (input(lcd_d7)) bit_set(dado,7);

   if (input(lcd_d6)) bit_set(dado,6);

   if (input(lcd_d5)) bit_set(dado,5);

   if (input(lcd_d4)) bit_set(dado,4);

   // d� um pulso na linha enable

   output_low(lcd_enable);

   output_high(lcd_enable);

   // l� os quatro bits menos significativos

   if (input(lcd_d7)) bit_set(dado,3);

   if (input(lcd_d6)) bit_set(dado,2);

   if (input(lcd_d5)) bit_set(dado,1);

   if (input(lcd_d4)) bit_set(dado,0);

   output_low(lcd_enable);   // desabilita o display

   return dado;   // retorna o byte lido

}

void lcd_envia_nibble( byte dado ){

// envia um dado de quatro bits para o display

   // coloca os quatro bits nas saidas

   output_bit(lcd_d4,bit_test(dado,0));

   output_bit(lcd_d5,bit_test(dado,1));

   output_bit(lcd_d6,bit_test(dado,2));

   output_bit(lcd_d7,bit_test(dado,3));

   // d� um pulso na linha enable

   output_high(lcd_enable);

   output_low(lcd_enable);

}

void lcd_envia_byte( boolean endereco, byte dado ){

   // coloca a linha rs em 0

   output_low(lcd_rs);

   // aguarda o display ficar desocupado

   //while ( bit_test(lcd_le_byte(),7) ) ;

   // configura a linha rs dependendo do modo selecionado

   output_bit(lcd_rs,endereco);

   delay_us(100);   // aguarda 100 us

   // caso a linha rw esteja definida, coloca em 0

   #ifdef lcd_rw

      output_low(lcd_rw);

   #endif

   // desativa linha enable

   output_low(lcd_enable);

   // envia a primeira parte do byte

   lcd_envia_nibble(dado >> 4);

   // envia a segunda parte do byte

   lcd_envia_nibble(dado & 0x0f);

}

void lcd_ini(){

// rotina de inicializa��o do display

   byte conta;

   output_low(lcd_d4);

   output_low(lcd_d5);

   output_low(lcd_d6);

   output_low(lcd_d7);

   output_low(lcd_rs);

   #ifdef lcd_rw

      output_high(lcd_rw);

   #endif

   output_low(lcd_enable);

   delay_ms(15);

   // envia uma seq��ncia de 3 vezes 0x03

   // e depois 0x02 para configurar o m�dulo

   // para modo de 4 bits

   for(conta=1;conta<=3;++conta){

      lcd_envia_nibble(3);

      delay_ms(5);

   }

   lcd_envia_nibble(2);

   // envia string de inicializa��o do display

   for(conta=0;conta<=3;++conta) lcd_envia_byte(0,INI_LCD[conta]);

}

void lcd_pos_xy( byte x, byte y){

   byte endereco;

   if(y!=1)

      endereco = lcd_seg_lin;

   else

      endereco = 0;

   endereco += x-1;

   lcd_envia_byte(0,0x80|endereco);

}

void lcd_escreve( char c){

// envia caractere para o display

   switch (c)   {

     case '\f'    :   lcd_envia_byte(0,1);

              delay_ms(2);

            break;

     case '\n'   :

     case '\r'    :   lcd_pos_xy(1,2);

              break;

     case '\b'    :   lcd_envia_byte(0,0x10);

              break;

     default   :   lcd_envia_byte(1,c);

              break;

   }

}

char lcd_le( byte x, byte y){

// le caractere do display

   char valor;

   // seleciona a posi��o do caractere

   lcd_pos_xy(x,y);

   // ativa rs

   output_high(lcd_rs);

   // l� o caractere

   valor = lcd_le_byte();

   // desativa rs

   output_low(lcd_rs);

   // retorna o valor do caractere

   return valor;

}

Arquivo principal: Bicicleta.c

#include <16F877A.h>

#device adc = 8

#FUSES NOWDT

#FUSES HS

#FUSES NOPUT

#FUSES NOPROTECT

#FUSES NODEBUG

#FUSES BROWNOUT

#FUSES NOLVP

#FUSES NOCPD

#FUSES NOWRT

#use delay(clock = 20MHz)

#ifndef lcd_enable

   #define lcd_enable   pin_e1 // pino enable do LCD

   #define lcd_rs       pin_e2 // pino rs do LCD

   //#define lcd_rw       pin_e2 // pino rw do LCD

   #define lcd_d4       pin_d4 // pino de dados d4 do LCD

   #define lcd_d5       pin_d5 // pino de dados d5 do LCD

   #define lcd_d6       pin_d6 // pino de dados d6 do LCD

   #define lcd_d7       pin_d7 // pino de dados d7 do LCD

#endif

#include <mod_lcd.c>

//#use fast_io(B) //habilita todas as portas B

//#use fast_io(D)

#define delay 50

unsigned int8 diametro = 0, cont = 0;

unsigned boolean flag = false;

int HORA = 0, MINUTO = 0, SEGUNDO = 0;

int8 velocidade, distancia;

#INT_RTCC

void  RTCC_isr(void) {

   output_toggle(PIN_B0); 

   cont++;

}

void main(){

     

   setup_adc_ports(NO_ANALOGS);

   setup_adc(ADC_OFF);

   setup_spi(SPI_SS_DISABLED);

   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256); //overflow en 13.1 

   setup_adc_ports(AN0_AN1_AN3);   

   setup_adc(ADC_CLOCK_DIV_16);     

   enable_interrupts(INT_RTCC);

   enable_interrupts(GLOBAL);

   

   setup_psp(PSP_DISABLED);

   setup_spi(SPI_SS_DISABLED);

   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);

   setup_timer_1(T1_DISABLED);

   setup_timer_2(T2_DISABLED,0,1);

   setup_comparator(NC_NC_NC_NC);

   setup_vref(FALSE);    

   set_adc_channel(0);    

   delay_us(50);

   

   //output_b(0);

   //set_tris_b(0x03);

   port_b_pullups(TRUE);

   output_d(0);

   set_tris_d(0);

      

   lcd_ini();

      

   while(TRUE){

      diametro = read_adc();

      

      printf (lcd_escreve,"\fIns. dist: %u",diametro);

      delay_ms(200);

            

      while( ! input(PIN_B1)){

         velocidade = diametro * 3.1415 * 0.5;

         distancia = velocidade * (HORA + MINUTO);

         SEGUNDO++;

         

         if(SEGUNDO > 59){

            SEGUNDO = 0;

            MINUTO++;

         }

         

         if(MINUTO > 59){

            MINUTO = 0;

            HORA++;

         }

         

         if(HORA > 23) HORA = 0;

         lcd_pos_xy(1,2);

         printf (lcd_escreve,"  V = %u r/s \n%u:%u:%u Dt= %u ",velocidade, HORA, MINUTO, SEGUNDO, distancia);

         output_c(0b1000);

         delay_ms(delay);

         output_c(0b0100);

         delay_ms(delay);

         output_c(0b0010);

         delay_ms(delay);

         output_c(0b0001);

         delay_ms(delay);

         

         distancia++;

      }

      

   }

}

Ligar os displays no PicsimLab com Pic 16F628A

Código feito em CCS C Compiler

#include <16F628A.h>

#FUSES NOWDT                     //No Watch Dog Timer

#FUSES NOBROWNOUT     //No brownout reset

#FUSES NOLVP                     //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O

#use delay(crystal = 4MHz)

#define LED PIN_B4

#define DELAY 3

#define DELAY_LIGADO 5

void apaga(){

   OUTPUT_B(0);

}

void dois(){

 

   /*output_high(PIN_B2);

   output_high(PIN_B3);

   output_high(PIN_B0);

   output_high(PIN_B7);

   output_high(PIN_B6);*/

 

   OUTPUT_B(0b11011101);

}

void um(){

   OUTPUT_B(0b0101000); // para ligar o display da direita => RB4 = 1

}

void main(){

 //apaga();

 //dois();

   while(true){

      apaga();

      delay_ms(DELAY);

      dois();

      delay_ms(DELAY_LIGADO);

      apaga();

      delay_ms(DELAY);

      um();

      delay_ms(DELAY_LIGADO);

   }

}

Software: PicsimLab com PIC 16F628A

#Desafio 4 - Biblioteca expandida

Acrescentar funções a biblioteca mod_lcd.c e criar uma nova com o nome mod_lcd_plus.c 

1. A biblioteca mod_lcd_plus.c deve ter no mínimo cinco funções a mais que a original sendo que uma delas servira para desenha caracteres definidos pelo usuário. Essa nova função deve chamar lcd_escreve_graphic. As outras quatros funções podem ser definida por você, isto é, você define o nome e o que a função vai fazer. 

2. Faça um programa para apresentar a nova biblioteca que rode no PICSimLab com a board PICGenios e o PIC 16F877A

Resolução feita em CCS C Compiler

Arquivo: mod_lcd_graphic.c

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

/* MOD_LCD_GRAPHIC.C - Biblioteca de manipulação de módulo LCD ++ */

/* */

/* Autor: Fábio Pereira e Alberto Willian Mascarenhas */

/* */

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

// Command set for Hitachi 44780U LCD display controller

#define LCD_CLEAR 0x01 // It clears everythings

#define LCD_HOME 0x02 // set the cursor to first line and first row

#define LCD_CURSOR_BACK 0x10 // moves curson one position back

#define LCD_CURSOR_FWD 0x14 //moves curson one position forward

#define LCD_PAN_LEFT 0x18 // used to scroll text left side to scroll text

#define LCD_PAN_RIGHT 0x1C // used to scroll text right side to scroll text

#define LCD_CURSOR_OFF 0x0C // stops display curson on screen

#define LCD_CURSOR_ON 0x0E // turns on cursor display

#define LCD_CURSOR_BLINK 0x0F // curson keeps blinking

#define LCD_CURSOR_LINE2 0xC0 // move curson to scond line or second row

// As definições a seguir são utilizadas para acesso aos pinos do display

// caso o pino RW não seja utilizado, comente a definição lcd_rw

#ifndef lcd_enable

#define lcd_enable pin_e1 // pino enable do LCD

#define lcd_rs pin_e0 // pino rs do LCD

//#define lcd_rw pin_e2 // pino rw do LCD

#define lcd_d4 pin_d4 // pino de dados d4 do LCD

#define lcd_d5 pin_d5 // pino de dados d5 do LCD

#define lcd_d6 pin_d6 // pino de dados d6 do LCD

#define lcd_d7 pin_d7 // pino de dados d7 do LCD

#endif

#define lcd_type 2 // 0=5x7, 1=5x10, 2=2 linhas

#define lcd_seg_lin 0x40 // Endereço da segunda linha na RAM do LCD

// a constante abaixo define a seqüência de inicialização do módulo LCD

byte CONST INI_LCD[4] = {0x20 | (lcd_type << 2), 0xf, 1, 6};

byte lcd_le_byte()

// lê um byte do LCD (somente com pino RW)

{

byte dado;

// configura os pinos de dados como entradas

input(lcd_d4);

input(lcd_d5);

input(lcd_d6);

input(lcd_d7);

// se o pino rw for utilizado, coloca em 1

#ifdef lcd_rw

output_high(lcd_rw);

#endif

 output_high(lcd_enable); // habilita display

dado = 0; // zera a variável de leitura

// lê os quatro bits mais significativos

if (input(lcd_d7)) bit_set(dado,7);

if (input(lcd_d6)) bit_set(dado,6);

if (input(lcd_d5)) bit_set(dado,5);

if (input(lcd_d4)) bit_set(dado,4);

// dá um pulso na linha enable

output_low(lcd_enable);

output_high(lcd_enable);

// lê os quatro bits menos significativos

if (input(lcd_d7)) bit_set(dado,3);

if (input(lcd_d6)) bit_set(dado,2);

if (input(lcd_d5)) bit_set(dado,1);

if (input(lcd_d4)) bit_set(dado,0);

output_low(lcd_enable); // desabilita o display

return dado; // retorna o byte lido

}

void lcd_envia_nibble( byte dado )

// envia um dado de quatro bits para o display

{

// coloca os quatro bits nas saidas

output_bit(lcd_d4,bit_test(dado,0));

output_bit(lcd_d5,bit_test(dado,1));

output_bit(lcd_d6,bit_test(dado,2));

output_bit(lcd_d7,bit_test(dado,3));

// dá um pulso na linha enable

output_high(lcd_enable);

output_low(lcd_enable);

}

void lcd_envia_byte( boolean endereco, byte dado )

{

// coloca a linha rs em 0

output_low(lcd_rs);

// aguarda o display ficar desocupado

//while ( bit_test(lcd_le_byte(),7) ) ;

// configura a linha rs dependendo do modo selecionado

output_bit(lcd_rs,endereco);

delay_us(100); // aguarda 100 us

// caso a linha rw esteja definida, coloca em 0

#ifdef lcd_rw

output_low(lcd_rw);

#endif

// desativa linha enable

output_low(lcd_enable);

// envia a primeira parte do byte

lcd_envia_nibble(dado >> 4);

// envia a segunda parte do byte

lcd_envia_nibble(dado & 0x0f);

}

void lcd_ini()

// rotina de inicialização do display

{

byte conta;

output_low(lcd_d4);

output_low(lcd_d5);

output_low(lcd_d6);

output_low(lcd_d7);

output_low(lcd_rs);

#ifdef lcd_rw

output_high(lcd_rw);

#endif

output_low(lcd_enable);

delay_ms(15);

// envia uma seqüência de 3 vezes 0x03

// e depois 0x02 para configurar o módulo

// para modo de 4 bits

for(conta=1;conta<=3;++conta)

{

lcd_envia_nibble(3);

delay_ms(5);

}

lcd_envia_nibble(2);

// envia string de inicialização do display

for(conta=0;conta<=3;++conta) lcd_envia_byte(0,INI_LCD[conta]);

}

void lcd_pos_xy( byte x, byte y)

{

 byte endereco;

 if(y!=1)

 endereco = lcd_seg_lin;

 else

 endereco = 0;

 endereco += x-1;

 lcd_envia_byte(0,0x80|endereco);

}

void lcd_escreve( char c)

// envia caractere para o display

{

 switch (c)

{

 case '\f' : lcd_envia_byte(0,1);

 delay_ms(2);

break;

 case '\n' :

case '\r' : lcd_pos_xy(1,2);

 break;

 case '\b' : lcd_envia_byte(0,0x10);

 break;

 default : lcd_envia_byte(1,c);

 break;

 }

}

char lcd_le( byte x, byte y)

// le caractere do display

{

char valor;

// seleciona a posição do caractere

lcd_pos_xy(x,y);

// ativa rs

output_high(lcd_rs);

// lê o caractere

valor = lcd_le_byte();

// desativa rs

output_low(lcd_rs);

// retorna o valor do caractere

return valor;

}

//-----------------------------------------------------------------

//

// Funções adicionadas por Alberto Willian Mascarenhas

//

//-----------------------------------------------------------------

void CriaCaracterEspecial (unsigned char *Pattern, char Location)

{

 int i=0;

 lcd_envia_byte(0,0x40+(Location*8)); //Send the Address of CGRAM

 for (i=0; i<8; i++)

 lcd_envia_byte(1,Pattern [ i ] ); //Pass the bytes of pattern on LCD

}

void Lcd_Imprime_String(char *a)

{

 int i;

 for(i=0;a[i]!='\0';i++)

 lcd_envia_byte(1,a[i]); //Lcd_Print_Char(a[i]);

 //Split the string using pointers and call the Char function

}

Arquivo principal: LCD_expandida

#include <16F877A.h>

#device adc=8

#FUSES NOWDT //No Watch Dog Timer

#FUSES HS //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)

#FUSES NOPUT //No Power Up Timer

#FUSES NOPROTECT //Code not protected from reading

#FUSES NODEBUG //No Debug mode for ICD

#FUSES BROWNOUT //Reset when brownout detected

#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O

#FUSES NOCPD //No EE protection

#FUSES NOWRT //Program memory not write protected

#use delay(clock = 20000000)

#ifndef lcd_enable

 #define lcd_enable pin_e1 // pino enable do LCD

 #define lcd_rs pin_e2 // pino rs do LCD

 //#define lcd_rw pin_e2 // pino rw do LCD

 #define lcd_d4 pin_d4 // pino de dados d4 do LCD

 #define lcd_d5 pin_d5 // pino de dados d5 do LCD

 #define lcd_d6 pin_d6 // pino de dados d6 do LCD

 #define lcd_d7 pin_d7 // pino de dados d7 do LCD

#endif

#include "mod_lcd_graphic.c"

//unsigned char Desenho0 [ ] = { 0x0e, 0x0e, 0x04, 0x04, 0x1f, 0x04, 0x0a, 0x0a } ;

unsigned char Desenho1 [ ] = {0b01110,0b01110,0b00100,0b01110,0b10101,0b00100,0b01010,0b01010} ; // Code for CGRAM memory space 1

unsigned char Desenho2 [ ] = {0b00000,0b00000,0b01010,0b00100,0b00100,0b10001,0b01110,0b00000} ; // Code for CGRAM memory space 2

unsigned char Desenho3 [ ] = {0b00100,0b01110,0b11111,0b11111,0b01110,0b01110,0b01010,0b01010} ; // Code for CGRAM memory space 3

unsigned char Desenho4 [ ] = {0b01110,0b10001,0b10001,0b11111,0b11011,0b11011,0b11111,0b00000} ; // Code for CGRAM memory space 4

unsigned char Desenho5 [ ] = {0b01110,0b10000,0b10000,0b11111,0b11011,0b11011,0b11111,0b00000} ; // Code for CGRAM memory space 5

unsigned char Desenho6 [ ] = {0b00000,0b10001,0b01010,0b10001,0b00100,0b01110,0b10001,0b00000} ; // Code for CGRAM memory space 6

unsigned char Desenho7 [ ] = {0b00000,0b00000,0b01010,0b10101,0b10001,0b01110,0b00100,0b00000} ; // Code for CGRAM memory space 7

unsigned char Desenho8 [ ] = {0b11111,0b11111,0b10101,0b11011,0b11011,0b11111,0b10001,0b11111} ; //

void main(){

   

    float valor = 67.3215;

    int i=0;

   

    setup_adc_ports(NO_ANALOGS);

    setup_adc(ADC_OFF);

    setup_psp(PSP_DISABLED);

    setup_spi(SPI_SS_DISABLED);

    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);

    setup_timer_1(T1_DISABLED);

    setup_timer_2(T2_DISABLED,0,1);

    setup_comparator(NC_NC_NC_NC);

    setup_vref(FALSE);

    lcd_ini();

    delay_ms(50);

    

    while(TRUE){

      

       printf(lcd_escreve, "\f IFMT - MICROC. \r\n");

       printf (lcd_escreve," LCD -2022 ");

       delay_ms (2000);

       //CriaCaracterEspecial(Desenho0,0); // //

       CriaCaracterEspecial(Desenho1,1); // //

       CriaCaracterEspecial(Desenho2,2); // //

       CriaCaracterEspecial(Desenho3,3); // //

       CriaCaracterEspecial(Desenho4,4); // //

       CriaCaracterEspecial(Desenho5,5); // //

       CriaCaracterEspecial(Desenho6,6); // //

       CriaCaracterEspecial(Desenho7,7); // //

       CriaCaracterEspecial(Desenho8,8); // //

       

       lcd_escreve ('\f'); // Apaga (limpa) o display

       

      //lcd_envia_byte(0,0x86 ) ; //Place cursor at 6th position of first row

      //lcd_envia_byte(1, 1 ) ; //Display Desenho1

      //lcd_envia_byte(1, 2 ) ; //Display Desenho2

      

      for(i=1;i<=8;i++){

         lcd_envia_byte(1, i ) ; //Display Desenho1

      }

      delay_ms (10000);

      

    }

}

 

 

Simulação no PicsimLab

Simulação no software proteus 7.9

#Desafio 4 - Biblioteca LCD

Desafio: Acrescentar funções a biblioteca mod_lcd.c e criar uma nova com o nome mod_lcd_plus.c

    1. A biblioteca mod_lcd_plus.c deve ter no mínimo cinco funções a mais que a original sendo que uma delas servira para desenha caracteres definidos pelo usuário. Essa nova função deve chamar lcd_escreve_graphic. As outras quatros funções podem ser definida por você, isto é, você define o nome e o que a função vai fazer. 

    2. Faça um programa para apresentar a nova biblioteca que rode no PICSimLab com a board PICGenios e o PIC 16F877A 

Resolução em CÓDIGO FEITO EM CCS C Compiler

Arquivo: mod_lcd.c

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

/*  MOD_LCD.C - Biblioteca de manipulação de módulo LCD                 */

/*                                                                      */

/*  Autor: Fábio Pereira                                                */

/*                                                                      */

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

// As definições a seguir são utilizadas para acesso aos pinos do display

// caso o pino RW não seja utilizado, comente a definição lcd_rw

#ifndef lcd_enable

#define lcd_enable pin_e1 // pino enable do LCD

#define lcd_rs pin_e0 // pino rs do LCD

//#define lcd_rw pin_e2 // pino rw do LCD

#define lcd_d4 pin_d4 // pino de dados d4 do LCD

#define lcd_d5 pin_d5 // pino de dados d5 do LCD

#define lcd_d6 pin_d6 // pino de dados d6 do LCD

#define lcd_d7 pin_d7 // pino de dados d7 do LCD

#endif

#define lcd_type 2           // 0=5x7, 1=5x10, 2=2 linhas

#define lcd_seg_lin 0x40    // Endereço da segunda linha na RAM do LCD

// a constante abaixo define a seqüência de inicialização do módulo LCD

byte CONST INI_LCD[4] = {0x20 | (lcd_type << 2), 0xf, 1, 6};

byte lcd_le_byte()

// lê um byte do LCD (somente com pino RW)

{

byte dado;

// configura os pinos de dados como entradas

input(lcd_d4);

input(lcd_d5);

input(lcd_d6);

input(lcd_d7);

// se o pino rw for utilizado, coloca em 1

#ifdef lcd_rw

output_high(lcd_rw);

#endif

   output_high(lcd_enable); // habilita display

dado = 0; // zera a variável de leitura

// lê os quatro bits mais significativos

if (input(lcd_d7)) bit_set(dado,7);

if (input(lcd_d6)) bit_set(dado,6);

if (input(lcd_d5)) bit_set(dado,5);

if (input(lcd_d4)) bit_set(dado,4);

// dá um pulso na linha enable

output_low(lcd_enable);

output_high(lcd_enable);

// lê os quatro bits menos significativos

if (input(lcd_d7)) bit_set(dado,3);

if (input(lcd_d6)) bit_set(dado,2);

if (input(lcd_d5)) bit_set(dado,1);

if (input(lcd_d4)) bit_set(dado,0);

output_low(lcd_enable); // desabilita o display

return dado; // retorna o byte lido

}

void lcd_envia_nibble( byte dado )

// envia um dado de quatro bits para o display

{

// coloca os quatro bits nas saidas

output_bit(lcd_d4,bit_test(dado,0));

output_bit(lcd_d5,bit_test(dado,1));

output_bit(lcd_d6,bit_test(dado,2));

output_bit(lcd_d7,bit_test(dado,3));

// dá um pulso na linha enable

output_high(lcd_enable);

output_low(lcd_enable);

}

void lcd_envia_byte( boolean endereco, byte dado )

{

// coloca a linha rs em 0

output_low(lcd_rs);

// aguarda o display ficar desocupado

//while ( bit_test(lcd_le_byte(),7) ) ;

// configura a linha rs dependendo do modo selecionado

output_bit(lcd_rs,endereco);

delay_us(100); // aguarda 100 us

// caso a linha rw esteja definida, coloca em 0

#ifdef lcd_rw

output_low(lcd_rw);

#endif

// desativa linha enable

output_low(lcd_enable);

// envia a primeira parte do byte

lcd_envia_nibble(dado >> 4);

// envia a segunda parte do byte

lcd_envia_nibble(dado & 0x0f);

}

void lcd_ini()

// rotina de inicialização do display

{

byte conta;

output_low(lcd_d4);

output_low(lcd_d5);

output_low(lcd_d6);

output_low(lcd_d7);

output_low(lcd_rs);

#ifdef lcd_rw

output_high(lcd_rw);

#endif

output_low(lcd_enable);

delay_ms(15);

// envia uma seqüência de 3 vezes 0x03

// e depois 0x02 para configurar o módulo

// para modo de 4 bits

for(conta=1;conta<=3;++conta)

{

lcd_envia_nibble(3);

delay_ms(5);

}

lcd_envia_nibble(2);

// envia string de inicialização do display

for(conta=0;conta<=3;++conta) lcd_envia_byte(0,INI_LCD[conta]);

}

void lcd_pos_xy( byte x, byte y)

{

   byte endereco;

   if(y!=1)

    endereco = lcd_seg_lin;

   else

    endereco = 0;

   endereco += x-1;

   lcd_envia_byte(0,0x80|endereco);

}

void lcd_escreve( char c)

// envia caractere para o display

{

   switch (c)

{

     case '\f' : lcd_envia_byte(0,1);

  delay_ms(2);

break;

     case '\n' :

case '\r' : lcd_pos_xy(1,2);

  break;

     case '\b' : lcd_envia_byte(0,0x10);

  break;

     default : lcd_envia_byte(1,c);

  break;

   }

}

char lcd_le( byte x, byte y)

// le caractere do display

{

char valor;

// seleciona a posição do caractere

lcd_pos_xy(x,y);

// ativa rs

output_high(lcd_rs);

// lê o caractere

valor = lcd_le_byte();

// desativa rs

output_low(lcd_rs);

// retorna o valor do caractere

return valor;

}

Arquivo: mod_lcd_graphic

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

/* MOD_LCD_GRAPHIC.C - Biblioteca de manipulação de módulo LCD ++ */

/* */

/* Autor: Fábio Pereira e Alberto Willian Mascarenhas */

/* */

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

// Command set for Hitachi 44780U LCD display controller

#define LCD_CLEAR 0x01 // It clears everythings

#define LCD_HOME 0x02 // set the cursor to first line and first row

#define LCD_CURSOR_BACK 0x10 // moves curson one position back

#define LCD_CURSOR_FWD 0x14 //moves curson one position forward

#define LCD_PAN_LEFT 0x18 // used to scroll text left side to scroll text

#define LCD_PAN_RIGHT 0x1C // used to scroll text right side to scroll text

#define LCD_CURSOR_OFF 0x0C // stops display curson on screen

#define LCD_CURSOR_ON 0x0E // turns on cursor display

#define LCD_CURSOR_BLINK 0x0F // curson keeps blinking

#define LCD_CURSOR_LINE2 0xC0 // move curson to scond line or second row

// As definições a seguir são utilizadas para acesso aos pinos do display

// caso o pino RW não seja utilizado, comente a definição lcd_rw

#ifndef lcd_enable

#define lcd_enable pin_e1 // pino enable do LCD

#define lcd_rs pin_e0 // pino rs do LCD

//#define lcd_rw pin_e2 // pino rw do LCD

#define lcd_d4 pin_d4 // pino de dados d4 do LCD

#define lcd_d5 pin_d5 // pino de dados d5 do LCD

#define lcd_d6 pin_d6 // pino de dados d6 do LCD

#define lcd_d7 pin_d7 // pino de dados d7 do LCD

#endif

#define lcd_type 2 // 0=5x7, 1=5x10, 2=2 linhas

#define lcd_seg_lin 0x40 // Endereço da segunda linha na RAM do LCD

// a constante abaixo define a seqüência de inicialização do módulo LCD

byte CONST INI_LCD[4] = {0x20 | (lcd_type << 2), 0xf, 1, 6};

byte lcd_le_byte()

// lê um byte do LCD (somente com pino RW)

{

byte dado;

// configura os pinos de dados como entradas

input(lcd_d4);

input(lcd_d5);

input(lcd_d6);

input(lcd_d7);

// se o pino rw for utilizado, coloca em 1

#ifdef lcd_rw

output_high(lcd_rw);

#endif

 output_high(lcd_enable); // habilita display

dado = 0; // zera a variável de leitura

// lê os quatro bits mais significativos

if (input(lcd_d7)) bit_set(dado,7);

if (input(lcd_d6)) bit_set(dado,6);

if (input(lcd_d5)) bit_set(dado,5);

if (input(lcd_d4)) bit_set(dado,4);

// dá um pulso na linha enable

output_low(lcd_enable);

output_high(lcd_enable);

// lê os quatro bits menos significativos

if (input(lcd_d7)) bit_set(dado,3);

if (input(lcd_d6)) bit_set(dado,2);

if (input(lcd_d5)) bit_set(dado,1);

if (input(lcd_d4)) bit_set(dado,0);

output_low(lcd_enable); // desabilita o display

return dado; // retorna o byte lido

}

void lcd_envia_nibble( byte dado )

// envia um dado de quatro bits para o display

{

// coloca os quatro bits nas saidas

output_bit(lcd_d4,bit_test(dado,0));

output_bit(lcd_d5,bit_test(dado,1));

output_bit(lcd_d6,bit_test(dado,2));

output_bit(lcd_d7,bit_test(dado,3));

// dá um pulso na linha enable

output_high(lcd_enable);

output_low(lcd_enable);

}

void lcd_envia_byte( boolean endereco, byte dado )

{

// coloca a linha rs em 0

output_low(lcd_rs);

// aguarda o display ficar desocupado

//while ( bit_test(lcd_le_byte(),7) ) ;

// configura a linha rs dependendo do modo selecionado

output_bit(lcd_rs,endereco);

delay_us(100); // aguarda 100 us

// caso a linha rw esteja definida, coloca em 0

#ifdef lcd_rw

output_low(lcd_rw);

#endif

// desativa linha enable

output_low(lcd_enable);

// envia a primeira parte do byte

lcd_envia_nibble(dado >> 4);

// envia a segunda parte do byte

lcd_envia_nibble(dado & 0x0f);

}

void lcd_ini()

// rotina de inicialização do display

{

byte conta;

output_low(lcd_d4);

output_low(lcd_d5);

output_low(lcd_d6);

output_low(lcd_d7);

output_low(lcd_rs);

#ifdef lcd_rw

output_high(lcd_rw);

#endif

output_low(lcd_enable);

delay_ms(15);

// envia uma seqüência de 3 vezes 0x03

// e depois 0x02 para configurar o módulo

// para modo de 4 bits

for(conta=1;conta<=3;++conta)

{

lcd_envia_nibble(3);

delay_ms(5);

}

lcd_envia_nibble(2);

// envia string de inicialização do display

for(conta=0;conta<=3;++conta) lcd_envia_byte(0,INI_LCD[conta]);

}

void lcd_pos_xy( byte x, byte y)

{

 byte endereco;

 if(y!=1)

 endereco = lcd_seg_lin;

 else

 endereco = 0;

 endereco += x-1;

 lcd_envia_byte(0,0x80|endereco);

}

void lcd_escreve( char c)

// envia caractere para o display

{

 switch (c)

{

 case '\f' : lcd_envia_byte(0,1);

 delay_ms(2);

break;

 case '\n' :

case '\r' : lcd_pos_xy(1,2);

 break;

 case '\b' : lcd_envia_byte(0,0x10);

 break;

 default : lcd_envia_byte(1,c);

 break;

 }

}

char lcd_le( byte x, byte y)

// le caractere do display

{

char valor;

// seleciona a posição do caractere

lcd_pos_xy(x,y);

// ativa rs

output_high(lcd_rs);

// lê o caractere

valor = lcd_le_byte();

// desativa rs

output_low(lcd_rs);

// retorna o valor do caractere

return valor;

}

//-----------------------------------------------------------------

//

// Funções adicionadas por Alberto Willian Mascarenhas

//

//-----------------------------------------------------------------

void CriaCaracterEspecial (unsigned char *Pattern, char Location)

{

 int i=0;

 lcd_envia_byte(0,0x40+(Location*8)); //Send the Address of CGRAM

 for (i=0; i<8; i++)

 lcd_envia_byte(1,Pattern [ i ] ); //Pass the bytes of pattern on LCD

}

void Lcd_Imprime_String(char *a)

{

 int i;

 for(i=0;a[i]!='\0';i++)

 lcd_envia_byte(1,a[i]); //Lcd_Print_Char(a[i]);

 //Split the string using pointers and call the Char function

}

Arquivo principal: LCD expandida

//EXEMPLO RETIRADO DO LIVRO

#include <16F877A.h>

#device adc = 8

// Uma animação simples no display

//#include <16f877.h>

#use delay(clock = 20MHz)

#fuses HS,NOWDT,PUT,NOBROWNOUT,NOLVP

#include <mod_lcd.c>

void main(){

   char k;

   

   setup_adc_ports(no_analogs); // desliga as entradas analógicas

   lcd_ini();

   // configura registrador AC para o endereço inicial da CGRAM

   lcd_envia_byte(0,0x40);

   lcd_envia_byte(1,0x04); // primeira linha do primeiro caractere

   lcd_envia_byte(1,0x0e); // segunda linha do primeiro caractere

   lcd_envia_byte(1,0x15); // terceira linha do primeiro caractere

   lcd_envia_byte(1,0x04); // quarta linha do primeiro caractere

   lcd_envia_byte(1,0x04); // quinta linha do primeiro caractere

   lcd_envia_byte(1,0x04); // sexta linha do primeiro caractere

   lcd_envia_byte(1,0x04); // sétima linha do primeiro caractere

   lcd_envia_byte(1,0x00); // oitava linha do primeiro caractere

   lcd_envia_byte(1,0x00); // primeira linha do segundo caractere

   lcd_envia_byte(1,0x04); // segunda linha do segundo caractere

   lcd_envia_byte(1,0x0e); // terceira linha do segundo caractere

   lcd_envia_byte(1,0x15); // quarta linha do segundo caractere

   lcd_envia_byte(1,0x04); // quinta linha do segundo caractere

   lcd_envia_byte(1,0x04); // sexta linha do segundo caractere

   lcd_envia_byte(1,0x04); // sétima linha do segundo caractere

   lcd_envia_byte(1,0x00); // oitava linha do segundo caractere

   

   // registrador AC aponta para a primeira coluna da segunda linha

   lcd_envia_byte(0,0xC0);

   while(TRUE){

      

      // registrador AC aponta para a primeira coluna da segunda linha

      lcd_envia_byte(0,0xC0);

      // imprime o primeiro caractere do usuário

      lcd_envia_byte(1,0x00);

      delay_ms(300);

      // registrador AC aponta para a primeira coluna da segunda linha

      lcd_envia_byte(0,0xC0);

      // imprime o segundo caractere do usuário

      lcd_envia_byte(1,0x01);

      delay_ms(300);

      

   }

}

Gerar QRCode com html

Créditos para Nilson Leitão

Clique aqui para fazer o download do arquivo

Mini teste 1 - 2022/1

Projete um sistema com microcontrolador PIC (circuitos necessários para o microcontrolador funcionar) para funcionar da seguinte forma: 

quando o usuário do micro-ondas (figura 1) apertar o botão INÍCIO (primeira vez) o micro-ondas começa uma contagem decrescente de 30 para zero; se o usuário apertar novamente antes da contagem chegar a zero ele soma mais trinta a contagem atual e continua a contagem decrescente. Quando chegar em zero para a contagem e liga um LED OBS.: o circuito deve ter a os conectores para gravação; circuito do oscilador; alimentação; circuito do LED; circuito do botão e circuito para display de sete seguimentos.

Resolução:

CÓDIGO FEITO EM CCS C Compiler

#include <16F877A.h>

#device adc=8

#FUSES NOWDT //No Watch Dog Timer

#FUSES HS //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)

#FUSES NOPUT //No Power Up Timer

#FUSES NOPROTECT //Code not protected from reading

#FUSES NODEBUG //No Debug mode for ICD

#FUSES BROWNOUT //Reset when brownout detected

#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O

#FUSES NOCPD //No EE protection

#FUSES NOWRT //Program memory not write protected

#use delay(clock = 20MHz)

unsigned int cont_int = 0;

unsigned int tempo = 0, i =0;

int1 mostra_UD = 0;

byte const numeros[11] ={

 0b00111111, //0

 0b00000110, //1

 0b01011011, //2

 0b01001111, //3

 0b01100110, //4

 0b01101101, //5

 0b01111101, //6

 0b00000111, //7

 0b01111111, //8

 0b01101111 //9

 };

#int_RTCC

void RTCC_isr(void){

   

   if(++cont_int>154){

      //output_toggle(PIN_B5);

      tempo--;

      cont_int = 0;

   }

 

   if(mostra_UD==0){

      mostra_UD=1;

      i = tempo/10;

      output_d(numeros[i]);

      output_high(PIN_A4);

      output_low(PIN_A5);

   }else{

      mostra_UD=0;

      i = tempo%10;

      output_d(numeros[i]);

      output_low(PIN_A4);

      output_high(PIN_A5);

   }

 

   if(tempo==0){

      disable_interrupts(INT_RTCC);

      output_high(PIN_B6); //liga o buzzer

      

      delay_ms(2000);

      output_low(PIN_B6); //desliga o buzzer

   }

}

#int_EXT

void EXT_isr(void){

   enable_interrupts(INT_RTCC);

   tempo = tempo + 30;

   output_toggle(PIN_B4);

}

void main(){

   

   setup_adc_ports(NO_ANALOGS);

   setup_adc(ADC_OFF);

   setup_psp(PSP_DISABLED);

   setup_spi(SPI_SS_DISABLED);

   // Programa o Timer0

   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_128); // overflow vai ser com 6,5ms

   setup_timer_1(T1_DISABLED);

   setup_timer_2(T2_DISABLED,0,1);

   setup_comparator(NC_NC_NC_NC);

   setup_vref(FALSE);

   // Habilita/desabilita as interrupções do Timer0 e externa (b0)

   disable_interrupts(INT_RTCC);

   enable_interrupts(INT_EXT);

   ext_int_edge( L_TO_H );

   enable_interrupts(GLOBAL);

   // Apaga os display 7 segmentos

   output_low(PIN_A2);

   output_low(PIN_A3);

   output_low(PIN_A4);

   output_low(PIN_A5);

   output_low(PIN_B6); //desliga o buzzer

   while(true){

   };

}

 

Software: PicsimLab

Leitura do conversor AD no PicsimLab com PIC 16F877A

CÓDIGO FEITO EM CCS C Compiler

ARQUIVO mod_lcd.c

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

/*  MOD_LCD.C - Biblioteca de manipula  o de módulo LCD  */

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

// As definições a seguir são utilizadas para acesso aos pinos do display

// caso o pino RW n o seja utilizado, comente a defini  o lcd_rw

#ifndef lcd_enable

   #define lcd_enable       pin_e1      // pino enable do LCD

   #define lcd_rs         pin_e0      // pino rs do LCD

   //#define lcd_rw      pin_e2      // pino rw do LCD

   #define lcd_d4         pin_d4      // pino de dados d4 do LCD

   #define lcd_d5         pin_d5      // pino de dados d5 do LCD

   #define lcd_d6         pin_d6      // pino de dados d6 do LCD

   #define lcd_d7         pin_d7      // pino de dados d7 do LCD

#endif

#define lcd_type 2           // 0=5x7, 1=5x10, 2=2 linhas

#define lcd_seg_lin 0x40    // Endere o da segunda linha na RAM do LCD

// a constante abaixo define a seq  ncia de inicializa  o do m dulo LCD

byte CONST INI_LCD[4] = {0x20 | (lcd_type << 2), 0xf, 1, 6};

byte lcd_le_byte()

// l  um byte do LCD (somente com pino RW)

{

   byte dado;

   // configura os pinos de dados como entradas

   input(lcd_d4);

   input(lcd_d5);

   input(lcd_d6);

   input(lcd_d7);

   // se o pino rw for utilizado, coloca em 1

   #ifdef lcd_rw

      output_high(lcd_rw);

   #endif

   output_high(lcd_enable); // habilita display

   dado = 0;   // zera a vari vel de leitura

   // l  os quatro bits mais significativos

   if (input(lcd_d7)) bit_set(dado,7);

   if (input(lcd_d6)) bit_set(dado,6);

   if (input(lcd_d5)) bit_set(dado,5);

   if (input(lcd_d4)) bit_set(dado,4);

   // d  um pulso na linha enable

   output_low(lcd_enable);

   output_high(lcd_enable);

   // l  os quatro bits menos significativos

   if (input(lcd_d7)) bit_set(dado,3);

   if (input(lcd_d6)) bit_set(dado,2);

   if (input(lcd_d5)) bit_set(dado,1);

   if (input(lcd_d4)) bit_set(dado,0);

   output_low(lcd_enable);   // desabilita o display

   return dado;   // retorna o byte lido

}

void lcd_envia_nibble( byte dado )

// envia um dado de quatro bits para o display

{

   // coloca os quatro bits nas saidas

   output_bit(lcd_d4,bit_test(dado,0));

   output_bit(lcd_d5,bit_test(dado,1));

   output_bit(lcd_d6,bit_test(dado,2));

   output_bit(lcd_d7,bit_test(dado,3));

   // d  um pulso na linha enable

   output_high(lcd_enable);

   output_low(lcd_enable);

}

void lcd_envia_byte( boolean endereco, byte dado ){

   // coloca a linha rs em 0

   output_low(lcd_rs);

   // aguarda o display ficar desocupado

   //while ( bit_test(lcd_le_byte(),7) ) ;

   // configura a linha rs dependendo do modo selecionado

   output_bit(lcd_rs,endereco);

   delay_us(100);   // aguarda 100 us

   // caso a linha rw esteja definida, coloca em 0

   #ifdef lcd_rw

      output_low(lcd_rw);

   #endif

   // desativa linha enable

   output_low(lcd_enable);

   // envia a primeira parte do byte

   lcd_envia_nibble(dado >> 4);

   // envia a segunda parte do byte

   lcd_envia_nibble(dado & 0x0f);

}

void lcd_ini()

// rotina de inicializa  o do display

{

   byte conta;

   output_low(lcd_d4);

   output_low(lcd_d5);

   output_low(lcd_d6);

   output_low(lcd_d7);

   output_low(lcd_rs);

   #ifdef lcd_rw

      output_high(lcd_rw);

   #endif

   output_low(lcd_enable);

   delay_ms(15);

   // envia uma seq  ncia de 3 vezes 0x03

   // e depois 0x02 para configurar o m dulo

   // para modo de 4 bits

   for(conta=1;conta<=3;++conta){

      lcd_envia_nibble(3);

      delay_ms(5);

   }

   lcd_envia_nibble(2);

   // envia string de inicializa  o do display

   for(conta=0;conta<=3;++conta) lcd_envia_byte(0,INI_LCD[conta]);

}

void lcd_pos_xy( byte x, byte y){

   byte endereco;

   if(y!=1)

      endereco = lcd_seg_lin;

   else

      endereco = 0;

   endereco += x-1;

   lcd_envia_byte(0,0x80|endereco);

}

void lcd_escreve( char c)

// envia caractere para o display

{

   switch (c)

   {

     case '\f'    :   lcd_envia_byte(0,1);

              delay_ms(2);

            break;

     case '\n'   :

     case '\r'    :   lcd_pos_xy(1,2);

              break;

     case '\b'    :   lcd_envia_byte(0,0x10);

              break;

     default   :   lcd_envia_byte(1,c);

              break;

   }

}

char lcd_le( byte x, byte y)

// le caractere do display

{

   char valor;

   // seleciona a posi  o do caractere

   lcd_pos_xy(x,y);

   // ativa rs

   output_high(lcd_rs);

   // l  o caractere

   valor = lcd_le_byte();

   // desativa rs

   output_low(lcd_rs);

   // retorna o valor do caractere

   return valor;

}

ARQUIVO PRINCIPAL

#include <16F877A.h>

#device adc = 8

#FUSES NOWDT

#FUSES HS

#FUSES NOPUT

#FUSES NOPROTECT

#FUSES NODEBUG

#FUSES BROWNOUT

#FUSES NOLVP

#FUSES NOCPD

#FUSES NOWRT

#use delay(clock = 20MHz)

#ifndef lcd_enable

   #define lcd_enable   pin_e1 // pino enable do LCD

   #define lcd_rs       pin_e2 // pino rs do LCD

   //#define lcd_rw       pin_e2 // pino rw do LCD

   #define lcd_d4       pin_d4 // pino de dados d4 do LCD

   #define lcd_d5       pin_d5 // pino de dados d5 do LCD

   #define lcd_d6       pin_d6 // pino de dados d6 do LCD

   #define lcd_d7       pin_d7 // pino de dados d7 do LCD

#endif

#include "mod_lcd.c"

void main(){

   

   unsigned int8 value = 0;

   

   setup_adc_ports(AN0_AN1_AN3);   setup_adc(ADC_CLOCK_DIV_16);

   

   setup_psp(PSP_DISABLED);

   setup_spi(SPI_SS_DISABLED);

   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);

   setup_timer_1(T1_DISABLED);

   setup_timer_2(T2_DISABLED,0,1);

   setup_comparator(NC_NC_NC_NC);

   setup_vref(FALSE);    

   set_adc_channel(0);

   delay_us(50);

   

   lcd_ini();

   delay_ms(50);

   

   while(true){

      value = read_adc();

      printf (lcd_escreve,"\fValor = %u\r\n",value);

      printf (lcd_escreve," lido do AD ");

      delay_ms (200);

   }

}

Palavras chave:

Leughadh inneal-tionndaidh AD ann am PicsimLab

Čtení AD převodníku v PicsimLab

Läser AD-konverterare i PicsimLab

לייענען AD קאַנווערטער אין PicsimLab

Maca konverter AD ing PicsimLab

Читання AD конвертера в PicsimLab

Чытанне канвэртар AD у PicsimLab

Convertidor AD de lectura en PicsimLab

Léamh tiontaire AD i PicsimLab

LCD no PicsimLab com PIC 16F877A

CÓDIGO FEITO EM CCS C Compiler

ARQUIVO mod_lcd.c

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

/*  MOD_LCD.C - Biblioteca de manipula  o de módulo LCD                 */

/*                                                                                                         */

/*                                                                      */

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

// As definições  a seguir são utilizadas para acesso aos pinos do display

// caso o pino RW n o seja utilizado, comente a defini  o lcd_rw

#ifndef lcd_enable

   #define lcd_enable       pin_e1      // pino enable do LCD

   #define lcd_rs         pin_e0      // pino rs do LCD

   //#define lcd_rw      pin_e2      // pino rw do LCD

   #define lcd_d4         pin_d4      // pino de dados d4 do LCD

   #define lcd_d5         pin_d5      // pino de dados d5 do LCD

   #define lcd_d6         pin_d6      // pino de dados d6 do LCD

   #define lcd_d7         pin_d7      // pino de dados d7 do LCD

#endif

#define lcd_type 2           // 0=5x7, 1=5x10, 2=2 linhas

#define lcd_seg_lin 0x40    // Endere o da segunda linha na RAM do LCD

// a constante abaixo define a seq  ncia de inicializa  o do m dulo LCD

byte CONST INI_LCD[4] = {0x20 | (lcd_type << 2), 0xf, 1, 6};

byte lcd_le_byte()

// l  um byte do LCD (somente com pino RW)

{

   byte dado;

   // configura os pinos de dados como entradas

   input(lcd_d4);

   input(lcd_d5);

   input(lcd_d6);

   input(lcd_d7);

   // se o pino rw for utilizado, coloca em 1

   #ifdef lcd_rw

      output_high(lcd_rw);

   #endif

   output_high(lcd_enable); // habilita display

   dado = 0;   // zera a vari vel de leitura

   // l  os quatro bits mais significativos

   if (input(lcd_d7)) bit_set(dado,7);

   if (input(lcd_d6)) bit_set(dado,6);

   if (input(lcd_d5)) bit_set(dado,5);

   if (input(lcd_d4)) bit_set(dado,4);

   // d  um pulso na linha enable

   output_low(lcd_enable);

   output_high(lcd_enable);

   // l  os quatro bits menos significativos

   if (input(lcd_d7)) bit_set(dado,3);

   if (input(lcd_d6)) bit_set(dado,2);

   if (input(lcd_d5)) bit_set(dado,1);

   if (input(lcd_d4)) bit_set(dado,0);

   output_low(lcd_enable);   // desabilita o display

   return dado;   // retorna o byte lido

}

void lcd_envia_nibble( byte dado )

// envia um dado de quatro bits para o display

{

   // coloca os quatro bits nas saidas

   output_bit(lcd_d4,bit_test(dado,0));

   output_bit(lcd_d5,bit_test(dado,1));

   output_bit(lcd_d6,bit_test(dado,2));

   output_bit(lcd_d7,bit_test(dado,3));

   // d  um pulso na linha enable

   output_high(lcd_enable);

   output_low(lcd_enable);

}

void lcd_envia_byte( boolean endereco, byte dado )

{

   // coloca a linha rs em 0

   output_low(lcd_rs);

   // aguarda o display ficar desocupado

   //while ( bit_test(lcd_le_byte(),7) ) ;

   // configura a linha rs dependendo do modo selecionado

   output_bit(lcd_rs,endereco);

   delay_us(100);   // aguarda 100 us

   // caso a linha rw esteja definida, coloca em 0

   #ifdef lcd_rw

      output_low(lcd_rw);

   #endif

   // desativa linha enable

   output_low(lcd_enable);

   // envia a primeira parte do byte

   lcd_envia_nibble(dado >> 4);

   // envia a segunda parte do byte

   lcd_envia_nibble(dado & 0x0f);

}

void lcd_ini()

// rotina de inicializa  o do display

{

   byte conta;

   output_low(lcd_d4);

   output_low(lcd_d5);

   output_low(lcd_d6);

   output_low(lcd_d7);

   output_low(lcd_rs);

   #ifdef lcd_rw

      output_high(lcd_rw);

   #endif

   output_low(lcd_enable);

   delay_ms(15);

   // envia uma seq  ncia de 3 vezes 0x03

   // e depois 0x02 para configurar o m dulo

   // para modo de 4 bits

   for(conta=1;conta<=3;++conta)

   {

      lcd_envia_nibble(3);

      delay_ms(5);

   }

   lcd_envia_nibble(2);

   // envia string de inicializa  o do display

   for(conta=0;conta<=3;++conta) lcd_envia_byte(0,INI_LCD[conta]);

}

void lcd_pos_xy( byte x, byte y)

{

   byte endereco;

   if(y!=1)

      endereco = lcd_seg_lin;

   else

      endereco = 0;

   endereco += x-1;

   lcd_envia_byte(0,0x80|endereco);

}

void lcd_escreve( char c)

// envia caractere para o display

{

   switch (c)

   {

     case '\f'    :   lcd_envia_byte(0,1);

              delay_ms(2);

            break;

     case '\n'   :

     case '\r'    :   lcd_pos_xy(1,2);

              break;

     case '\b'    :   lcd_envia_byte(0,0x10);

              break;

     default   :   lcd_envia_byte(1,c);

              break;

   }

}

char lcd_le( byte x, byte y)

// le caractere do display

{

   char valor;

   // seleciona a posi  o do caractere

   lcd_pos_xy(x,y);

   // ativa rs

   output_high(lcd_rs);

   // l  o caractere

   valor = lcd_le_byte();

   // desativa rs

   output_low(lcd_rs);

   // retorna o valor do caractere

   return valor;

}

ARQUIVO PRINCIPAL:

#include <16F877A.h>

#device adc = 8

#FUSES NOWDT

#FUSES HS

#FUSES NOPUT

#FUSES NOPROTECT

#FUSES NODEBUG

#FUSES BROWNOUT

#FUSES NOLVP

#FUSES NOCPD

#FUSES NOWRT

#use delay (clock = 20MHz)

#ifndef lcd_enable

   #define lcd enable   pin_e1

   #define lcd_rs       pin_e2

   //#define lcd_rw     pin_e2

   #define lcd_d4       pind4

   #define lcd_d5       pin_d5

   #define lcd_d6       pin_d6

   #define lcd_d7       pin_d7

#endif

#include <C:\Users\Henrique\Documents\3MICROCONTROLADORES\13LCD\Drivers\mod_lcd.c>

void main(){

   

   float valor = 67.3215;

      

   setup_adc_ports(NO_ANALOGS);

   setup_adc(ADC_OFF);

   setup_adc(PSP_DISABLED);

   setup_spi(SPI_SS_DISABLED);

   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);

   setup_timer_1(T1_DISABLED);

   setup_timer_2(T2_DISABLED, 0, 1);

   setup_comparator(NC_NC_NC_NC);

   setup_vref(FALSE);

   

   lcd_ini();

   delay_ms(50);

   

   while(TRUE){

      //TODO: User Code

      

      //lcd_escreve('\f');//limpa a tela

      printf(lcd_escreve, "\fHello World !\n");

      //printf(lcd_escreve, "\fHello World !\r\n"); escreve da direita para esquerda

      delay_ms(200);

      

      output_toggle(PIN_D0);

            

      printf (lcd_escreve,"\fValor = %3.2f\r\n",valor);

      delay_ms(1000);

   }

}

Palavras chave:

Bhalela i-LCD usebenzisa i-PicsimLab

Escriu a la pantalla LCD amb PicsimLab

Rašykite į LCD naudodami PicsimLab

Andika LCD ukoresheje PicsimLab

Запись на LCD с помощью PicsimLab

Pagsulat sa LCD gamit ang PicsimLab

Пишите на ЛЦД користећи ПицсимЛаб

Ghi vào màn hình LCD bằng PicsimLab

Пишете на LCD с помощта на PicsimLab

כתוב ל-LCD באמצעות PicsimLab

Sgrìobh gu LCD a’ cleachdadh PicsimLab

Comandos no SQL Server #3

FUNÇÕES NO SQL SERVER

Funções em T-SQL: São rotinas que retornam valores ou tabelas. Com elas

você poderá construir visões parametrizadas ou ainda construir suas próprias

funções, semelhantes a DATE(), Rtrim() dentre outras.

Existem 3 tipos de funções possíveis

- Scalar-valued user-defined function

- Multi-statement table-valued function

- inline table-valued function 

Funções Escalares: Retornam um valor único de dados do tipo definido

na cláusula RETURNS. Para uma função escalar embutida, não há um corpo

de função; o valor escalar é o resultado de uma única instrução. O retorno

pode ser qualquer tipo de dados, execeto text, ntext, image, cursor e timestamp.

-- função para excluir

CREATE FUNCTION Trim(@ST VARCHAR (1000

  returns VARCHAR?(1000)

   BEGIN

     RETURN (Ltrim(Rtrim(@ST))) --remove os espaços na esquerda

   END

--Excemplo função eslar TRIM

SELECT '>' + ('  Silva Telles   ')+'<' union

SELECT '>' + DBO.TRIM('   Silva Telles      ') + '<'

____________________________//__________________________

Exemplo 2

--GERANDO A FUNÇÃO

CREATE FUNCTION inventario(@ProductID INT) 

  return INT AS

-- Retorna estoque de produto

BEGIN 

  DECLARE @ret INT;

  SELECT @ret = Sum(p.quantity)

FROM production.productinventory p

      WHERE p.productid = @ProductID

AND p.localionid = '6';

     IF ( @ret IS NULL)

     SET @ret = 0;

     RETURN @ret;

     END;

--Invocando a função inventario

SELECT productmodelid, name, dbo.inventario(productid) 

    AS Estoque_atual

      FROM production.product

    WHERE productmodelid BETWEEN 75 AND 80;

_______________________________//_______________________________

Procedures (Procedimentos armazenados)

Um procedimento armazenado é um tipo especial de script escrito eem Transact-SQL,

usando a linguagem SQL e extensões SQL. Os procedimentos são salvos em um 

servidor de banco de dados para aperfeiçoar o desempenho e a consistência das 

tarefas repetitivas.

Procedimentos armazenados podem ser usados para as seguintes tarefas:

- Controlar autorização de acesso

- Criar um caminho de auditoria de atividades em tabelas de banco de dados

- Separar instruções de definição e de manipulação de dados relativas a um banco de

dados das aplicações que o acessam.

--Retornar apenas o conteúdo estático

CREATE PROCEDURE TESTE1 

 AS BEGIN SELECT 'O famoso hello world!'

   END

--Executando Procedure

EXEC TESTE1 

_______________________________/ / _____________________________

TRIGGERS: É um bloco de comandos Transact-SQL que é automaticamente executado 

quando um comando INSERT, DELETE ou UPDATE for executado em uma tabela do banco de dados.

Os Triggers são usados para realizar tarefas relacionadas com validações, restrições de 

acesso, rotinas de segurança e consistência de dados; desta forma estes controles deixam

de ser executados pela aplicação e passam a ser executados pelos Triggerss em determinadas

situações.

Sintaxe:

CREATE TRIGGER [nome do trigger] ON [nome da tabela]

  [FOR/AFTER/INSTEAD OF] [INSERT/UPDATE/DELETE] AS

    --CORPO DO TRIGGER

--Os parâmetros são:

NOME DO TRIGGER:

NOME DA TABELA: Tabela â qual o gatilho estará ligado, para ser disparado mediante

ações de insert, update ou delete.

FOR/AFTER/INSTEAD OF: uma dessas opções deve ser escolhida para definir o momento em

que o trigger será disparado.

INSERT/UPDATE/DELETE: uma ou várias dessas opções (separadas por vírgula) devem ser

indicadas para informar ao banco qual é a ação que disparará o gatilho.

Existem 2 tipos de triggers:

- DML (Acionadas através de comandos de manipulação de dados)

- DDL ((Acionadas através de comandos de definição de objetos no banco de dados)

Exemplo:

CREATE TRIGGER tg_aud_sal --unico registro

  ON salario AFTER UPDATE AS BEGIN

DECLARE @sal_antigo DECIMAL (10,2)

DECLARE @sal_novo DECIMAL (10,2)

DECLARE @matricula int

SELECT @matricula = (SELECT matricula FROM inserted)

SELECT @sal_antigo = (SELECT salario FROM deleted)

SELECT @sal_novo = (SELECT salario FROM inserted)

   INSERT INTO auditoria_salario VALUES

     (@matricula isnull (@sal_antigo, 0), @sal_novo, SYSTER_USER, getdate)__

   END

--Testando triggers

upadate salario set salario = '2500' where matricula = '1'

upadate salario set salario = '3000' where matricula = '2'

select *from auditoria_salario 

________________________ / / _______________________________________

TRIGGER no SQL Server

ALTER TRIGER trg_atualiza_saldo_cc ON conta_corrente --aluliza saldo onde a conta corrente recebe

FOR INSERT AS --inclui um registro 

  BEGIN 

    DECLARE @CONTA_C VARCHAR(20),--declara algumas variaveis

         @VALOR DECIMAL (10, 2),

         @OPER CHAR(1)

    SELECT @CONTA_C = I.conta_c,--faz a seleção

           @VALOR = I.valor,

   @OPER = I.operacao

    FROM inserted I -- e atribui o insert das variavéis

D = debito   C = crédito

   IF @OPER NOT IN ('D', 'C') BEGIN

     PRINT 'OPERACAO NAO PERMITIDA' 

ROLL BACK TRANSACTION 

    END

   ELSE IF (SELECT Count(*)

     FROM saldo_conta

     WHERE conta_c = @conta_c) = 0

    AND @OPER = 'D' -- e operação igual à débito

    BEGIN

      INSERT INTO saldo_conta

      VALUES   (@CONTA_C, @VALOR *-1) -- se está emprestando entao fica devendo

   END

  ELSE IF (SELECT Count(*)

    FROM saldo_conta

    WHERE conta_c = @conta_c) = 0

   AND @OPER = 'C'

   BEGIN

  INSERT INTO saldo_conta

  SET saldo = saldo + @VALOR

WHERE conta_c = @CONTA_C

   END

  ELSE IF (SELECT Count(*)

FROM saldo_conta

WHERE conta_c = @conta_c) > 0

AND @OPER = 'D'

     BEGIN

    UPDATE saldo_conta

SET saldo = saldo - @VALOR

WHERE conta_c = @CONTA_C

    END

END

Palavras chave:

FUNCIONES EN SERVIDOR SQL

FUNGSI ING SQL SERVER

פונקציות ב-SQL SERVER

ФУНКЦИИ В SQL СЕРВЕРЕ

ФУНКЦІЇ В SQL СЕРВЕРУ

SQL सर्भरमा कार्यहरू

CÁC CHỨC NĂNG TRONG SQL SERVER

MGA FUNCTION SA SQL SERVER

FUNKCIJE U SQL SERVERU

FUNCIONS EN SQL SERVER

FUNCIONS EN SQL SERVER