DBA - DBCC no Microsoft SQL Server #108 #109 #110

DBA - DBCC (DataBase Console Comamands)

DBCC: São comandos que fazem a consitência lógica e física do banco de dados.

Apesar da maioria dos comandos ser somante para retornar informações sobre o banco

existem alguns comandos que podem ajudar a resolver problemas.

DBCC - Manutenção

DBCC TABLE CHECK: A consitência lógica e física dos objetos no banco de dados é verificada

nessa fase.

DBCC TABLE REPAIR: As correções de banco de dados são executadas nessa fase, se REPAIR_FAST,

REPAIR_REBUILD ou REPAIR_ALLOW_DATA_LOSS for especificado e houver erros de objeto que

precisem ser corrigidos.

DBCC SYS CHECK: As tabelas do sistema de banco de dados são verificadas nessa fase.

DBCC SYS REPAIR: As correções de banco de dados são realizadas nessa fase se REPAIR_FAST, REAPIR_REBUILD 

ou REPAIR_ALLOW_DATA_LOSS for especificado e houver erros de tabelas do sistema que 

precisem ser corrigidos.

DBCC FREEPROCCACHE: Limpa cache de procedures

DBCC - Diversas Miscellneous

DBCC HELP: Retorna informações de sintaxe para o comando especificado DBCC.

DBCC dilname(FREE): Descarrega o procedimento armazenado estendido DLL especificado da memória

DBCC TRACEON: Habilita os sinalizadores de rastreamento especificados

DBCC TRACEOFF: Desabilita os sinalizadores de rastreamento especificados.

DBCC - Informações

DBCC SHOWCONTIG: Exibe informaçções de fragmentação para os dados e índices da tabela ou exibição especificada

DBCC SHOW_STATISTICS: Exibe as estatísticas de otimização de consulta atuais de uma tabela ou exibição indexada

DBCC PROCCACHE: Exibe informações em um formato de tabela sobre o cache de procedimento

DBCC OPENTRAN: Ajuda a identificar as transações ativas que podem impedir o truncamento do log

DBCC - Validação

DBCC CHECKDB: Verifica a integridade lógica e física de todos os objetos do banco de dados especificando com

execução das seguintes operações

DBCC CHECKTABLE: Verifica a integridade de todas as páginas e estruturas que compõe a tabela ou a exibição

indexada

DBCC CHECKCONSTRAINTS: Inspeciona a integridade de uma restrição especificada ou de todas as restrições em

uma tabela especificada no banco de dados atual.

DBCC CHECKALLOC: Verifica a consitência de estruturas de alocação de espaço em disco para um banco de dados

especificado

_______________ DBCC PARA OBTER INFORMAÇÕES ____________________

--Link de apoio: https://msdn.microsoft.com/pt-br/library/ms188796(v=sql.120).aspx

USE MASTER

DBCC HELP('?'); -- exibe os comandos para execução

