Pesquisar neste blog

07/04/2022

#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++;
      }
      
   }
}

05/04/2022

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




















04/04/2022

#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








02/04/2022

#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);
      
   }
}


















20/03/2022

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





17/03/2022

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

16/03/2022

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