DBCC HELP (SHOW_STATISTICS) --(checkdb),(

--Exibe informações de fragmentação para os dados e índices da tabela ou exibição específica

use curso

DBCC SHOWCONTIG (cidades)

--Exibe as estatísticas de otimização de consulta atuais de uma tabela ou exibição indexada

DBCC SHOW_STATISTICS (cidades)

--Exibe as informações em um formato de tabela sobre o cache de procedimento

DBCC PROCCACHE

--Ajuda a indetificar as transações ativas que podem impedir o truncamento do log

DBCC OPENTRAN

#109_______________DBCC PARA DIVERSOS __________________

--Retorna informações de sintaxe para o comando específico DBCC.

DBCC HELL (?)

DBCC HELP (TRACEON) --(CHECKALLOC)

--Descarrega o procedimento armazenado estendido DLL especificado da memória

DBCC dllname (FREE)

--select *from sys.session

--Habilita os sinalizadores de rastreamento especificados

DBCC TRACEON

--Exibe o status de sinalizadores de rastreamento

DBCC TRACESTATUS

--Desabilita os sinalizadores de rastreamento especificados.

DBCC TRACEOFF

--apoio

--Conexões ativas

SELECT *FROM sys.dm_exec_connections

--Verificando arquivo trave

SELECT TextData,

SPID, 

LoginName,

NTUserName,

NTDomainName,

HostName,

ApplicatinName,

StarTime, ServerName,

DatabaseName,

EventClass,

ObjectType

FROM fn_trace_gettable('C:\Program Files\Microsoft SQL Server\MSSQL12.SQLEXPRESS\MSSQL\Log\log_19.trc',default)

#110____________________

--Verifica a integridade lógica e física de todos os objetos do banco de dados

--especificado com a execução das seguintes operações:

ALTER DATABASE curso SET SINGLE_USER

USE curso

DBCC CHECKDB (curso, REPAIR_FAST)

DBCC CHECKDB (curso, REPAIR_REBUILD)

DBCC CHECKDB (curso, REPAIR_ALLOW_DATA_LOSS)

--Verifica a integridade de todas as páginas e estruturas que compõem

--a tabela ou a exibição indexada

DBCC CHECKTABLE (cidades)

--Inspeciona a integridade de uma restrição especificada ou de todas

--as restrições em uma tabela especificada no banco de dados atual

DBCC CHECKCONSTRAINTS

--Verifica a consistencia de estruturas de alocação de espaço em disco

--para um banco de dados específíco

_____________DBCC DE MANUTENÇÃO____________________

DBCC HELP ('?');

DBCC HELP ('CHECKTABLE');

--A consistência lógica e física dos objetos no banco de dados é 

--verificada nessa fase.

use curso

DBCC CHECTABLE ('pedidos');

--As correções de banco de dados são executados nessa fase, se REPAIR_FAST,

--REPAIR_REBUILD ou REPAIR_ALLOW_DATA_LOSS

--for especificado e houver erros de objeto que precisem ser corrígidos

--DBCC TABLE REPAIR

USE MASTER

ALTER DATABASE curso SET SINGLE_USER;

DBCC CHECKTABLE ('cidades', REPAIR_FAST)

DBCC CHECKTABLE ('cidades', REPAIR_REBUILD)

DBCC CHECKTABLE ('cidades', REPAIR_ALLOW_DATA_LOSS)

DBCC CHECKSYS --As tabelas são verificadas nessa fase

Status de porta com PIC 16F877A

Objetivo: Visualizar em um LCD o status das entradas PORTA . Temos os componentes ISIS: PIC16F877A, RESPACK8, LG M I264IBSIR e SW-SPST-M OM

#include <16F877A.h>

#fuses HS, NOWDT, NOPROTECT, NOLVP

#use delay(clock = 20MHz)

#include <HDM64GS12.c>

#include <graphics.c>

#use standard_io(a)

void main(){

   CHAR A5[] = "A5";

   CHAR A4[] = "A4";

   CHAR A3[] = "A3";

   CHAR A2[] = "A2";

   CHAR A1[] = "A1";

   CHAR A0[] = "A0";

   CHAR IN[] = "PORTA A";

   glcd_init(ON);

   glcd_text57(33, 30, A5, 1, 1);

   glcd_text57(49, 30, A4, 1, 1);

   glcd_text57(65, 30, A3, 1, 1);

   glcd_text57(81, 30, A2, 1, 1);

   glcd_text57(97, 30, A1, 1, 1);

   glcd_text57(113, 30, A0, 1, 1);

   glcd_text57(30, 5, IN, 2, 1);

   

   while(TRUE){

      if (input_state(PIN_A5) == 0){

         glcd_rect(32, 40, 46, 60, 1, 1);

      }else{

         glcd_rect(32, 40, 46, 60, 1, 0);

         glcd_rect(32, 40, 46, 60, 0, 1);

      }

      

      if (input_state(PIN_A4) == false){

         glcd_rect(48, 40, 62, 60, 1, 1);

      }else{

         glcd_rect(48, 40, 62, 60, 1, 0);

         glcd_rect(48, 40, 62, 60, 0, 1);

      }

      

      if (input_state(PIN_A3) == false){

         glcd_rect(64, 40, 78, 60, 1, 1);

      }else{

         glcd_rect(64, 40, 78, 60, 1, 0);

         glcd_rect(64, 40, 78, 60, 0, 1);

      }

      

      if (input_state(PIN_A2) == false){

         glcd_rect(80, 40, 94, 60, 1, 1);

      }else{

         glcd_rect(80, 40, 94, 60, 1, 0);

         glcd_rect(80, 40, 94, 60, 0, 1);

      }

      

      if (input_state(PIN_A1) == false){

         glcd_rect(96, 40, 110, 60, 1, 1);

      }else{

         glcd_rect(96, 40, 110, 60, 1, 0);

         glcd_rect(96, 40, 110, 60, 0, 1);

      }

      

      if (input_state(PIN_A0) == false){

         glcd_rect(112, 40, 126, 60, 1, 1);

      }else{

         glcd_rect(112, 40, 126, 60, 1, 0);

         glcd_rect(112, 40, 126, 60, 0, 1);

      }

      

      delay_ms(400);

   }

}

Contador multiplexado com PIC 16F876

Código feito no CCS C Compiler

//PÁGINA 63

#include <16F876.h>

#USE DELAY(CLOCK = 4MHz)

#FUSES XT, NOWDT, NOPROTECT, NOPUT

#USE fast_IO (B)

#USE fast_IO (A)

byte CONST DISPLAY[10] = {0x3f, 0x06, 0x5b, 0x4f, 0x66, 

         0x6d, 0x7d, 0x07, 0x7f, 0x6f};

         

void main(){

   byte ud = 0, dec = 0;

   SET_TRIS_B(0x00);

   SET_TRIS_A(0x00);

   OUTPUT_B(0);

   

   for( ;; ){

      for(dec = 0; dec < 10; dec++){

         for(ud = 0; ud < 10; ud++){

            output_a(0x02);

            output_b(DISPLAY[ud]);

            delay_ms(50);

            

            if (dec == 0) output_a(0x03);

            else output_a(0x01);

                                    //cat_D_ = acender

            OUTPUT_B(DISPLAY[dec]);//digito dezenas

            delay_ms(50);     //para evitar paralelos

         }

      }

   }

}

SUSPECT no SQL Server #107

SUSPECT (Recuperando de um Desastre)

Este estado no Banco de Dados acontece quando alguns dos arquivos do grupo de

Banco de Dados estão corrompidos. Na inicialização do SQL Server, este verifica

se os arquivos estão íntegros.

Se ele encontra -se com algum problema nesses arquivos, ele coloca o banco de dados no

estado 'SUSPECT', 'RECOVERY_PENDING'. Esse estado necessita da ação direta do Administrador

de Banco de Dados.

--SET BACKUP FULL

ALTER DATABASE desastre SET recovery full --opcional

--Realiza backup

BACKUP DATABASE desastre TO disk=N'C:\LOCAL ARMAZENADO.NOME.bak'

--Recuperando do BD

--1 colocar BD em emergency

ALTER DATABASE desastre SET EMERGENCY

--2 Fazer um backup do log de transações mesmo o banco estando como suspect

--(lembrando que o log de transações deve estar íntegro em outra unidade de disco);

--BACKUP DO ARQUIVO !!!

--3 Em alguns casos é necessário a exclusão do banco de dados marcado como 'Suspect';

--4 Restaurar o último backup full;

--  DROP DATABASE DESASTRE 

RESTORE DATABASE DESASTRE FROM disk=N'C:\LOCAL DO BD\desastre.bak'

WITH RECOVERY, REPLACE --REPLACE substitui esses arquivos

--Verificando base

SELECT *FROM MATERIAL

DBA - LINKED SERVER #106

LINKED SERVER é utilizado para realizarem consultas em outros servidores.

Essa "ponte" de comunicação é possível entre fontes OLE BD, como Excel, Acces,

servidores SQL Server e até servidores como outro SGBDs como Oracle, Mysql, Sybase.

As principais vantagens de se utilizar Linked Server é a facilidade de executar consultas

distribuídas, comandos de atualizações que envolvem diversas bases em servidores diferentes.

SIMULANDO LINKED SERVER

Para simular o Linked Server em ação, será necessário no minimo duas instâncias, 

onde elas podem estar ou não no mesmo servidor. Vamos criar un banco de dados e uma

tabela, a qual será utilizada para realizar consultas e manipulação através do

Linked Server.

--Verificando se existe LINKED SERVER NO BD

SELECT *FROM sys.servers

A instancia SERVER1 conterá o banco de dados DB_LK, que será acessado pela instancia

SERVER2

Configuration Manager Pipes Nomeado e TCP/IP -> Habilitados

Configurações Firewall -> Portas 1433, 1434 -> Liberadas, Regras.

Conexão Remota na Instancia -> Permitir

Conexão entre as redes -> Funcionando

--Verificando se exeiste LINKED SERVER NO BD

SELECT * FROM sys.servers

--CRIANDO LINKED SERVER

EXEC sp_addlinkedserver

@server = 'INFINITY', --servidor/IP infinity

@srvproduct = '',

@provider = 'SQLNCLI',

@datasrc = 'INFINITY\SQLEXPRESS2'--data serce 'instancia sqlexpress2

--Gerando usuário do LINKED SERVER

EXEC sp_addlinkedsrvlogin

@rmtsrvname = 'INFINITY'

@useself = 'true',

@locallogin = 'INFINITY\andre',

@rmtuser = NULL,

@rmtpassword = 'SUA SENHA'.. --senha remota do computador

--Selecionando dados através do LINKED SERVER

SELECT *FROM INFINITY.TESTE_LINK.dbo.PESSOAS --nomedoprovedor.nomedoBD.dbo.nomedaTabela

--ATUALIZANDO DADOS ATRAVES DO LINKED SERVER

UPDATE INFINITY.TESTE_LINK.dbo.PESSOAS SET NOME = 'TESTE UPADATE' WHWRE ID = 5

--Inserindo dados atraves do LINKED SERVER

INSERT INTO INFINITY.TESTE_LINK.dbo.PESSOAS (NOME) VALUES ('JACK')

ATTACH no SQL Server #105

ATTACH/DETACH

É possível anexar ou desanexar ou banco de dados através do recurso de administração do SQLSERVER, através do modo Gráfico ou linha de comando.

Exemplos gráfico (Demonstração);

Exemplos linha de comando abaixo:

--DETACH/DESANEXANDO BD

USE master;

GO EXEC sp_detach_bd @dbname = N'CURSO';

GO

--ATTACH/ANEXANDO BD

USE master;

GO

CREATE DATABASE curso --Gera o arquivo com bases dados

ON (FILENAME = 'C:\local do diretório\arquivo1.mdf'),

   (FILENAME = 'C:\local do diretório\arquivo2.ldf')

FOR ATTACH;

GO

SHRINK no SQL Server #104

DBA - REDUZIR - SHRINK

SHRINK: São comandos/tarefas utilizadas para redução do tamanho

de banco de dados ou arquivos. 

É possível reduzer cada arquivo dentro de um banco de dados para remover

páginas sem utilização. Embora o Mecanismo de Banco de Dados

reutilize efetivamente os espaços, há momentos em que um 

arquivo não necessita mais ser tão grande quanto era.

--Quando a opção AUTO_SHRINK do banco de dados estiver definida como ON /redução automática

ALTER DATABASE nome_bd SET AUTO_SHRINK OFF --Desliga

ALTER DATABASE nome_bd SET AUTO_SHRINK ON --Liga

--Reduzindo um banco de dados e especificando uma porcentagem de espaço livre

DBCC SHRINKDATABASE (AdventureWorks2014, 10); -- 10%

--Truncando un banco de dados

DBCC SHRINKDATABASE (AdventureWorks2014, TRUNCATEONLY); --Reduz até a última extensão alocada

--Reduzindo arquivo de dados

DBCC SHRINKFILE (AdventureWorks2014_Data, 10); -- 10%

DBCC SHRINKFILE (AdventureWorks2014_Log, 5); --5%

Analise de crescimento DB #103

--Verificando tamanho/espaço ocupado pelos banco de dados

EXEC sp_spaceused 'alunos'

EXEC sp_spaceused 'cidaddes'

--Verificando as tabelas

SELECT

   OBJECT_NAME(object_id) AS Tabela, p.Rows AS Linhas, -- tras na tabela p --Na tabela a, vai somar o campo Total_Pages irá multiplicar por 8 

   SUM(a.Total_Pages * 8) AS RESERVADO, --ira trazer as linhas

   SUM(CASE WHEN p.Index_ID) > 1 THEN 0 ELSE a.Data_Pages * 8 END) AS Dados, --Quantos que os dados irá ocupar naquela tabela

    SUM(a.Used_Pages * 8) -

SUM(CASE WHEN p.Index_ID > 1 THEN 0 ELSE a.Data_Pages * 8 END) AS Indice,

   SUM((a.Total_Pages - a.Used_Pages) * 8) AS NaoUtilizado

FROM

    sys.partitions AS p INER JOIN sys.allocation_units AS a

    ON p.hobt_id = a.container_id

GROUP BY OBJECT_NAME(object_id), ROWS

ORDER BY dados desc --Trazer em ordem decrescente

Statistics no Microsoft SQL Server #102

Statistics

Estatisticas (statistics) são objetos que detêm informações importantes sobre a distribuitção dos dados dentro de tabelas e views indexadas. As estatísticas são de extrema importância para o SQL Server, uma vez que o Otimizador de Consulta  (Query Optimizer) utiliza as estatísticas paa analisar a seletividade e 

cardinalidade dos dados.

-- seleciona tudo da tabela alunos exeto o que contém Gustavo

SELECT * FROM alunos WHERE nome NOT LIKE ('Gustavo%) 

--VERIFICANDO STATISTICS

EXEC sp_helpstats 'alunos', 'all'

--verificando tabela de estatisticas

SELECT *FROM sys.stats WHERE object_id = OBJECT_ID('alunos')

--Estatísticas criadas implicitamente é quando geramos um índice 

--seja ele clustered ou não, e por consequencia são criadas estatísticas

implicitamente para os campos chaves do índice

--Força um primary key

ALTER TABLE campoenato ADD CONSTRAINT pc_time PRIMARY KEY 

 CLUSTERED (nometime)

--Verificando estatistics

EXEC sp_helpstats 'campeonato', 'all'

--Estatísticas criadas manualmente

--Também podemos gera -las manualmente, utilizando o comando CREATE STATISTICS

CREATE STATISTICS St_id_nome ON alunos (aluno_id, aluno_nome);

Mini teste 1 #2021/2

Construa um programa (em C) para sistema baseado no microcontrolador PIC16F877A que após o botão B1 ser pressionado ele escreve o dia e o mês do seu nascimento (com interrupção do B1). Quando o B0 for pressionado ele apaga tudo

Ex 25:12 (vinte e cinco de dezembro)

Resolução feita no CCS C Compiler

#include <16F877A.h>

#device adc=8

#use delay(clock = 20MHz)

#fuses NOWDT, HS, NOPUT, NOPROTECT, NODEBUG, BROWNOUT, NOLVP

#fuses NOCPD, NOWRT

#define t 5

unsigned int8 display [ ] = {

   0b000000,   // display desligado

   0b000100,   // display 1

   0b001000,   // display 2

   0b010000,   // display 3

   0b100000,  // display 4

};

unsigned int8 v1[] = {0b00111111, 0b00000110, 0b01011011, 

   0b01001111, 0b01100110, 0b01101101, 0b01111101, 

   0b00000111, 0b01111111, 0b01100111};

#int_EXT

void EXT_isr(void){

   enable_interrupts(INT_RTCC);

   if(input(PIN_B1) == TRUE){

      output_a(display[0]); // desliga todos os display

      delay_ms(500);

      

   }

}

void main(){

   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_128);

   setup_timer_1(T1_DISABLED);

   setup_timer_2(T2_DISABLED, 0, 1);

   setup_comparator(NC_NC_NC_NC);

   setup_vref(FALSE);

   

   disable_interrupts(INT_RTCC);

   enable_interrupts(INT_EXT);

   

   ext_int_edge(L_TO_H);

   enable_interrupts(GLOBAL);

    

   

   while(true){

            

      for(int i = 0; i < 15; i++){

         output_a(display[1]);

         output_d(v1[1]);

         delay_ms(t);

         

         output_a(display[2]);

         output_d(v1[6]);

         delay_ms(t);

         

         output_a(display[3]);

         output_d(v1[0]);

         delay_ms(t);

         

         output_a(display[4]);

         output_d(v1[8]);

         delay_ms(t);

         

      }

   }

}

Saída gerada no PicsimLab

Backup no SQL Server

--BACKUP

USE MASTER

ALTER DATABAE nome_do_BD SET RECOVERY FULL

BACKUP DATABASE nome_do_BD TO DISK = "C:\LOCAL' WITH STATS

--Processo de restauração do BACKUP

RESTORE DATABASE nome_do_BD FROM DISK = 'C:\LOCAL DO BD' WITH STATS, RECOVERY

--Backup multiplos arquivos

BACKUP DATABASE nome_do_BD 

TO DISK = 'C:\local1',

DISK = 'C:\local2',

DISK = 'C:\local3',

DISK = 'C:\local4',

WITH STATS

--Restauração de mutiplos backups

RESTORE DATABASE nome_do_BD 

 FROM DISK ='C:\local21',

DISK = 'C:\local2',

DISK = 'C:\local3',

WITH STATS, RECOVERY

Modo OFFLINE e ONLINE no SQL Oracle

Objetivo: Derrubar o uso do banco de dados através de comando

--Deixa OFFlILINE e derruba todas as conexões

USE MASTER

GO

ALTER DATABASE curso SET OFFLINE WITH ROLLBACK IMMEDIATE --curso é banco de dados

--Colocar Online

USE MASTER GO

ALTER DATABASE curso SET ONLINE 

USE MASTER;

GO

--BD modo único usuário

ALTER DATABASE curso SET SINGLE_USER WITH ROLLBACK IMMEDIATE;

GO

--Banco de Dados em modo único usuário

USE MASTER;

GO

ALTER DATABASE curso SET SINGLE_USER WITH ROLLBACK IMMEDIATE;

GO

--BD modo de leitura

ALTER DATABASE curso SET READ_ONLY;

GO

--BD modo muitos usuários

ALTER DATABASE curso SET MULTI_USER;

GO

--BD leitua e gravacaao

ALTER DATABASE curso SET READ_WRITE;

GO

Memória EEPROM com PIC 16F877A

 Objetivo: Gravar um dado na memória EEPROM a cada pressionada de botão

Código feito no CCS C Compiler

#include <16F877A.h>

#device adc = 10

#include <math.h>

#use delay(clock = 4MHz)

#fuses XT, NOWDT, NOPROTECT, NOBROWNOUT, PUT, NOLVP

#include <lcd.c>

#define value pin_b1

int8 data = 30, a = 100, location = 0, read_data; // read_data = 255

float analog_temp, actual_temp, temp_ms;

void main(){

   setup_adc(ADC_CLOCK_DIV_32);

   lcd_init();

   read_data = read_eeprom(15); //retornar um byte de um endereço de memória específico

   lcd_gotoxy(1, 1);

   printf(lcd_putc, "Local 15: %u", read_data);

   lcd_gotoxy(1, 2);

   printf(lcd_putc, "Verificar dados: %u", a);

   

   while(TRUE) {

      if(input(value)){// a cada precionada grava byte

         delay_ms(1000);

         data++;

         location++;

         a++;

         write_eeprom(location, data); //Grava um byte no endereço EEPROM de dados especificado

         read_data = read_eeprom(location);

         lcd_gotoxy(21, 2);

         printf(lcd_putc, "Local %u : %u", location, read_data);

      }

   }

   

}

Saída gerada no software Proteus versão 7.9

Frequência com TIMER0 no PIC 16F877A

Código feito no CCS C Compiler

#include <16F877A.h>

#device adc = 8

#FUSES NOWDT, HS, NOPUT, NOPROTECT, NODEBUG, BROWNOUT, NOLVP, NOCPD, NOWRT, NOWRT

#use delay(clock = 20MHz)

unsigned int16 cont1 = 0, cont2 = 0, cont3 = 0;

/*Contagem  frequencia de entrada

   PARA 220 Hz

   PARA 95 Hz

   PARA 82 Hz 

*/

// 274 Hz ---> 36 ---> 3.65ms

#int_TIMER0

void TIMER0_isr(void){

   if(++cont1 >= 44)  { cont1 = 0; output_toggle(pin_B0) ; } // [274 * 36] / 220) = 44

   if(++cont2 >= 103) {cont2 = 0;output_toggle(pin_B1); } //   [274 * 36] / 95 = 103

   if(++cont3 >= 120) {cont3 = 0; output_toggle(pin_B2); } //  [274 * 36] / 82 = 120

}

void main(){

   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); // overflow 51,2 us

   setup_timer_1(T1_DISABLED);

   setup_timer_2(T2_DISABLED,0,1);

   setup_comparator(NC_NC_NC_NC);

   setup_vref(FALSE);

   enable_interrupts(INT_TIMER0);

   enable_interrupts(GLOBAL);

   //disable_interrupts(GLOBAL);

   

   while(true);

}

Saída gerada no software Proteus 7.9

Serial com PIC 16F877A

Código feito no CCS C Compiler

#include <16F877A.h>

#device adc = 8

#FUSES NOWDT, HS, NOPUT, NOPROTECT

#FUSES NODEBUG, NOBROWNOUT, NOLVP, NOCPD, NOWRT

#use delay(clock = 20MHz)

//#use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)

#use rs232(baud = 9600, parity = N, xmit = PIN_C6, rcv = PIN_C7, bits = 8, STREAM = Wireless)

#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>

unsigned int i = 0, tensao = 0;

signed int y = -50;

void main(){

   setup_adc(ADC_CLOCK_DIV_16);

   setup_adc_ports(AN0);

   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();

   while(true){

      

      putc('A');

      putc('\n');

      putc('\r');

      delay_ms(1000);

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

         //fprintf(Wireless,"%u %d\r", i, y);

         printf(lcd_escreve, "%u %d\r", i, y);

         delay_ms(1000);

         if(++y > 50) y = -50;

      }

   }

}

Saída gerada no PicsimLab

Memória Externa RS232 Long e Float com PIC 16F877A

Código feito no CCS C Compiler

#include <16F877A.h>

#device adc = 8

#FUSES NOWDT //No Watch Dog Timer

#FUSES XT //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 NOBROWNOUT //No brownout reset

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

#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"

#include "2404.C"

   long int End_HL(byte H, byte L){

   return (H<<8)+ L;

}

char* IntToHex(int value) {

   int a;

   int b;

   char* buffer;

   a = value && 16;

   b = (value>>4)&16;

   buffer[0] = (a<10)?'0'+a:'A'-(a-10);

   buffer[1] = (b<10)?'0'+b:'A'-(b-10);

   return buffer;

}

WRITE_FLOAT_EXT_EEPROM(long int n, float data) {

   int i;

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

      write_ext_eeprom(i + n, *((int8*)&data + i) ) ;

}

float READ_FLOAT_EXT_EEPROM(long int n) {

   int i;

   float data;

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

      *((int8*)&data + i) = read_ext_eeprom(i + n);

      return(data);

}

void eeprom_int16(unsigned int endereco, int16 valor_i16){

   write_ext_eeprom(endereco, make8(valor_i16,0));

   write_ext_eeprom(endereco+1, make8(valor_i16,1));

}

int16 read_int16_ext_eeprom(long int endereco) {

   int a, b;

   int16 valor;

   a = read_ext_eeprom(endereco);

   b = read_ext_eeprom(endereco + 1);

   valor = make16(b, a);

   return valor;

}

void main() {

   byte dispositivo1,dispositivo2;

   unsigned int8 a,b,c,d;

   unsigned int endereco;

   int16 Temperatura;

   float pressao = 21.37f;

   float result_f;

   setup_adc_ports(NO_ANALOGS);

   setup_adc(ADC_OFF);

   setup_psp(PSP_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(); // Inicializa LCD

   delay_ms(10);

   init_ext_eeprom();

   delay_ms(10);

   printf (lcd_escreve,"\f iniciando...");

   delay_ms(2000);

   while (true){

      write_ext_eeprom(0x1, 6);

      write_ext_eeprom(0x2, 9);

      write_ext_eeprom(3, 12);

      write_ext_eeprom(4, 40);

      write_ext_eeprom(5, 50);

      write_ext_eeprom(6, 60);

      write_ext_eeprom(7, 70);

      Temperatura = 730;

      endereco = 8;

      eeprom_int16(endereco,Temperatura);

      endereco = 10;

      WRITE_FLOAT_EXT_EEPROM(endereco,pressao);

      printf(lcd_escreve,"\fValor: %d",read_ext_eeprom(0x2 ));

      printf(lcd_escreve,"\r\nValor: %d",read_ext_eeprom(4));

      delay_ms(3000);

      //a = read_ext_eeprom(8);  

      //b = read_ext_eeprom(9);

      //printf(lcd_escreve,"\fTemp.: %lu",make16(b,a));

      printf(lcd_escreve,"\fTemp.: %lu", read_int16_ext_eeprom(8));

      delay_ms(3000);

   

      result_f = READ_FLOAT_EXT_EEPROM(10);

      printf(lcd_escreve,"\fPressao: %.1f", result_f);

      delay_ms(3000);

   }

}

Software: PicsimLab

Memória Externa RS232 com PIC 16F877A

Código feito no CCS C Compiler

#include <16F877A.h>

#fuses HS,NOWDT,NOPROTECT,NOLVP

#use delay(clock = 20MHz)

#use rs232(baud = 9600, xmit = PIN_C6, rcv = PIN_C7)

#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"

//#include "input.c"

#include "2401.c"

void main() {

   BYTE value,value_recebido, cmd;

   EEPROM_ADDRESS address;

   unsigned int8 i = 0;

   init_ext_eeprom();

   lcd_ini();

   delay_us(50);

   // TODO: USER CODE!!

   printf (lcd_escreve,"\f iniciando...");

   delay_ms(2000);

   for(i = 0; i <= 128; i++){

      WRITE_EXT_EEPROM(i, 255 );

      WRITE_EXT_EEPROM(0, 8 ); 

      WRITE_EXT_EEPROM(1, 7);

      WRITE_EXT_EEPROM(2, 'P');

      WRITE_EXT_EEPROM(3, 'A');

      WRITE_EXT_EEPROM(4, 55);

      //WRITE_EXT_EEPROM(1, 7); //valores repetidos

   }

   value_recebido = READ_EXT_EEPROM(0);

   while(true){

      printf (lcd_escreve,"\f IFMT ");

      //printf("\n\rTemp = %d", value);

      printf (lcd_escreve,"\n\rValor: %i %c", value_recebido, value_recebido);

      delay_ms(2000);

   }

}

Saída gerada no Software PicsimLab

Memória interna RS232 com PIC 16F877A

Código feito no CCS C Compiler

#include <16F877A.h>

#device adc = 8

#FUSES NOWDT   //Sem temporizador de vigilância

#FUSES HS      //Crystal osc <= 4 mhz para PCM/PCH, 3 mhz a 10 mhz para

#FUSES NOPUT   //Sem temporizador de inicialização

#FUSES NOPROTECT //Código não protegido contra leitura

#FUSES NODEBUG    //Sem modo de depuração para ICD

#FUSES BROWNOUT   //Redefinir quando o brownout for detectado

#FUSES NOLVP      //Sem progamação de baixa tensão, B3(PIC16) ou B5(PIC18) usado para E/S

#FUSES NOCPD      //No EE protection

#FUSES NOWRT      //Memória de programa não protegida contra gravação

#use delay(clock = 20MHz)

#use rs232(baud = 9600, parity = N, xmit = PIN_C6, rcv = PIN_C7, bits = 8)

#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 result = 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_us(50);

   // TODO: USER CODE!!

   printf (lcd_escreve,"\f iniciando...");

   delay_ms(2000);

   write_eeprom(0,'A'); // 0x41

   write_eeprom(1,221); //

   write_eeprom(2,'9'); //

   write_eeprom(3,'D'); //

   

   result = read_eeprom(2);

   while(true){

      printf (lcd_escreve,"\f IFMT ");

      //printf("\n\rTemp = %d", value);

      printf (lcd_escreve,"\n\rValor: %u %c", result, result); //imprimi o valor ASCII, seu caracter

      delay_ms(2000);

   }

}

Saída gerada no PicsimLab

Saída gerada no software Proteus 7.9

Converter ADC em voltagem com PIC 16F877A

Objetivo: Receber um valor analógico através do potenciômetro, converter esse valor para tensão e exibir seus dados no LCD usando microcontrolador PIC 16F877A.

Código feito em CCS C Compiler

#include <16F877A.h>

#device adc = 8

#FUSES NOWDT, HS, NOPUT, NOPROTECT, NODEBUG, BROWNOUT, NOLVP, NOCPD, NOWRT, NOWRT

#use delay(clock = 20MHz)

#include <lcd.c>

unsigned int8 analog;

float tensao ;

void main(){

   setup_adc(ADC_CLOCK_DIV_32);           // Set ADC conversion time to 32Tosc

   setup_adc_ports(AN0_AN1_AN3);          // Configure AN0,AN1 and AN3 as analog   

   setup_ccp2(CCP_PWM);                   // Configure CCP2 as a PWM

   setup_timer_2(T2_DIV_BY_16, 255, 1);   // Set PWM frequency to 488Hz

   set_adc_channel(0);                    // Select channel AN1   

   

   lcd_init();

   

   while(true) {

      analog = read_adc();

      tensao = (5.0 / 255.0) * analog; // 5V , (2^8) - 1 = 255

      

      printf(lcd_putc,"\fADC = %u\nTensao = %01.2f V",analog, tensao);

      delay_ms(100);

   }

}

Software Proteus versão 7.9

Palavras chave:

Convert ADC to Voltage with PIC 16F877A

U beddelo ADC Voltage PIC 16F877A

Konwertuj ADC na napięcie za pomocą PIC 16F877A

Převeďte ADC na napětí pomocí PIC 16F877A

Konverter ADC til spenning med PIC 16F877A

Ngonversi ADC kanggo Tegangan karo PIC 16F877A

המר ADC למתח עם PIC 16F877A

Convertir ADC en tension avec PIC 16F877A

Преобразование АЦП в напряжение с помощью PIC 16F877A

Konvertera ADC till spänning med PIC 16F877A

PIC 16F877A를 사용하여 ADC를 전압으로 변환

Converteix ADC a voltatge amb PIC 16F877A

Tionndaidh ADC gu Voltage le PIC 16F877A

Gerar frequência de 1KHz com PIC 16F877A

Exemplo1: Gere um sinal quadrado de 1KHz usando a interrupção do TEMPORIZADOR 0

Solução

Para 1KHz é necessário meio período de 500 us. De acordo com a equação de K overflow, usando um cristal de 4 MHz e um prescaler de 2

T = Tcm. Preescaler. (256 - Carregar TMR0)

500 us = (4/4000000).2.(256 - x)

x = 6 *

Código feito em CCS C Compiler

#include <16F877A.h>

#use delay(crystal = 4MHz)

#fuses XT, NOWDT

#use standard_io(B)

#int_TIMER0

void  RTCC_isr(void) {

  output_toggle(PIN_B0);

  set_timer0(0x1B);

}

void main(){

     

   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_2); 

   set_timer0(0x1B);

   enable_interrupts(INT_TIMER0); // habilita a chave timer0

   enable_interrupts(GLOBAL);   // habilita a chave geral

   while(TRUE) ; 

}

Query SQL em ordem crescente no google sheets

Objetivo: Selecionar usando SQL do google sheets apenas os dados ADM em ODEM CRESCENTE.

Resolução:

Inserindo os dados no excel e digitando ao lado com a tecla de comando CTL + E

Comando no google sheets:

=QUERY(F1:G14;"select F where G = 'ADM' order by F asc")

Resultado gerado

Palavras chave:

Query SQL in ascending order on google sheets

שאילתות SQL בסדר עולה ב-google sheets

Query SQL kanthi urutan munggah ing lembaran google

Запрос SQL в порядке возрастания на листах Google

Dotaz SQL ve vzestupném pořadí na google listech

Googleスプレッドシートで昇順でSQLをクエリする

Запыт SQL у парадку ўзрастання на табліцах Google

Consulteu SQL en ordre ascendent als fulls de Google

Inserir valor analógico com display 7segmentos

 Objetivo: Capturar o valor analógico lido e exibir na tela LCD + no display de 7 segmentos.

Código feito em CCS C Compiler

#include <16F877A.h>

#device adc = 8

#include <math.h>

#FUSES NOWDT, HS, NOPROTECT, NODEBUG

#FUSES NOBROWNOUT, NOLVP, NOCPD, NOWRT

#use delay(crystal = 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>

unsigned int8 valor, aux, c, d, u;

unsigned int8 vetor[] = {0b00111111, 0b00000110, // 0 a 9

   0b01011011, 0b01001111, 0b01100110, 0b01101101,

   0b01111101, 0b00000111, 0b01111111, 0b01100111 };

void main(){

   setup_adc_ports(AN0);

   setup_adc(ADC_CLOCK_INTERNAL);

   set_adc_channel(0);

   

   lcd_ini();

   while(TRUE){

      //TODO: User Code

      valor = read_adc();

      if(valor >= 99){

         valor = 99;

      }  

      aux = valor/100;     // extrai o primeiro piso das centenas

      c = (int)floor(aux); // converte para inteiro

      

      aux = ((valor/10)-(10*c)); //extrai o primeiro piso das dezenas

      d = (int)floor(aux);       //converte para inteiro

      

      aux = ((valor)-(100*c)-(10*d));  //extrai o primeiro piso das unidades

      u = (int)floor(aux);             //converte para inteiro

      

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

      delay_ms(20); 

      output_b(vetor[d]);

      output_c(vetor[u]);  

   }

}

Software: Proteus versão 7.9

Ligando todos os displays no PicsimLab

Objetivo: Ligar todos displays no Pic Genius com microcontrolador 16F877A

Código feito em CCS C Compiler

#include <16F877A.h>

#device adc=8

#use delay(clock=20MHz)

  

byte const display [ ] = {

   0b000000,  // display desligado

   0b000100, // display 1

   0b001000, // display 2

   0b010000, // display 3

   0b100000,  // display 4

   0b111100 //todos os display

};

int i = 0;

void main(){

   

   while(true){

      output_a(display[i]);

      delay_ms(500);

      i++;

   }

}

Simulador: PicsimLab

Comandos no SQL Server #4

--disable trigger trig_controla_ddl on database

CREATE TRIGGER trig_controla_dd1 ON DATABASE

FOR create_procedure, alter_procedure, drop_procedure, drop_table, alter_table AS

   IF Datepart(hh, Getdate()) <= 8

OR Datepart(hh, Getdate()) >= 17

   BEGIN

DECLARE @msg VARCHAR(200)

SELECT @msg = 'Complete o trabalho em horario comercial'

PRINT (@msg)

ROLLBACK

  END

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

      }

      

   }

}