MICROCONTROLADORES PIC
|
|
- João Henrique Valverde Arruda
- 6 Há anos
- Visualizações:
Transcrição
1 MICROCONTROLADORES PIC PRÁTICA MSc. Gustavo Souto de Sá e Souza
2 INTRODUÇÃO Para fins de avaliação e estudo prático, usaremos os microcontroladores da família PIC18, mais especificamente o PIC18F45K20. É importante lembrar que as informações contidas aqui podem variar para outras famílias PIC ou até mesmo para outros chips da mesma família.
3 LINGUAGEM C COMPILADOR XC8 Inicialização da variável variavel : Bit ou boolean: bit variavel; Valor inteiro: int variavel; Valor inteiro com sinal (positivo ou negativo): signed int variavel; Caractere: char variavel; String (conjunto de, digamos, 10 caracteres): char variavel[10]; Valor flutuante: float variavel;
4 LINGUAGEM C COMPILADOR XC8 Definição de variável: Decimal: variavel = 100; Binário: variavel = 0b ; Hexadecimal: variavel = 0x64; Caractere: variavel = d ;
5 LINGUAGEM C COMPILADOR XC8 Operações: Definição de variável: variavel = 255; Soma: variavel = 15 + b; Subtração: variavel = 15 - b; Multiplicação: variavel = 15 * b; Divisão: variavel = 15 / b; Rotação de N bits para esquerda: variavel = variavel << N; Rotação de N bits para a direita: variavel = variavel >> N;
6 LINGUAGEM C COMPILADOR XC8 Operações: Operação E: variavel = variavel & 55; Operação OU: variavel = variavel 55; Operação NÃO (inverte apenas 1 bit): variavel =!variavel; Incrementar em 1: variavel++; Decrementar em 1: variavel--;
7 LINGUAGEM C COMPILADOR XC8 Condições (retornam 1 se verdadeiro, 0 se falso): Verificar se é igual: (variavel == b); Verificar se é diferente: (variavel!= b); Verificar se é maior: (variavel > b); Verificar se é menor: (variavel < b); Verificar se é maior ou igual: (variavel >= b); Verificar se é menor ou igual: (variavel <= b); Condição E: (variavel <= b && variavel!= 0); Condição OU: (variavel <= b variavel!= 0);
8 LINGUAGEM C COMPILADOR XC8 Definições: Define _constante como 5: #define _constante 5 Define PINO_DO_LED como LATD1: #define PINO_DO_LED LATD1 Inclusões de bibliotecas: Inclui biblioteca do compilador: #include <stdlib.h> Inclui biblioteca da pasta local: #include lcd.h
9 LINGUAGEM C COMPILADOR XC8 Se: if: if (variavel == 10) { // executa se condição for verdadeira else { // executa se condição for falsa
10 LINGUAGEM C COMPILADOR XC8 Se: if: if (variavel == 10) { Condição // executa se condição for verdadeira else { // executa se condição for falsa
11 LINGUAGEM C COMPILADOR XC8 Loops: While: while (variavel!= 0) { // código em loop
12 LINGUAGEM C COMPILADOR XC8 Loops: While: while (variavel!= 0) { // código em loop Condição (executa enquanto for 1)
13 LINGUAGEM C COMPILADOR XC8 Loops: for: for (variavel = 1; variavel < 100; variavel++) { // código em loop
14 LINGUAGEM C COMPILADOR XC8 Valor inicial Loops: for: for (variavel = 1; variavel < 100; variavel++) { // código em loop
15 LINGUAGEM C COMPILADOR XC8 Condição (executa enquanto for 1) Loops: for: for (variavel = 1; variavel < 100; variavel++) { // código em loop
16 LINGUAGEM C COMPILADOR XC8 Incremento Loops: for: for (variavel = 1; variavel < 100; variavel++) { // código em loop
17 LINGUAGEM C COMPILADOR XC8 Loops: break: for (variavel = 1; variavel < 100; variavel++) { // código em loop if (variavel < 0) { break;
18 LINGUAGEM C COMPILADOR XC8 Loops: break: for (variavel = 1; variavel < 100; variavel++) { // código em loop if (variavel < 0) { break; Finaliza e sai do loop aqui
19 LINGUAGEM C COMPILADOR XC8 Funções: Principal: void main (void) { // Código principal do programa vem aqui
20 LINGUAGEM C COMPILADOR XC8 Funções: Interrupção: void interrupt int_func (void) { // Código da interrupção
21 LINGUAGEM C COMPILADOR XC8 Funções: Interrupção de baixa prioridade: void interrupt low_priority int_low_funcao (void) { // Código da interrupção de baixa prioridade
22 LINGUAGEM C COMPILADOR XC8 Funções: Secundárias: void LigaTimer (void) { TMR0ON = 1;
23 LINGUAGEM C COMPILADOR XC8 Funções: Secundárias com valores de entrada e saída: int SomaDez (int valor_de_entrada) { valor_de_entrada = valor_de_entrada + 10; return valor_de_entrada;
24 LINGUAGEM C COMPILADOR XC8 Chamando Funções: LigaTimer(); variavel = SomaDez(variavel);
25 LINGUAGEM C COMPILADOR XC8 Função de atraso por milissegundo: delay_ms(tempo_em_milissegundos);!!! Requer que a velocidade do oscilador seja definido antes, por meio da linha #define _XTAL_FREQ (para um oscilador de 1 MHz) Também requer a library xc.h incluída por meio da linha: #include <xc.h> Pode causar erro se o valor de entrada for muito grande, relativo à velocidade do oscilador.
26 LINGUAGEM C COMPILADOR XC8 Comentando o código: TRISA = 0; // A parte comentada vem depois de // duas barras /* Ou você pode comentar todo um trecho do código usando asterisco e barra */ ok++;
27 LINGUAGEM C COMPILADOR XC8 sprintf: imprime e manipula strings e caracteres. Requer que a biblioteca stdio.h seja incluída. #include <stdio.h> char linha1[16]; sprintf(linha1, Hello, world! ); // Grava o texto Hello, world! na variável linha1
28 LINGUAGEM C COMPILADOR XC8 char linha1[16]; contador = 15; sprintf(linha1, Contagem: %i, contador); // Grava o texto Contagem: 15 na variável linha1 // %i imprime um número inteiro
29 LINGUAGEM C COMPILADOR XC8 char linha1[16]; contador = 15; sprintf(linha1, Contagem: %3.2i, contador); // Grava o texto Contagem: na variável linha1 // %X.Yi imprime um número inteiro com X casas fixas // antes do separador decimal e Y fixas casas depois
30 LINGUAGEM C COMPILADOR XC8 char linha1[16]; temperatura = 37.52; sprintf(linha1, Graus: %2.2f, temperatura); // Grava o texto Graus: na variável linha1 // %f imprime um número de ponto flutuante
31 LINGUAGEM C COMPILADOR XC8 char linha1[16]; caractere_u = 0x55; sprintf(linha1, Letra U: %c, caractere_u); // Grava o texto Letra U: U na variável linha1 // %c imprime um caractere correspondente à tabela // ASCII
32 LINGUAGEM C COMPILADOR XC8 Definindo bits de Configuração: #pragma config LVP = OFF; // Desabilita o bit ICSP de fonte de alimentação simples (única)
33 LINGUAGEM C COMPILADOR XC8 Bits de Configuração essenciais: FOSC: // Frequência do oscilador Define a origem do oscilador principal do microcontrolador. Mais usados: #pragma config FOSC = INTIO; (oscilador interno) #pragma config FOSC = XT; (cristal externo) #pragma config FOSC = HS; (cristal externo rápido)
34 LINGUAGEM C COMPILADOR XC8 Bits de Configuração essenciais: WDTEN: Watchdog Timer enable. Habilita o reset automático do Watchdog Timer. Caso o comando ClrWdt() não seja executado num dado número de instruções, o microcontrolador será ressetado: #pragma config WDTEN = OFF; #pragma config WDTPS = 32768; No PIC18F4550: #pragma config WDT = OFF; // desabilita watchdog timer #pragma config WDTPS = 32768;
35 LINGUAGEM C COMPILADOR XC8 Bits de Configuração essenciais: MCLRE: Master Clear enable. Habilita ou desabilita o pino de reset no microcontrolador. #pragma config MCLRE = OFF;
36 LINGUAGEM C COMPILADOR XC8 Bits de Configuração essenciais: PBADEN: Habilita ou desabilita o conversor Analógico-Digital na porta B. Caso for utilizar interrupção na porta B ou usá-la como entrada/saída digital, este deve estar desabilitado. Por padrão é habilitado: #pragma config PBADEN = OFF;
37 LINGUAGEM C COMPILADOR XC8 Bits de Configuração não tão essenciais (podem ficar no valor padrão): PWRT: Aguarda um tempo depois de ligar para iniciar o programa. Habilitá-lo evita instabilidade no programa devido a oscilações na alimentação e oscilador: #pragma config PWRT = ON;
38 LINGUAGEM C COMPILADOR XC8 Bits de Configuração não tão essenciais (podem ficar no valor padrão): BOREN: Brown-out reset enable. Habilita o reset automático em caso de baixa tensão de alimentação: #pragma config BOREN = SBORDIS;
39 LINGUAGEM C COMPILADOR XC8 Registradores essenciais: OSCCON: Byte que define a frequência do oscilador interno do PIC18F45K20: OSCCON=0b ; // Frequência: 16 MHz OSCCON=0b ; // Frequência: 8 MHz OSCCON=0b ; // Frequência: 4 MHz OSCCON=0b ; // Frequência: 1 MHz (padrão)
40 LINGUAGEM C COMPILADOR XC8 Registradores essenciais: OSCCON: Byte que define a frequência do oscilador interno do PIC18F4550: Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0 IDLEN IRCF2 IRCF1 IRCF0 OSTS IOFS SCS1 SCS0 Bits de seleção da frequência OSCCON=0b ; OSCCON=0b ; OSCCON=0b ; OSCCON=0b ; OSCCON=0b ; OSCCON=0b ; // Frequência: 8 MHz // Frequência: 4 MHz // Frequência: 2 MHz // Frequência: 1 MHz (padrão) // Frequência: 500 khz // Frequência: 250 khz
41 LINGUAGEM C COMPILADOR XC8 Registradores importantes - interrupção: GBIE: bit que habilita a interrupção global: GBIE = 1; // Habilita interrupção PBIE: bit que habilita a interrupção de periféricos (timer2, adc): PBIE = 1; // Habilita interrupção de periféricos INTXIE: bit que habilita a interrupção externa X (X = 0, 1 ou 2): INT0IE = 1; // Habilita interrupção externa 0
42 LINGUAGEM C COMPILADOR XC8 Registradores importantes - interrupção: ADIF: bit que habilita a interrupção do conversor AD: ADIF = 1; // Habilita interrupção do ADC TXIE: bit que habilita a interrupção de transmissão da serial: TXIE = 1; // Habilita interrupção do TX da serial RCIE: bit que habilita a interrupção de recepção da serial: RCIE = 1; // Habilita interrupção do RX da serial
43 LINGUAGEM C COMPILADOR XC8 Registradores importantes - interrupção: TMRXIE: bit que habilita o timer X (X pode ser 0, 1, 2 ou 3): TMR3IE = 1; // Habilita interrupção do TMR3
44 LINGUAGEM C COMPILADOR XC8 Registradores importantes interrupção (flags): INTXIF: bit que sinaliza a flag da interrupção externa X (X=0, 1, 2): INT0IF = 0; // Limpa a flag do INT0 TMRXIF: bit que sinaliza a flag de interrupção do timer X (X=0, 1, 2, 3): TMR3IF = 0; // Limpa a flag do TMR3 ADIF: bit que sinaliza a flag de interrupção do ADC: ADIF = 0; // Limpa a flag do ADC
45 LINGUAGEM C COMPILADOR XC8 Registradores importantes ADC : ADCON0bits.GO: bit que inicia a conversão analógica: ADCON0bits.GO = 1; // Inicia a conversão AD ADCON0bits.DONE: flag que sinaliza o fim da conversão analógica: while (!ADCON0bits.DONE) { // Aguarda finalização da conversão AD
46 LINGUAGEM C COMPILADOR XC8 Registradores importantes ADC : ANSEL e ANSELH: bytes que selecionam quais canais analógicos ficam ativos: ANSEL = 0b ; // Habilita ADC nas portas // AN2 e AN4 ANSELH = 0b ; // Habilita ADC nas portas // AN8 até AN12
47 LINGUAGEM C COMPILADOR XC8 Registradores importantes ADC (PIC18F4550): ADCON0: Registrador de Controle do ADC Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0 X X CHS3 CHS2 CHS1 CHS0 GO/DONE\ ADON Bits de seleção do Canal Analógico Status da conversão Habilita ADC ADCON0bits.CHS = 0b0000 Seleção do Canal AN0 ADCON0bits.CHS = 0b0001 Seleção do Canal AN1 ADCON0bits.ADON = 1 Liga o ADC ADCON0bits.GO = 1 Inicia a conversão A/D
48 LINGUAGEM C COMPILADOR XC8 Registradores importantes ADC (PIC18F4550): ADCON1: Registrador de Controle do ADC Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0 X X VCFG1 VCFG0 PCFG3 PCFG2 PCFG1 PCFG0 Bits de configuração da tensão de referência ADCON1bits.VCFG = 0b00; Tensões de referência: Vss e Vdd
49 LINGUAGEM C COMPILADOR XC8 Registradores importantes ADC (PIC18F4550): ADCON2: Registrador de Controle do ADC Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0 ADFM - ACQT2 ACQT1 ACQT0 ADCS2 ADCS1 ADCS0 Formato do resultado Bits de seleção do Tempo de Aquisição de dados ADCON2bits.ADCS = 0b110 Clock do AD: Fosc/64 Bits de seleção do Clock de conversão ADCON2bits.ACQT = 0b010 Tempo de aquisição: 4 T AD ADCON2bits.ADFM = 0b1 Formato do resultado: justificado à direita
50 LINGUAGEM C COMPILADOR XC8 Registradores importantes ADC : ADRESL: byte que guarda os 8 bits menos significativos da conversão AD: ADRESH: byte que guarda os 8 bits mais significativos da conversão AD: valor_convertido = (ADRESH * 0x0100) + ADRESL; // guarda o valor da conversão AD na variável // de 16 bits valor_convertido
51 LINGUAGEM C COMPILADOR XC8 Registradores importantes PWM: CCPR2L: byte que define o duty cycle do PWM2: CCPR2L = 26; // Define PWM com duty-cycle de 10% CCPR2L = 255; // Define PWM com duty-cycle de 100% CCPR2L = 128; // Define PWM com duty-cycle de 50% CCPR2L = 77; // Define PWM com um duty-cycle de 30%
52
53 EXEMPLO PISCAR LED Inicio Configuração Inverte sinal do pino D0 Atrasa 100 ms
54 EXEMPLO PISCAR LED #define _XTAL_FREQ // Oscilador de 4 MHz #include <xc.h> #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF void main(void) { OSCCON = 0b ; TRISD = 0b ; // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado // Define velocidade do oscilador para 4MHz // Habilita porta D como saída while(1) { LATDbits.LATD0 =!LATDbits.LATD0; delay_ms(100); // Inicia loop infinito // Inverte sinal do pino D0 // Atraso de 100 ms Fim de Código
55 EXEMPLO PISCAR LED 1 SEGUNDO Inicio Configuração Inverte sinal do pino D0 Atrasa 100 vezes 10 ms
56 EXEMPLO PISCAR LED 1 SEGUNDO #define _XTAL_FREQ // Oscilador de 4 MHz #include <xc.h> #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado void SuperDelay(long counter) { // Função com valor de entrada counter counter = counter / 10; // Divide o valor informado por 10 for (long i = 1; i <= counter; i++) { // E usa o resultado como base delay_ms(10); // Para repetir uma contagem de 10 ms void main(void) { OSCCON = 0b ; TRISD = 0b ; // Define velocidade do oscilador para 4MHz // Habilita porta D como saída
57 EXEMPLO PISCAR LED 1 SEGUNDO while(1) { LATDbits.LATD0 =!LATDbits.LATD0; SuperDelay(1000); // Inicia loop infinito // Inverte sinal do pino D0 // Atraso de 1 s Fim de Código
58 EXEMPLO ROTACIONAR LED Inicio Configuração Rotaciona para a esquerda sim LED aceso na borda direita? não não LED aceso na borda esquerda? sim Rotaciona para a direita
59 EXEMPLO ROTACIONAR LED #define _XTAL_FREQ #include <xc.h> #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF // Oscilador de 4 MHz // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado void main(void) { TRISA = 0b ; // Habilita porta A como saída LATA = 1; // Liga o primeiro pino da porta A while(1) { // Inicia loop infinito while(lata!= 0b ) { LATA = (LATA >> 1 LATA << 7); // Rotacionando com estilo pra esquerda delay_ms(100); // Atraso de 100 ms while(lata!= 0b ) { LATA = (LATA << 1 LATA >> 7); // Rotacionando com estilo pra direita delay_ms(100); // Atraso de 100 ms Fim de Código
60 EXEMPLO ROTACIONAR LED - EXPLICAÇÃO Digamos que LATA = 0b LATA >> 1 retorna o seguinte valor: 0b , pois rotacionou o 1 para a direita e ele caiu fora dos 8 bits. O oitavo bit é preenchido com 0. LATA << 7 retorna o seguinte valor: 0b , pois rotacionou o 1 um total de sete bits para a esquerda e ele ficou no lugar do oitavo bit. Os 7 primeiros bits são preenchidos com 0. Fazendo a operação OU entre ambos, temos (LATA >> 1 LATA << 7) = 0b ; Continuemos com LATA = 0b LATA >> 1 retorna o seguinte valor: 0b , pois rotacionou o 1 para a direita e ele caiu no lugar do sétimo bit. O oitavo bit é preenchido com 0. LATA << 7 retorna o seguinte valor: 0b , pois rotacionou o 1 um total de sete bits para a esquerda e ele saiu do espaço dos bits. Os 7 primeiros bits são preenchidos com 0. Fazendo a operação OU entre ambos, temos (LATA >> 1 LATA << 7) = 0b ;
61 EXEMPLO LCD Inicio Configuração Adiciona 1 em contador Atualiza LCD com valor de contador
62 EXEMPLO LCD #define _XTAL_FREQ #include <xc.h> #define RS LATD2 // < Pinos do LCD #define EN LATD3 #define D4 LATD4 #define D5 LATD5 #define D6 LATD6 #define D7 LATD7 // Pinos do LCD > #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado #include "lcd.h" #include <stdio.h>
63 EXEMPLO LCD char linha1[16]; // Variável linha1 com 16 caracteres char linha2[16]; // Variável linha2 com 16 caracteres int contador = 0; // Variável contador com valor inicial 0 void main(void) { TRISD = 0; // Define porta D inteira como saída Lcd_Init(); // Inicia o LCD sprintf(linha1, "Hello world! "); // Grava texto em linha1 Lcd_Set_Cursor(1,1); // Posiciona o cursor na linha 1, caractere 1 Lcd_Write_String(linha1); // Escreve texto de linha1 no LCD while(1) { sprintf(linha2, "Contador: %i ",contador); // Grava texto em linha2 contador ++; // Incrementa contador Lcd_Set_Cursor(2,1); // Posiciona o cursor na linha 2, caractere 1 Lcd_Write_String(linha2); // Escreve texto de linha2 no LCD Fim de Código
64 EXEMPLO LCD + CONTADOR FLOAT Inicio Configuração Adiciona 1 em contador Atualiza LCD com valor de contador
65 EXEMPLO LCD + CONTADOR FLOAT #define _XTAL_FREQ #include <xc.h> #define RS LATD2 // < Pinos do LCD #define EN LATD3 #define D4 LATD4 #define D5 LATD5 #define D6 LATD6 #define D7 LATD7 // Pinos do LCD > #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado #include "lcd.h" #include <stdio.h>
66 EXEMPLO LCD + CONTADOR FLOAT char linha1[16]; // Variável linha1 com 16 caracteres char linha2[16]; // Variável linha2 com 16 caracteres float contador = 0.0; // Variável contador com valor inicial 0.0 void main(void) { TRISD = 0; // Define porta D inteira como saída Lcd_Init(); // Inicia o LCD sprintf(linha1, "Hello world! "); // Grava texto em linha1 Lcd_Set_Cursor(1,1); // Posiciona o cursor na linha 1, caractere 1 Lcd_Write_String(linha1); // Escreve texto de linha1 no LCD while(1) { sprintf(linha2, "Contador: %3.2f",contador); // Grava texto em linha2 contador = contador ; // Incrementa contador em 0.01 Lcd_Set_Cursor(2,1); // Posiciona o cursor na linha 2, caractere 1 Lcd_Write_String(linha2); // Escreve texto de linha2 no LCD Fim de Código
67 EXEMPLO INTERRUPÇÃO (INT0) Inicio Configuração Aguarda interrupção não Interrupção ativada? sim Inverte sinal do LED
68 EXEMPLO INTERRUPÇÃO (INT0) #define _XTAL_FREQ #include <xc.h> #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF #pragma config PBADEN = OFF // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado // Conversor AD da porta B desligado void setupint(void) { GIE = 1; // Habilita interrupção global INT0IE = 1; // Interrupção da INT 0 INT0F = 0; // Flag de interrupção da INT 0 INTEDG0 = 1; // Interrupção por borda crescente.
69 EXEMPLO INTERRUPÇÃO (INT0) void interrupt interrupcao(void) { if (INT0F) { LATAbits.LA0 =!LATAbits.LA0; INT0F = 0; void main(void) { TRISA = 0x00; TRISB = 0x01; setupint(); while(1) { // Função de interrupção // Caso a flag da INT0 esteja habilitada // Inverte o sinal no pino A0 // Desabilita a flag da INT0 // Porta A com todos pinos de saída // Somente pino B1 como entrada (INT0) // Função de inicializar Interrupção // Loop infinito // O código acima inverte o sinal no pino A0 a cada pressionar de um botão ligado à INT0 Fim de Código
70 EXEMPLO TEMPORIZADOR 0 Inicio Configuração (temporizador configurado para gerar interrupção a cada 50 ms) Aguarda interrupção não Interrupção ativada? sim Inverte sinal do LED
71 EXEMPLO TEMPORIZADOR 0 #define _XTAL_FREQ #include <xc.h> #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF // Oscilador a 4 MHz. O número de instruções por // segundo é de 1 milhão. O tempo para executar uma // instrução (e do tick do timer) é de 1 us. // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado void setupint(void) { GIE = 1; // Habilita interrupção global TMR0IE = 1; // interrupção do Timer 0 void setuptmr0() { T08BIT = 0; // Modo 16 bits T0CS = 0; // Source do clock PSA = 1; // Desabilita Prescaler TMR0H = 0x3C; // Começa a contar de TMR0L = 0xAF; // até (conta 50 mil vezes) TMR0ON = 1; // Liga o timer
72 EXEMPLO TEMPORIZADOR 0 void interrupt interrupcao(void) { // Função de interrupção if (TMR0IF) { // Caso a flag do temporizador esteja ativa LATAbits.LA0 =!LATAbits.LA0; // Inverte pino A0 TMR0H = 0x3C; // Começa a contar de TMR0L = 0xAF; // até (conta 50 mil vezes) TMR0IF = 0; // Flag do timer 0 em 0 void main(void) { OSCCON = 0b ; // Oscilador a 4 MHz (1 tick do timer = 1 us) setupint(); // Função de habilitar interrupção setuptmr0(); // Função de configurar timer 0 TRISA = 0x00; // Porta A como saída while(1) { // Loop infinito // O código acima inverte o sinal do pino A0 a cada us, via temporizador 0. Fim de Código
73 EXEMPLO TEMPORIZADOR 0 + PRESCALER Inicio Configuração (temporizador configurado para gerar interrupção a cada 1s) Aguarda interrupção não Interrupção ativada? sim Inverte sinal do LED
74 EXEMPLO TEMPORIZADOR 0 + PRESCALER #define _XTAL_FREQ #include <xc.h> #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF // Oscilador a 4 MHz. O número de instruções por // segundo é de 1 milhão. O tempo para executar uma // instrução (e do tick do timer) é de 1 us. // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado void setupint(void) { GIE = 1; // Habilita interrupção global TMR0IE = 1; // interrupção do Timer 0 void setuptmr0() { T08BIT = 0; T0CS = 0; PSA = 0; T0PS0 = 0; T0PS1 = 0; T0PS2 = 1; // Modo 16 bits // Source do clock // Habilita Prescaler // Multiplicador Prescaler // 32 vezes // 32 x us = 1 segundo
75 EXEMPLO TEMPORIZADOR 0 + PRESCALER TMR0H = 0x85; // Começa a contar de TMR0L = 0xED; // até (conta vezes) TMR0ON = 1; // Liga o timer void interrupt interrupcao(void) { // Função de interrupção if (TMR0IF) { // Caso a flag do temporizador esteja ativa LATAbits.LA0 =!LATAbits.LA0; // Inverte pino A0 TMR0H = 0x85; // Começa a contar de TMR0L = 0xED; // até (conta vezes) TMR0IF = 0; // Flag do timer 0 em 0 void main(void) { OSCCON = 0b ; // Oscilador a 4 MHz (1 tick do timer = 1 us) setupint(); // Função de habilitar interrupção setuptmr0(); // Função de configurar timer 0 TRISA = 0x00; // Porta A como saída while(1) { // Loop infinito
76 EXEMPLO TEMPORIZADOR 0 + PRESCALER // O código acima inverte o sinal do pino A0 a cada 1 s, via temporizador 0. Fim de Código
77 EXEMPLO TEMPORIZADOR 2 Inicio Configuração (temporizador configurado para gerar interrupção a cada 10 ms) Aguarda interrupção não Interrupção ativada? sim Inverte sinal do LED
78 EXEMPLO TEMPORIZADOR 2 #define _XTAL_FREQ #include <xc.h> #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF // Oscilador a 4 MHz. O número de instruções por // segundo é de 1 milhão. O tempo para executar uma // instrução (e do tick do timer) é de 1 us. // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado void setupint(void) { GIE = 1; // Habilita interrupção global PEIE = 1; // Timer 2 exige interrupção de periféricos habilitada TMR2IE = 1; // interrupção do Timer 2 void setuptmr2() { T2CKPS0 = 1; // Prescaler x 4 T2CKPS1 = 0; // T2OUTPS0 = 0; // Postscaler x 10 T2OUTPS1 = 1; // T2OUTPS2 = 0; // Conta 250 (PR2, abaixo) x 4 (prescaler) x 10 (postscaler) vezes T2OUTPS3 = 1; // totalizando vezes (~10 ms) por interrupção
79 EXEMPLO TEMPORIZADOR 2 TMR2 = 0x00; // Começa a contar de 0 PR2 = 249; // até 249 (conta 250 vezes + recarga automatica) TMR2ON = 1; // Liga o timer void interrupt interrupcao(void) { // Função de interrupção if (TMR2IF) { // Caso a flag do temporizador esteja ativa LATAbits.LA0 =!LATAbits.LA0; // Inverte pino A0 TMR2IF = 0; // Flag do timer 2 em 0 void main(void) { OSCCON = 0b ; // Oscilador a 4 MHz (1 tick do timer = 1 us) setupint(); // Função de habilitar interrupção setuptmr2(); // Função de configurar timer 0 TRISA = 0x00; // Porta A como saída while(1) { // Loop infinito // O código acima inverte o valor do pino A0 a cada 10 ms usando o Timer 2. Fim de Código
80 EXEMPLO CONVERSOR ANALÓGICO-DIGITAL Inicio Configuração Inicia leitura da tensão no pino A0 não Finalizou leitura? sim Grava valor da leitura nos bits da porta C e D
81 EXEMPLO CONVERSOR ANALÓGICO-DIGITAL #define _XTAL_FREQ // Oscilador de 4 MHz #include <xc.h> #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF void main(void) { OSCCON = 0b ; TRISD = 0b ; TRISC = 0b ; TRISA = 0x ; // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado // Define velocidade do oscilador para 4MHz // Habilita porta D como saída // Habilita porta C como saída // Habilita pino A0 como entrada ADCON2 = 0b ; // ADCON1 = 0b ; // Tensões de referência: Vss e Vdd ANSEL = 0x ; // Seleciona o canal AN0
82 EXEMPLO CONVERSOR ANALÓGICO-DIGITAL ADCON0bits.ADON = 1; // Habilita o conversor AD while(1) { ADCON0bits.GO = 1; while (!ADCON0bits.GODONE) { LATD = ADRESL; LATC = ADRESH; delay_ms(100); // Inicia loop infinito // Inicia a conversão // Aguarda fim da conversão // Transfere valor para porta D // Transfere valor para porta C // Atraso de 100 ms Fim de Código
83 EXEMPLO ADC + LCD Inicio Configuração Inicia leitura da tensão no pino A0 não Finalizou leitura? sim Calcula tensão no pino e exibe valor lido e tensão calculada no LCD
84 EXEMPLO ADC + LCD #define _XTAL_FREQ // Oscilador de 4 MHz #include <xc.h> #define RS LATD2 // < Pinos do LCD #define EN LATD3 #define D4 LATD4 #define D5 LATD5 #define D6 LATD6 #define D7 LATD7 // Pinos do LCD > #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado #include "lcd.h" #include <stdio.h> char linha1[16]; char linha2[16]; // Variável linha1 com 16 caracteres // Variável linha2 com 16 caracteres
85 EXEMPLO ADC + LCD int contador = 0; // Variável contador com valor inicial 0 float tensao = 0.0; // Variável tensao com valor inicial 0.0 void setupadc(void) { TRISA = 0b ; ADCON2bits.ADCS = 0b111; ADCON2bits.ACQT = 0b110; ADCON2bits.ADFM = 0b1; ADCON1bits.VCFG = 0b00; ANSEL = 0x ; // Habilita pino A0 como entrada // Tempo de aquisição: 4 Tad // Clock do AD: Fosc/64 // Formato: à direita // Tensões de referência: Vss e Vdd // Seleciona o canal AN0 ADCON0bits.ADON = 1; // Liga o AD void main(void) { OSCCON = 0b ; TRISD = 0b ; // Define velocidade do oscilador para 4MHz // Habilita porta D como saída
86 EXEMPLO ADC + LCD setupadc(); Lcd_Init(); // Inicia o LCD while(1) { // Inicia loop infinito ADCON0bits.GO = 1; // Inicia a conversão A/D while (!ADCON0bits.GODONE) { // Aguarda fim da conversão contador = (ADRESH * 0x100) + ADRESL; // Transfere valor para variável tensao = ((5 * contador) * ); // Calcula tensão real sprintf(linha1, "Conversor: %4i ", contador); // Grava texto em linha1 sprintf(linha2, "Tensao: %1.2f ",tensao); // Grava texto em linha2 Lcd_Set_Cursor(1,1); // Posiciona o cursor na linha 1, caractere 1 Lcd_Write_String(linha1); // Escreve texto de linha1 no LCD Lcd_Set_Cursor(2,1); // Posiciona o cursor na linha 2, caractere 1 Lcd_Write_String(linha2); // Escreve texto de linha2 no LCD Fim de Código
87 EXEMPLO ADC + LCD + DOIS CANAIS Inicio Configuração Lê tensão no pino A0 Atualiza LCD com valor lido Atualiza LCD com valor lido Lê tensão no pino A1
88 EXEMPLO ADC + LCD + DOIS CANAIS #define _XTAL_FREQ // Oscilador de 4 MHz #include <xc.h> #define RS LATD2 // < Pinos do LCD #define EN LATD3 #define D4 LATD4 #define D5 LATD5 #define D6 LATD6 #define D7 LATD7 // Pinos do LCD > #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado #include "lcd.h" #include <stdio.h> char linha1[16]; char linha2[16]; // Variável linha1 com 16 caracteres // Variável linha2 com 16 caracteres
89 EXEMPLO ADC + LCD + DOIS CANAIS int contador = 0; // Variável contador com valor inicial 0 float tensao1 = 0.0; // Variável tensao com valor inicial 0.0 float tensao2 = 0.0; // Variável tensao com valor inicial 0.0 void setupadc(void) { TRISA = 0b ; ADCON2bits.ADCS = 0b111; ADCON2bits.ACQT = 0b110; ADCON2bits.ADFM = 0b1; ADCON1bits.VCFG = 0b00; ANSEL = 0b ; // Habilita pinos A0 e A1 como entrada // Tempo de aquisição: 4 Tad // Clock do AD: Fosc/64 // Formato: à direita // Tensões de referência: Vss e Vdd // Habilita canais AN0 e AN1 como AD ADCON0bits.ADON = 1; // Liga o circuito AD void main(void) { OSCCON = 0b ; // Define velocidade do oscilador para 4MHz
90 EXEMPLO ADC + LCD + DOIS CANAIS TRISD = 0b ; // Habilita porta D como saída setupadc(); Lcd_Init(); // Inicia o LCD while(1) { // Inicia loop infinito ADCON0bits.CHS = 0b0000; // Seleciona canal AN0 ADCON0bits.GO = 1; // Inicia a conversão while (!ADCON0bits.GODONE) { // Aguarda fim da conversão contador = (ADRESH * 0x100) + ADRESL; // Transfere valor para variável tensao1 = ((5 * contador) * ); // Calcula tensão real ADCON0bits.CHS = 0b0001; ADCON0bits.GO = 1; while (!ADCON0bits.GODONE) { // Seleciona canal AN1 // Inicia a conversão // Aguarda fim da conversão
91 EXEMPLO ADC + LCD + DOIS CANAIS contador = (ADRESH * 0x100) + ADRESL; tensao2 = ((5 * contador) * ); // Transfere valor para variável // Calcula tensão real sprintf(linha1, "Tensao 1: %1.2f ",tensao1); // Grava texto em linha1 sprintf(linha2, "Tensao 2: %1.2f ",tensao2); // Grava texto em linha2 Lcd_Set_Cursor(1,1); // Posiciona o cursor na linha 1, caractere 1 Lcd_Write_String(linha1); // Escreve texto de linha1 no LCD Lcd_Set_Cursor(2,1); // Posiciona o cursor na linha 2, caractere 1 Lcd_Write_String(linha2); // Escreve texto de linha2 no LCD Fim de Código
92 EXEMPLO ADC + LCD + 4 CANAIS #define _XTAL_FREQ // Oscilador de 4 MHz #include <xc.h> #define RS LATD2 // < Pinos do LCD #define EN LATD3 #define D4 LATD4 #define D5 LATD5 #define D6 LATD6 #define D7 LATD7 // Pinos do LCD > #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado #include "lcd.h" #include <stdio.h> char linha1[16]; char linha2[16]; // Variável linha1 com 16 caracteres // Variável linha2 com 16 caracteres
93 EXEMPLO ADC + LCD + 4 CANAIS Inicio Configuração Atualiza LCD (chama rotina que lê tensão nos pinos A0 a A4 automaticamente)
94 EXEMPLO ADC + LCD + 4 CANAIS void setupadc(void) { TRISA = 0b ; ADCON2bits.ADCS = 0b1111; ADCON2bits.ACQT = 0b110; ADCON2bits.ADFM = 0b1; ADCON1bits.VCFG = 0b00; ANSEL = 0b ; // Habilita pinos A0 a A3 como entrada // Clock do AD: Fosc/64 // Tempo de aquisição automático: 16 Tad // Formato: à direita // Tensões de referência: Vss e Vdd // Habilita canais AN0 a AN3 como AD ADCON0bits.ADON = 1; // Liga o circuito AD float letensao(int canal_adc) { ADCON0bits.CHS = canal_adc; // Seleciona canal ADCON0bits.GO = 1; // Inicia a conversão while (!ADCON0bits.GODONE) { // Aguarda fim da conversão int contador = (ADRESH * 0x100) + ADRESL; // Transfere valor para variável
95 EXEMPLO ADC + LCD + 4 CANAIS float tensao = ((5 * contador) * ); return tensao; // Calcula tensão real void main(void) { OSCCON = 0b ; // Define velocidade do oscilador para 4MHz TRISD = 0b ; // Habilita porta D como saída setupadc(); Lcd_Init(); // Inicia o LCD while(1) { // Inicia loop infinito sprintf(linha1, "T0: %1.1f T1: %1.1f", letensao(0), letensao(1)); // Grava texto em linha1 sprintf(linha2, "T2: %1.1f T3: %1.1f", letensao(2), letensao(3)); // Grava texto em linha2 Lcd_Set_Cursor(1,1); // Posiciona o cursor na linha 1, caractere 1 Lcd_Write_String(linha1); // Escreve texto de linha1 no LCD Lcd_Set_Cursor(2,1); // Posiciona o cursor na linha 2, caractere 1 Lcd_Write_String(linha2); // Escreve texto de linha2 no LCD Fim de Código
96 EXEMPLO ADC + LCD + 8 CANAIS + INT Inicio Configuração (x = 0) Atualiza LCD com as variáveis tensão[0] a tensão[7]; Inicia leitura do pino ANx Leitura finalizada? Atualiza variável tensão[x] com o valor da tensão no pino Ax; Incrementa x não sim x é não maior que 7? sim x = 0
97 EXEMPLO ADC + LCD + 8 CANAIS + INT #define _XTAL_FREQ // Oscilador de 4 MHz #include <xc.h> #define RS LATD2 // < Pinos do LCD #define EN LATD3 #define D4 LATD4 #define D5 LATD5 #define D6 LATD6 #define D7 LATD7 // Pinos do LCD > #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado #include "lcd.h" #include <stdio.h> char linha1[16]; char linha2[16]; // Variável linha1 com 16 caracteres // Variável linha2 com 16 caracteres
98 EXEMPLO ADC + LCD + 8 CANAIS + INT int canal = 0; float tensao[8]; bit atualizado; // Variável que diz qual canal é lido atualmente // Vetor que guarda a tensão em cada um dos canais // Flag que indica se todos canais já foram lidos void setupadc(void) { TRISA = 0b ; TRISE = 0b ; ADCON2bits.ADCS = 0b1111; ADCON2bits.ACQT = 0b110; ADCON2bits.ADFM = 0b1; ADCON1bits.VCFG = 0b00; ANSEL = 0b ; ADCON0bits.ADON = 1; // Habilita pinos A0 a A3 e A5 como entrada // Habilita pinos E0 a E2 como entrada // São os pinos relativos a AN0 a AN7 // Clock do AD: Fosc/64 // Tempo de aquisição automático: 16 Tad // Formato: à direita // Tensões de referência: Vss e Vdd // Habilita canais AN0 a AN7 como AD // Liga o circuito AD
99 EXEMPLO ADC + LCD + 8 CANAIS + INT void setupinterrupcao(void) { GIE = 1; // Habilita interrupção global PEIE = 1; // ADC exige interrupção de periféricos habilitada ADIE = 1; // Liga interrupção pelo AD void interrupt adc_interrupt(void) { if (ADIF) { int contador = (ADRESH * 0x100) + ADRESL; // Transfere valor para variável tensao[canal] = ((5 * contador) * ); // Calcula tensão real if (canal == 7) { // Verificação para alternar canal = 0; // o canal lido a cada interrupcao ADCON0bits.CHS = canal; // Seleciona canal atualizado = 1; // Marca a flag caso ja leu os 4 canais else { canal++; // Atualiza o canal ADCON0bits.CHS = canal; // Seleciona canal ADCON0bits.GO = 1; ADIF = 0; // Inicia a conversão // Desmarca flag da interrupção ADC
100 EXEMPLO ADC + LCD + 8 CANAIS + INT void main(void) { OSCCON = 0b ; TRISD = 0b ; Lcd_Init(); setupadc(); setupinterrupcao(); atualizado = 0; ADCON0bits.CHS = canal; ADCON0bits.GO = 1; // Define velocidade do oscilador para 4MHz // Habilita porta D como saída // Inicia o LCD // Configura o ADC // Configura a interrupção // Marca a flag para atualizar os 8 canais // Seleciona canal // Inicia a conversão while(1) { // Inicia loop infinito sprintf(linha1, "1:%1.0f 2:%1.0f 3:%1.0f 4:%1.0f", tensao[0], tensao[1], tensao[2], tensao[3]); // Grava texto em linha1 sprintf(linha2, "5:%1.0f 6:%1.0f 7:%1.0f 8:%1.0f", tensao[4], tensao[5], tensao[6], tensao[7]); // Grava texto em linha2
101 EXEMPLO ADC + LCD + 8 CANAIS + INT Lcd_Set_Cursor(1,1); // Posiciona o cursor na linha 1, caractere 1 Lcd_Write_String(linha1); // Escreve texto de linha1 no LCD Lcd_Set_Cursor(2,1); // Posiciona o cursor na linha 2, caractere 1 Lcd_Write_String(linha2); // Escreve texto de linha2 no LCD atualizado = 0; // Marca a flag para atualizar os 4 canais ADCON0bits.GO = 1; // Inicia a conversão Fim de Código
102 EXEMPLO ADC + LCD + TIMER Inicio Configuração (configura timer para interromper a cada 10 ms) Atualiza LCD com o valor da variável tensão e contador não Interrupção do conversor AD? sim Grava tensão do pino AN0 na variável tensão ; Incrementa contador ; Interrupção do timer? sim Inicia leitura no conversor AD
103 EXEMPLO ADC + LCD + TIMER #define _XTAL_FREQ #define RS LATD2 // < Pinos do LCD #define EN LATD3 #define D4 LATD4 #define D5 LATD5 #define D6 LATD6 #define D7 LATD7 // Pinos do LCD > #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado #include <xc.h> #include "lcd.h" #include <stdio.h> char linha1[16]; // Variável linha1 com 16 caracteres char linha2[16]; // Variável linha2 com 16 caracteres int contador = 0; // Variável contador com valor inicial 0
104 EXEMPLO ADC + LCD + TIMER float tensao = 0.0; // Variável que guarda a tensão lida no conversor AD long contagem = 10000; // Variável que define quantos us serão contados a cada conversão void interrupt interrupcao() { if (ADIF) { int leitura_adc = (ADRESH * 0x100) + ADRESL; tensao = ((5 * leitura_adc) * ); contador++; ADIF = 0; if (TMR3IF) { // Transfere valor para variável // Calcula tensão real // Incrementa contador // Desmarca flag da interrupção ADC TMR3H = (0xFFFF - contagem) >> 8; // Cálculo do valor inicial do TMR3 TMR3L = ((0xFFFF - contagem) & 0xFF); // Cálculo do valor inicial do TMR3 LATDbits.LD0 =!LATDbits.LD0; // Inverte sinal no pino D0 TMR3IF = 0; // Limpa a Flag da interrupção ADCON0bits.GO = 1; // Inicia conversao AD
105 EXEMPLO ADC + LCD + TIMER void setuptmr3() { T3CKPS0 = 0; T3CKPS1 = 0; TMR3CS = 0; // Prescaler // Prescaler // Clock origina do clock interno TMR3H = (0xFFFF - contagem) >> 8; TMR3L = ((0xFFFF - contagem) & 0xFF); // Cálculo do valor inicial do TMR3 // Cálculo do valor inicial do TMR3 TMR3ON = 1; // Liga o timer void setupadc(void) { TRISA = 0b ; ADCON2bits.ADCS = 0b1111; ADCON2bits.ACQT = 0b110; ADCON2bits.ADFM = 0b1; ADCON1bits.VCFG = 0b00; // Habilita pino A0entrada // Clock do AD: Fosc/64 // Tempo de aquisição automático: 16 Tad // Formato: à direita // Tensões de referência: Vss e Vdd
106 EXEMPLO ADC + LCD + TIMER ANSEL = 0b ; ADCON0bits.ADON = 1; // Habilita canal AN0 // Liga o circuito AD void setupint(void) { GIE = 1; // Habilita interrupção global PEIE = 1; // Habilita interrupção de periféricos TMR3IE = 1; // Interrupção do timer 3 ADIE = 1; // Habilita interrupção do ADC void main(void) { OSCCON = 0b ; TRISA = 1; TRISD = 0; setupadc(); setupint(); // Oscilador interno a 4 MHz // A0 como entrada // Define porta D inteira como saída // Configuração do ADC // Configuração da Interrupção
107 EXEMPLO ADC + LCD + TIMER setuptmr3(); // Configuração do Timer 3 Lcd_Init(); // Inicia o LCD while(1) { sprintf(linha1, "N: %i", contador); // Grava texto em linha1 Lcd_Set_Cursor(1,1); // Posiciona o cursor na linha 1, caractere 1 Lcd_Write_String(linha1); // Escreve texto de linha1 no LCD sprintf(linha2, "Tensao: %3.2f", tensao); // Grava texto em linha2 Lcd_Set_Cursor(2,1); // Posiciona o cursor na linha 2, caractere 1 Lcd_Write_String(linha2); // Escreve texto de linha2 no LCD Fim de Código
108 EXEMPLO PWM Inicio Configuração (configura temporizador e PWM)... É, não faz nada.
109 EXEMPLO PWM #define _XTAL_FREQ #pragma config FOSC = INTIO #pragma config WDT = OFF #pragma config MCLRE = OFF #pragma config CCP2MX = PORTC // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado // Saída do PWM na porta C #include <xc.h> void setuptmr2() { TMR2 = 0x00; // Começa a contar de 0 PR2 = 249; // até 250 (conta 250 vezes + recarga automatica) void setuppwm (void) { TRISCbits.RC1 = 1; // "desliga" bit de saída setuptmr2(); // Configura timer 2 CCP2CONbits.CCP2M = 0b1100; // Modo PWM ativo CCPR2L = 128; // Configura % do PWM (0-255), portanto 128 = 50%
110 EXEMPLO PWM TMR2IF = 0; TMR2ON = 1; TRISCbits.RC1 = 0; // Limpa flag do TMR2 // Dispara o timer // "liga" bit de saída void main(void) { OSCCON = 0b ; setuppwm(); // Oscilador interno a 4 MHz while(1) { // Gera um sinal PWM na saída do pino RC1 Fim de Código
111 EXEMPLO PWM + ADC Inicio Configuração Inicia conversão AD no pino AN0 não Interrupção do conversor AD? sim Atualiza valor do duty cycle do PWM baseado no valor de tensão lido no pino AN0
112 EXEMPLO PWM + ADC #define _XTAL_FREQ #pragma config FOSC = INTIO67 #pragma config WDTEN = OFF #pragma config MCLRE = OFF #pragma config CCP2MX = PORTC // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado // Saída do PWM na porta C #include <xc.h> long contagem = 0; // Variável auxiliar void interrupt interrupcao() { if (ADIF) { contagem = (ADRESH * 0x100) + ADRESL; // Transfere a leitura do AD para a contagem = contagem >> 2; // variavel 'contagem' CCPR2L = contagem; // % é igual aos 8 MSB do ADC ADIF = 0; // Desmarca flag da interrupção ADC if (TMR2IF) { // Caso a flag do temporizador esteja ativa, TMR2IF = 0; // desmarca a mesma
113 EXEMPLO PWM + ADC void setuptmr2() { TMR2 = 0x00; // Começa a contar de 0 PR2 = 249; // até 250 (conta 250 vezes + recarga automatica) void setupadc(void) { TRISA = 0b ; ADCON2bits.ADCS = 0b1111; ADCON2bits.ACQT = 0b110; ADCON2bits.ADFM = 0b1; ADCON1bits.VCFG = 0b00; ANSEL = 0b ; // Habilita pino A0entrada // Clock do AD: Fosc/64 // Tempo de aquisição automático: 16 Tad // Formato: à direita // Tensões de referência: Vss e Vdd // Habilita canal AN0
114 EXEMPLO PWM + ADC ADCON0bits.ADON = 1; // Liga o circuito AD void setupint(void) { GIE = 1; // Habilita interrupção global PEIE = 1; // Habilita interrupção de periféricos TMR2IE = 1; // Interrupção do timer 1 ADIE = 1; // Habilita interrupção do ADC void setuppwm (void) { TRISCbits.RC1 = 1; // "desliga" bit de saída setuptmr2(); // Configura timer 2 CCP2CONbits.CCP2M = 0b1100; // Modo PWM ativo CCPR2L = 128; // Configura % do PWM (0-255) TMR2IF = 0; // Limpa flag do TMR2 TMR2ON = 1; // Dispara o timer
115 EXEMPLO PWM + ADC TRISCbits.RC1 = 0; // "liga" bit de saída void main(void) { OSCCON = 0b ; TRISD = 0; LATD = 1; setupadc(); setupint(); setuppwm(); // Oscilador interno a 4 MHz // Define porta D inteira como saída // Acende o primeiro LED da porta D // Configuração do ADC // Configuração da Interrupção // Configuração do PWM while(1) { ADCON0bits.GO = 1; // Lê ADC, para recarregar valor no PWM while (ADCON0bits.NOT_DONE) { // Gera um sinal PWM na saída com ciclo variando de acordo com a tensão no pino A0 Fim de Código
116 EXEMPLO - SERIAL Inicio Configuração; Envia texto pra porta serial; Aguarda interrupção não Interrupção da recepção serial? sim Envia texto para a porta serial com caractere digitado;
117 EXEMPLO - SERIAL #include <stdio.h> #include <string.h> #include <stdlib.h> #define _XTAL_FREQ //para usar funçoes de string deve se adicionar este header // Oscilador interno de 4 MHz #include <xc.h> #pragma config FOSC = INTIO67 #pragma config WDTEN = OFF #pragma config MCLRE = OFF // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado char caracter; bit flag_interrupcao = 0; void interrupt RS232(void) { caracter = RCREG; flag_interrupcao = 1; RCIF = 0; //vetor de interrupção // Lê caractere recebido do registrador // Habilita variável indicando que houve recepção // Limpa flag de interrupção de recepção
118 SERIAL void inicializa_rs232(long velocidade,int modo) { RCSTA = 0X90; // Habilita porta serial, recepção de // 8 bits em modo continuo, assíncrono. int valor; if (modo == 1) { // modo = 1, modo alta velocidade TXSTA = 0X24; // modo assíncrono, transmissão 8 bits. valor =(int)(((_xtal_freq/velocidade)-16)/16); // Cálculo do baud rate else { //modo = 0,modo baixa velocidade TXSTA = 0X20; //modo assincrono,trasmissao 8 bits. valor =(int)(((_xtal_freq/velocidade)-64)/64); //calculo do valor do gerador de baud rate SPBRG = valor; RCIE = 1; //habilita interrupção de recepção TXIE = 0; //deixa interrupção de transmissão desligado //(pois corre se o risco de ter uma interrupção escrita e leitura ao mesmo tempo)
119 SERIAL void escreve(char valor) { TXIF = 0; TXREG = valor; while(txif ==0); void imprime(const char frase[]) { char indice = 0; char tamanho = strlen(frase); while(indice < tamanho ) { escreve(frase[indice]); indice++; // limpa flag que sinaliza envio completo. // Envia caractere à porta serial // espera caractere ser enviado // índice da cadeia de caracteres // tamanho total da cadeia a ser impressa // verifica se todos foram impressos // Chama rotina que escreve o caractere // incrementa índice
120 SERIAL void main(void) { OSCCON = 0b ; // Oscilador interno a 4 MHz TRISB = 0X02; // configura portb B1 (pino RX) como entrada PORTB = 0; // limpar as portas que estão configuradas como saidas inicializa_rs232(9600,1); // modo de alta velocidade GIE = 1; // GIE: Global Interrupt Enable bit PEIE = 1; // habilita interrupção de periféricos do pic imprime("usando a serial MPLAB X XC8 \n\r"); imprime( Digite algo: \n\r"); while (1) { if(flag_interrupcao == 1) { //tem dados para ler imprime(" \n\rcaractere digitado :"); escreve(caracter); flag_interrupcao = 0; //loop infinito Fim de Código
121 EXEMPLO SERIAL + LCD Inicio Configuração; Envia texto pra porta serial e LCD; Aguarda interrupção Organiza posição do caractere na segunda linha do LCD não Interrupção da recepção serial? sim Envia texto para a porta serial e LCD com caractere digitado;
122 EXEMPLO SERIAL + LCD #define _XTAL_FREQ // Oscilador interno de 4 MHz #include <xc.h> #define RS LATD2 // < Pinos do LCD #define EN LATD3 #define D4 LATD4 #define D5 LATD5 #define D6 LATD6 #define D7 LATD7 // Pinos do LCD > #include "lcd.h" #include <stdio.h> #include <string.h> #include <stdlib.h> #pragma config FOSC = INTIO67 #pragma config WDTEN = OFF #pragma config MCLRE = OFF //para usar funçoes de string deve se adicionar este header // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado
123 EXEMPLO SERIAL + LCD char caracter; char linha1[16]; char linha2[16]; bit flag_interrupcao = 0; void interrupt RS232(void) { caracter = RCREG; flag_interrupcao = 1; RCIF = 0; // Variável linha1 com 16 caracteres // Variável linha2 com 16 caracteres //vetor de interrupção // Lê caractere recebido do registrador // Habilita variável indicando que houve recepção // Limpa flag de interrupção de recepção void inicializa_rs232(long velocidade,int modo) { RCSTA = 0X90; int valor; if (modo == 1) { // Habilita porta serial, recepção de // 8 bits em modo continuo, assíncrono. // modo = 1, modo alta velocidade
124 EXEMPLO SERIAL + LCD TXSTA = 0X24; // modo assíncrono, transmissão 8 bits. valor =(int)(((_xtal_freq/velocidade)-16)/16); // Cálculo do baud rate else { //modo = 0,modo baixa velocidade TXSTA = 0X20; //modo assincrono,trasmissao 8 bits. valor =(int)(((_xtal_freq/velocidade)-64)/64); //calculo do valor do gerador de baud rate SPBRG = valor; RCIE = 1; //habilita interrupção de recepção TXIE = 0; //deixa interrupção de transmissão desligado //(pois corre se o risco de ter uma interrupção escrita e leitura ao mesmo tempo) void escreve(char valor) { TXIF = 0; TXREG = valor; while(txif ==0); // limpa flag que sinaliza envio completo. // Envia caractere à porta serial // espera caractere ser enviado
125 EXEMPLO SERIAL + LCD void imprime(const char frase[]) { char indice = 0; char tamanho = strlen(frase); while(indice < tamanho ) { escreve(frase[indice]); indice++; // índice da cadeia de caracteres // tamanho total da cadeia a ser impressa // verifica se todos foram impressos // Chama rotina que escreve o caractere // incrementa índice void main(void) { OSCCON = 0b ; // Oscilador interno a 4 MHz TRISB = 0X02; // configura portb B1 (pino RX) como entrada PORTB = 0; // limpar as portas que estão configuradas como saidas inicializa_rs232(9600,1); // modo de alta velocidade GIE = 1; // GIE: Global Interrupt Enable bit PEIE = 1; // habilita interrupção de perifericos do pic
126 EXEMPLO SERIAL + LCD TRISD = 0x00; Lcd_Init(); int posicao = 1; // configura portd como saída // Inicia o LCD // Variável que guarda posição do caractere no LCD imprime("usando a serial MPLAB X XC8 \n\r"); imprime("digite algo: \n\r"); // Envia texto para a serial Lcd_Set_Cursor(1,1); // Posiciona o cursor na linha 1, caractere 1 sprintf(linha1, "Digite algo:"); // Grava texto em linha1 Lcd_Write_String(linha1); // Escreve texto de linha1 no LCD while (1) { if(flag_interrupcao == 1) { imprime(" \n\rcaractere digitado: "); escreve(caracter); // Tem dados para ler Lcd_Set_Cursor(1,1); // Posiciona o cursor na linha 1, caractere 1 sprintf(linha1, "Ultima tecla: %c", caracter); // Grava texto em linha1 Lcd_Write_String(linha1); // Escreve texto de linha1 no LCD
127 EXEMPLO SERIAL + LCD Lcd_Set_Cursor(2,posicao); // Posiciona o cursor na linha 2, ultima posicao sprintf(linha1, "%c", caracter); // Grava texto em linha2 Lcd_Write_String(linha1); // Escreve texto de linha2 no LCD if (posicao == 16) { posicao = 1; else { posicao++; flag_interrupcao = 0; //loop infinito Fim de Código
128 EXEMPLO SERIAL + ADC Inicio Configuração; Envia texto pra porta serial; Inicia leitura da tensão no pino AN0 não Finalizou a leitura? sim Envia texto para a porta serial com tensão lida;
129 EXEMPLO SERIAL + ADC #define _XTAL_FREQ #include <xc.h> #include <stdio.h> #include <string.h> #include <stdlib.h> #pragma config FOSC = INTIO67 #pragma config WDTEN = OFF #pragma config MCLRE = OFF // Oscilador interno de 4 MHz //para usar funçoes de string deve se adicionar este header // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado char caracter; bit flag_interrupcao = 0; char linha[22]; int contador; float tensao; void inicializa_rs232(long velocidade,int modo) { RCSTA = 0X90; // Habilita porta serial, recepção de
130 EXEMPLO SERIAL + ADC // 8 bits em modo continuo, assíncrono. int valor; if (modo == 1) { // modo = 1, modo alta velocidade TXSTA = 0X24; // modo assíncrono, transmissão 8 bits. valor =(int)(((_xtal_freq/velocidade)-16)/16); // Cálculo do baud rate else { //modo = 0,modo baixa velocidade TXSTA = 0X20; //modo assincrono,trasmissao 8 bits. valor =(int)(((_xtal_freq/velocidade)-64)/64); //calculo do valor do gerador de baud rate SPBRG = valor; RCIE = 1; //habilita interrupção de recepção TXIE = 0; //deixa interrupção de transmissão desligado //(pois corre se o risco de ter uma interrupção escrita e leitura ao mesmo tempo) void escreve(char valor) { TXIF = 0; // limpa flag que sinaliza envio completo.
131 EXEMPLO SERIAL + ADC TXREG = valor; while(txif ==0); // Envia caractere à porta serial // espera caractere ser enviado void imprime(const char frase[]) { char indice = 0; char tamanho = strlen(frase); while(indice < tamanho ) { escreve(frase[indice]); indice++; // índice da cadeia de caracteres // tamanho total da cadeia a ser impressa // verifica se todos foram impressos // Chama rotina que escreve o caractere // incrementa índice void setupadc(void) { TRISA = 0b ; ADCON2bits.ADCS = 0b111; ADCON2bits.ACQT = 0b110; // Habilita pino A0 como entrada // Tempo de aquisição: 4 Tad // Clock do AD: Fosc/64
132 EXEMPLO SERIAL + ADC ADCON2bits.ADFM = 0b1; ADCON1bits.VCFG = 0b00; ANSEL = 0x ; ADCON0bits.ADON = 1; // Formato: à direita // Tensões de referência: Vss e Vdd // Seleciona o canal AN0 // Liga o AD void SuperDelay(long counter) { // Função com valor de entrada counter counter = counter / 10; // Divide o valor informado por 10 for (long i = 1; i <= counter; i++) { // E usa o resultado como base delay_ms(10); // Para repetir uma contagem de 10 ms void main(void) { OSCCON = 0b ; // Oscilador interno a 4 MHz
133 EXEMPLO SERIAL + ADC TRISB = 0X02; // configura portb B1 (pino RX) como entrada PORTB = 0; // limpar as portas que estão configuradas como saidas inicializa_rs232(9600,1); // modo de alta velocidade setupadc(); // Configuração do AD sprintf(linha, "Tensão lida: 0.000"); imprime(linha); // Grava texto em linha1 while (1) { ADCON0bits.GO = 1; // Inicia leitura do ADC while(adcon0bits.not_done) { // Aguarda leitura do ADC contador = (ADRESH * 0x100) + ADRESL; // Transfere valor para variável tensao = ((5 * contador) * ); // Calcula tensão real sprintf(linha, "\b\b\b\b\b%1.3f", tensao); // Grava texto em linha1 imprime(linha); SuperDelay(1000); //loop infinito Fim de Código
134 PROGRAMAS COM BUGS #1 ROTAÇÃO DE LEDS Comportamento esperado: Os LEDs rotacionem no estilo bate-e-volta. Sintoma: Ao iniciar o programa, os LEDs começam a rotacionar corretamente, mas depois de várias rotações, ele volta a rotacionar do primeiro LED.
135 PROGRAMAS COM BUGS #1 ROTAÇÃO DE LEDS #define _XTAL_FREQ #include <xc.h> #pragma config FOSC = INTIO67 #pragma config WDTEN = ON #pragma config MCLRE = OFF // Oscilador de 1 MHz // Oscilador interno // Watchdog Timer ligado // Master Clear desabilitado void main(void) { TRISA = 0b ; // Habilita porta A como saída LATA = 1; // Liga o primeiro pino da porta A while(1) { // Inicia loop infinito while(lata!= 0b ) { LATA = (LATA >> 1 LATA << 7); // Rotacionando com estilo pra esquerda delay_ms(100); // Atraso de 100 ms while(lata!= 0b ) { LATA = (LATA << 1 LATA >> 7); // Rotacionando com estilo pra direita delay_ms(100); // Atraso de 100 ms Fim de Código
136 PROGRAMAS COM BUGS #2 ROTAÇÃO DE LEDS Comportamento esperado: Os LEDs rotacionem no estilo bate-e-volta. Sintoma: Ao iniciar o programa, nada acontece.
137 PROGRAMAS COM BUGS #2 ROTAÇÃO DE LEDS #define _XTAL_FREQ #include <xc.h> #pragma config FOSC = INTIO67 #pragma config WDTEN = ON #pragma config MCLRE = OFF // Oscilador de 1 MHz // Oscilador interno // Watchdog Timer ligado // Master Clear desabilitado void main(void) { TRISA = 0b ; // Habilita porta A como saída LATA = 1; // Liga o primeiro pino da porta A while(1) { // Inicia loop infinito while(lata!= 0b ) { LATA = (LATA >> 1 LATA << 7); // Rotacionando com estilo pra esquerda delay_ms(100); // Atraso de 100 ms while(lata!= 0b ) { LATA = (LATA << 1 LATA >> 7); // Rotacionando com estilo pra direita delay_ms(100); // Atraso de 100 ms Fim de Código
138 PROGRAMAS COM BUGS #3 ROTAÇÃO DE LEDS Comportamento esperado: Os LEDs rotacionem no estilo bate-e-volta. Sintoma: Ao iniciar o programa, nada acontece. A tensão nos pinos de saída dos LEDs não mostram nenhum valor bem definido.
139 PROGRAMAS COM BUGS #3 ROTAÇÃO DE LEDS #define _XTAL_FREQ #include <xc.h> #pragma config FOSC = INTIO67 #pragma config WDTEN = OFF #pragma config MCLRE = OFF // Oscilador de 1 MHz // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado void main(void) { LATA = 1; // Liga o primeiro pino da porta A while(1) { // Inicia loop infinito while(lata!= 0b ) { LATA = (LATA >> 1 LATA << 7); // Rotacionando com estilo pra esquerda delay_ms(100); // Atraso de 100 ms while(lata!= 0b ) { LATA = (LATA << 1 LATA >> 7); // Rotacionando com estilo pra direita delay_ms(100); // Atraso de 100 ms Fim de Código
140 PROGRAMAS COM BUGS #4 PISCAR LED Comportamento esperado: Piscar um LED na porta D0 a cada 100 ms. Sintoma: O LED pisca, mas o osciloscópio mostra que ele pisca a cada 25 ms.
141 PROGRAMAS COM BUGS #4 PISCAR LED #define _XTAL_FREQ // Oscilador de 1 MHz #include <xc.h> #pragma config FOSC = INTIO67 #pragma config WDTEN = OFF #pragma config MCLRE = OFF void main(void) { OSCCON = 0b ; TRISD = 0b ; // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado // Define frequência do oscilador para 4MHz // Habilita porta D como saída while(1) { LATDbits.LATD0 =!LATDbits.LATD0; delay_ms(100); // Inicia loop infinito // Inverte sinal do pino D0 // Atraso de 100 ms Fim de Código
142 PROGRAMAS COM BUGS #5 PISCAR LED Comportamento esperado: Piscar um LED na porta D0 a cada 100 ms. Sintoma: O LED fica ligado o tempo todo.
143 PROGRAMAS COM BUGS #5 PISCAR LED #define _XTAL_FREQ // Oscilador de 4 MHz #include <xc.h> #pragma config FOSC = INTIO67 #pragma config WDTEN = OFF #pragma config MCLRE = OFF void main(void) { OSCCON = 0x ; TRISD = 0b ; // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado // Define frequência do oscilador para 4MHz // Habilita porta D como saída while(1) { LATDbits.LATD0 =!LATDbits.LATD0; delay_ms(100); // Inicia loop infinito // Inverte sinal do pino D0 // Atraso de 100 ms Fim de Código
144 PROGRAMAS COM BUGS #6 LCD Comportamento esperado: Escrever Hello, world! e um contador na tela do LCD. A cada contagem, o LED da porta D0 deve piscar. Sintoma: Ao iniciar o programa, o LCD não mostra nada escrito. Apesar disso, o LED pisca.
145 PROGRAMAS COM BUGS #6 LCD #define _XTAL_FREQ #include <xc.h> #define RS LATD2 // < Pinos do LCD ligados na porta D #define EN LATD3 #define D4 LATD4 #define D5 LATD5 #define D6 LATD6 #define D7 LATD7 // Pinos do LCD ligados na porta D > #pragma config FOSC = INTIO67 #pragma config WDTEN = OFF #pragma config MCLRE = OFF // Oscilador interno // Watchdog Timer desligado // Master Clear desabilitado #include "lcd.h" #include <stdio.h>
146 PROGRAMAS COM BUGS #6 LCD char linha1[16]; // Variável linha1 com 16 caracteres char linha2[16]; // Variável linha2 com 16 caracteres int contador = 0; // Variável contador com valor inicial 0 void main(void) { Lcd_Init(); // Inicia o LCD, ligado na porta D TRISD = 0; // Define porta D inteira como saída sprintf(linha1, "Hello world! "); // Grava texto em linha1 Lcd_Set_Cursor(1,1); // Posiciona o cursor na linha 1, caractere 1 Lcd_Write_String(linha1); // Escreve texto de linha1 no LCD while(1) { sprintf(linha2, "Contador: %i ",contador); // Grava texto em linha2 contador ++; // Incrementa contador Lcd_Set_Cursor(2,1); // Posiciona o cursor na linha 2, caractere 1 Lcd_Write_String(linha2); // Escreve texto de linha2 no LCD LATDbits.LATD0 =!LATDbits.LATD0; // Pisca LED na porta D0 Fim de Código
147 PROGRAMAS COM BUGS #7 INTERRUPÇÃO Comportamento esperado: O LED deve acender ou apagar a cada pressionar do botão ligado à porta B0 (ou INT0) Sintoma: Nada acontece ao pressionar o botão.
Interrupções e timers
Prática 3: 3.1 Introdução e objetivos Interrupções e timers Na prática anterior foi visto que a função main fica continuamente monitorando o teclado avaliando se alguma tecla foi pressionada através da
Leia maisSistemas Digitais e Microcontrolados
UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ DEPARTAMENTO ACADÊMICO DE ELETROTÉCNICA CURSO DE ENGENHARIA INDUSTRIAL ELÉTRICA TECNOLOGIA EM AUTOMAÇÃO INDUSTRIAL Sistemas Digitais e Microcontrolados Conversor
Leia maisUm resumo do Microcontrolador PIC18xx
Um resumo do Microcontrolador PIC18xx Autor: Pedro Inácio Revisão: Rui Antunes Dezembro/2007 1. Introdução 1.1 PIC-Programmable Interrupt Controller O PIC é um microcontrolador fabricado exclusivamente
Leia maisCurso básico de linguagem C para microcontroladores PIC. Índice
Índice Linguagem C... 3 Programação de Microcontroladores em linguagem C... 3 Princípio de programação - Álgebra Booleana... 5 - Operações... 5 - Representação Gráfica das Portas Lógicas... 5 Introdução
Leia maisLista de Exercícios 1
Conceitos envolvidos: a) Memória de Dados (interna e externa) b) Memória de Programa (interna e externa) c) Operações aritméticas e lógicas d) Portas e) Endereçamento a Bit f) Contadores e Temporizadores
Leia maisAplicações: Conversão de Códigos e Motor de Passo. Prof. Adilson Gonzaga
Aplicações: Conversão de Códigos e Motor de Passo Aplicação 1 Conversão de Código ASCII para Hexadecimal Alguns periféricos, tais como Teclados Alfa-numéricos, Monitores de Vídeo, Displays de Cristal Líquido,
Leia maisTECLADO MATRICIAL. Universidade Tecnológica Federal do Paraná - UTFPR Sistemas Microcontrolados Monitor da disciplina: Luís Paulo Custódio
TECLADO MATRICIAL Universidade Tecnológica Federal do Paraná - UTFPR Sistemas Microcontrolados Monitor da disciplina: Luís Paulo Custódio Introdução Teclados são geralmente utilizados em aplicações na
Leia maisSistemas Microcontrolados. Período Aula 6. 1 Saulo O. D. Luiz
Sistemas Microcontrolados Período 2009.2 Aula 6 1 Saulo O. D. Luiz Roteiro Entrada e saída Portas 2 Saulo O. D. Luiz Porta Porta um registrador conectado aos pinos do microcontrolador 3 Saulo O. D. Luiz
Leia maisConhecendo o PIC16F877 Microcontrolador de 8 bits da Microchip Co.
Programação Daniel Corteletti Aula 2 Página 1/6 Conhecendo o PIC16F877 Microcontrolador de 8 bits da Microchip Co. O microcontrolador PIC16F877 pode ser encontrado em diversos encapsulamentos: PDIP, QFP,
Leia maisHardware Parte I. Fábio Rodrigues de la Rocha
Hardware Parte I Fábio Rodrigues de la Rocha PIC16F877 40 pinos Freqüência máxima 20MHz. Vias de programação 14 bits 33 portas configuráveis como entradas/saídas 15 interrupções diferentes Memória EEPROM
Leia mais16F628A - The Configuration Word Jon Wilder 25 de agosto de 2011.
1 16F628A - The Configuration Word Jon Wilder 25 de agosto de 2011. Tradução e edição Prof. esp eng Luiz Antonio Vargas Pinto 22 de Fevereiro de 2015 A palavra de configuração (word config) está entre
Leia maisCurso de Linguagem C. Rinaldo Câmara Gonçalves Labtools Mosaico Didactic Division Revisão 2
Curso de Linguagem C Rinaldo Câmara Gonçalves Labtools Mosaico Didactic Division Revisão 2 Sumário SUMÁRIO...3 RECURSOS BÁSICOS: EXEMPLO 1 BOTÃO E LED...5 RECURSOS DO LIVRO...5 LÓGICA DO EXEMPLO...5 ESQUEMA
Leia maisProgramação Básica. Estrutura de um algoritmo
Programação Básica Estrutura de um algoritmo Código-fonte Como vimos na aula anterior um algoritmo pode ser representado usando um fluxograma Um algoritmo pode também ser representado usando texto Esse
Leia maisPlaca McLab1 Upgrade PIC16F84A p/ PIC16F62x
Placa Upgrade PIC16F84A p/ PIC16F62x Sumário 1. UTILIZANDO OS PICS 16F62X...3 1.1. INTRODUÇÃO...3 2. ATUALIZAÇÃO DO HARDWARE...4 2.1. UPGRADE DA PLACA MCLAB1 PARA TRABALHAR COM PIC16F627 / PIC16F628...4
Leia maisLinguagem C. Prof.ª Márcia Jani Cícero
Linguagem C Prof.ª Márcia Jani Cícero A estrutura Básica de um Programa em C Consiste em uma ou várias funções ou programas. main( ) // primeira função a ser executada // inicia a função // termina a função
Leia maisSistemas Microcontrolados
Sistemas Microcontrolados Aula 4: Programação em C para PIC Marco Jose da Silva mdasilva@utfpr.edu.br Compiladores C para PICs C18 HI-TECH CCS IAR MikroC http://www.microchip.com/ http://www.htsoft.com/
Leia maiswww.vwsolucoes.com Copyright 2013 VW Soluções
Apresentação O ClpPic40-v4 foi desenvolvido com base no microcontrolador PIC16F877A, mas pode ser utilizado qualquer outro PIC de 40 pinos da família 16F ou 18F (observar a pinagem). Ele possui várias
Leia maisMicrocontroladores PIC. Microcontroladores PIC
Microcontroladores PIC Prof. Valdir Dugo Zaragoza 28/07/2015 1 MICROCONTROLADORES PIC Os microcontroladores PIC são componentes integrados programáveis fabricados pela empresa americana Microchip. Possuem
Leia maisSistemas Microprocessados baseados no PIC16F877A
Sistemas Microprocessados baseados no PIC16F877A 20 de outubro de 2014 Sumário 1 Introdução 1 2 Revisão de Linguagem C 3 3 Ambiente de Desenvolvimento MPLAB X 5 3.1 Instalação....................................
Leia maisCapítulo 2: Introdução à Linguagem C
Capítulo 2: Introdução à Linguagem C INF1005 Programação 1 Pontifícia Universidade Católica Departamento de Informática Programa Programa é um algoritmo escrito em uma linguagem de programação. No nosso
Leia maisEstrutura do programa
Linguagem C Estrutura do programa Exemplo: #include #include main() { printf( Ola, mundo! ); system( pause ); }
Leia maiswww.vwsolucoes.com Copyright 2011 VW Soluções
1 Apresentação O adaptador ADP.v01 é utilizado para facilitar a instalação de display Lcd 16x2 ou display Lcd 20x4 nos CLP PIC28 ou CLP PIC40 através de um flat cable de 10vias de acordo com a necessidade
Leia maisWWW.cerne-tec.com.br. Comunicação USB com o PIC Vitor Amadeu Souza Parte II vitor@cerne-tec.com.br
1 Comunicação USB com o PIC Vitor Amadeu Souza Parte II vitor@cerne-tec.com.br Continuando com o artigo apresentado na edição passada de comunicação USB com o PIC, continuaremos nesta edição o estudo do
Leia maisSeqüencial de Leds utilizando o microcontrolador PIC16F628A Vitor Amadeu
Seqüencial de Leds utilizando o microcontrolador PIC16F628A Vitor Amadeu A Cerne Tecnologia e Treinamento, estará neste mês de agosto, abrindo várias seções mostrando o que é, para que servem e onde são
Leia maisLinguagem C. Programação Estruturada. Fundamentos da Linguagem. Prof. Luis Nícolas de Amorim Trigo nicolas.trigo@ifsertao-pe.edu.
Programação Estruturada Linguagem C Fundamentos da Linguagem Prof. Luis Nícolas de Amorim Trigo nicolas.trigo@ifsertao-pe.edu.br Sumário Estrutura Básica Bibliotecas Básicas Tipos de Dados Básicos Variáveis/Declaração
Leia maisSistemas Embarcados. Introdução aos sistemas embarcados
Sistemas Embarcados Introdução aos sistemas embarcados Introdução aos Sistemas embarcados Definição de um sistema embarcado Exemplos de sistemas embarcados Processadores utilizados em sistemas embarcados
Leia maisIntrodução a Programação de Jogos
Introdução a Programação de Jogos Aula 03 Introdução a Linguagem C Edirlei Soares de Lima Estrutura de um Programa C Inclusão de bibliotecas auxiliares: #include Definição
Leia maisMODULAÇÃO DE UM SINAL ANALÓGICO
Relatório de Microprocessadores 2007/2008 Engenharia Física Tecnológica MODULAÇÃO DE UM SINAL ANALÓGICO USANDO UM PWM E UM CIRCUITO RC E AQUISIÇÃO ATRAVÉS DE UM ADC Laboratório IV Trabalho realizado por:
Leia maisCapítulo 2 Operadores. A função scanf()
Capítulo 2 Operadores A função scanf() A função scanf() é outra das funções de E/S implementadas em todos os compiladores e nos permite ler dados formatados da entrada padrão (teclado). Sintaxe: scanf(
Leia maisCopyright 2014 VW Soluções
1 Apresentação O ClpPic40-B v1.0 foi desenvolvido com base no microcontrolador PIC16F887, mas pode ser utilizado qualquer outro PIC de 40 pinos da família 16F ou 18F (observar a pinagem). Ele possui várias
Leia mais8051 PROGRAMAÇÃO EM C
1 8051 PROGRAMAÇÃO EM C C E ASSEMBLY for-loop em C int z; for (z=255; z>0; z--) P1=z; loop em Assembly MOV R1,#255 ABC: MOV P1,R1 DJNZ R1,ABC 2 TIPOS DE DADOS (DATA TYPES) E ATRASOS (TIME DELAY) EM C DO
Leia maisAlgoritmos e Estruturas de Dados I (DCC/003) 2013/1. Estruturas Básicas. Aula Tópico 4
Algoritmos e Estruturas de Dados I (DCC/003) 2013/1 Estruturas Básicas Aula Tópico 4 1 Problema 3 Exibir o maior número inteiro que pode ser representado no computador. 2 Qual o maior número inteiro? Para
Leia maisProgramação Básica em Arduino Aula 2
Programação Básica em Arduino Aula 2 Execução: Laboratório de Automação e Robótica Móvel Variáveis são lugares (posições) na memória principal que servem para armazenar dados. As variáveis são acessadas
Leia maisComputação para Informática - Prof. Adriano Joaquim de Oliveira Cruz Segunda Aula Prática - 29 de agosto de 2008
Computação para Informática - Prof. Adriano Joaquim de Oliveira Cruz Segunda Aula Prática - 29 de agosto de 2008 Introdução O objetivo desta aula prática é exercitar comandos de entrada e saída simples
Leia maisLinguagem C Controle do Fluxo de Execução. Lógica de Programação
Linguagem C Controle do Fluxo de Execução Lógica de Programação Caro(a) aluno(a), Aqui começaremos a escrever os nossos primeiros programas em uma Linguagem de Programação. Divirta-se!!! Estrutura Seqüencial
Leia maisComunicando com um teclado PS2 Vitor Amadeu Souza
Comunicando com um teclado PS2 Vitor Amadeu Souza vitor@cerne-tec.com.br Introdução Os teclados são corriqueiramente utilizados nos dias de hoje no mundo dos PCs. Neste artigo, irei apresentar ao leitor
Leia maisTEM VÁRIOS ESTADOS: 0V,0.1V,3V,3.3V,4V,5V,10V, ETC.
CONVERSOR ANALÓGICO / DIGITAL SINAL DIGITAL ASSUME APENAS 2 ESTADOS: 0V E 5V SINAL ANALÓGICO TEM VÁRIOS ESTADOS: 0V,0.1V,3V,3.3V,4V,5V,10V, ETC. 1 FONTE DESTES SINAIS ANALÓGICOS UM DOS NOSSOS OBJETIVOS
Leia maisBinário para Decimal. Binário: = 19. Decimal:
www.iesa.com.br 1 Binário para Decimal Binário: 00010011 0 0 0 1 0 0 1 1 2 7 2 6 2 5 2 4 2 3 2 2 2 1 2 0 128 64 32 16 8 4 2 1 16 + 2 + 1 = 19 Decimal: 19 www.iesa.com.br 2 Decimal para Binário Decimal:
Leia maisVariáveis, Tipos de Dados e Operadores
! Variáveis, Tipos de Dados e Operadores Engenharias Informática Aplicada 2.o sem/2013 Profa Suely (e-mail: smaoki@yahoo.com) VARIÁVEL VARIÁVEL É um local lógico, ligado a um endereço físico da memória
Leia maisINF 1005 Programação I
INF 1005 Programação I Aula 03 Introdução a Linguagem C Edirlei Soares de Lima Estrutura de um Programa C Inclusão de bibliotecas auxiliares: #include Definição de constantes:
Leia maisV1 5V +V. (14)Vdd (6)RB0 PIC 16F628A. (16) Clk-out. C1 33pF. C2 33pF. Figura 1 Circuito pisca-pisca.
AUTOR Maurício Madeira Oliveira Página pessoal (fonte): www.seguidorsolar.com.br Este curso pode ser usado e divulgado, sem fins comerciais, citar fonte e autor Prévia: Curso de Microcontroladores PIC
Leia mais(a partir da versão 1.27 Beta) Rev. 0 em 24.09.2003. Copyright Junho/2003 Renie S. Marquet
(a partir da versão 1.27 Beta) Rev. 0 em 24.09.2003 Copyright Junho/2003 Renie S. Marquet ËQGLFH 1RWDVVREUHRPDQXDOHRVVRIWZDUHV 2TXHpR5HPRWR6HULDO &RPSRQHQWHVGR5HPRWR6HULDO3& ÈUHDVGDWHODSULQFLSDO 0HQXSULQFLSDO
Leia maisIntrodução à robótica
Núcleo de Robótica e Sistemas Cibernéticos Ensino pesquisa e extensão em robótica educacional e cibernética. Introdução à robótica Objetivo da aula 7: Entender o funcionamento de um controlador ou processador
Leia maisINTRODUÇÃO A LINGUAGEM C
INTRODUÇÃO A LINGUAGEM C Aula 01 Programação em Microinformática Prof. Allbert Velleniche de Aquino Almeida E-mail: professor@allbert.com.br Site: http://www.allbert.com.br Histórico O C nasceu na década
Leia maisComércio e Manutenção de Produtos Eletrônicos. Mapeamento de memória e conexões do Controlador CP-WS13/8DI8DO2AI2AO/USB/OEM. Versão 1.
Comércio e Manutenção de Produtos Eletrônicos Manual CP-WS1 Mapeamento de memória e conexões do Controlador CP-WS13/8DI8DO2AI2AO/USB/OEM PROXSYS Versão 1.4 Setembro -2015 Controlador Industrial CP-WS1
Leia maisPIC16F628a. Pinagem do PIC16F628a:
PIC16F628a O PIC16F628a é um microcontrolador fabricado pela Microchip Technology (www.microchip.com), com as seguintes características: - composto de 18 pinos; - possui somente 35 instruções no seu microcódigo;
Leia maisUNIVERSIDADE FEDERAL DO PARANÁ MICROCONTROLADOR PIC 18F452 / PROTEUS
UNIVERSIDADE FEDERAL DO PARANÁ CURSO DE ENGENHARIA ELÉTRICA MINI CURSO MICROCONTROLADOR PIC 18F452 / PROTEUS Orientando: João Luiz Glovacki Graneman de Melo Orientador: Prof. Dr. Gideon Villar Leandro
Leia maisComunicação RC5 com o dspic Vitor Amadeu Souza
Comunicação RC5 com o dspic Vitor Amadeu Souza vitor@cerne-tec.com.br Neste artigo, irei apresentar aos leitores um exemplo prático de comunicação via infravermelho, utilizando neste caso o protocolo RC5.
Leia maisarduino = new roboticalivre(); Arduino Marcus Fazzi
arduino=newroboticalivre(); Arduino MarcusFazzi arduino::whatis(); Placadedesenvolvimentomicrocontrolada, Podereceberdadosdoambienteatravésdeuma grandevariedadedesesores; PodeafetaroambientecontrolandoLEDs,
Leia maisEPAC Microcontroladores Organização do curso 30/8/2007
EPAC 2007 Microcontroladores 8051 Thiago B. Ló Guilherme Galante Organização do curso 1. Parte I Introdução Visão Geral da família 8051 O circuito básico Atividades Práticas 2. Parte II Interrupções Contadores
Leia maisIntrodução ao Arduino. Pessanha Santos ASPOF EN-AEL
Introdução ao Arduino Pessanha Santos ASPOF EN-AEL Programa 1. Introdução à plataforma de desenvolvimento Arduino 2. Análise à sua constituição 3. Software de desenvolvimento Arduino 4. Estrutura e Sintaxe
Leia maisCerne Tecnologia e Treinamento
Cerne Tecnologia e Treinamento Tutorial de Instalação da Placa X-Control I E-mail: Sumário Configurando o PC 3 Conectando a Placa 6 Conectores e Pinagem da Placa 7 Comandos para comunicação 13 2 Obs: A
Leia maisIntrodução à Programação em C (I)
Introdução à Programação em C (I) IAED Tagus, 2009/2010 Organização de Ficheiros em C Organização Típica de Ficheiros em C Inclusão de bibliotecas de sistema Inclusão de bibliotecas locais Definição de
Leia maisEstrutura de Programas e Tipos de Dados Simples
SSC0101 - ICC1 Teórica Introdução à Ciência da Computação I Estrutura de Programas e Tipos de Dados Simples Prof. Vanderlei Bonato: vbonato@icmc.usp.br Prof. Claudio Fabiano Motta Toledo: claudio@icmc.usp.br
Leia maisMICROCONTROLADORES PIC PRIMEIROS PASSOS
MICROCONTROLADORES PIC PRIMEIROS PASSOS Os microcontroladores são chips inteligentes, que tem um processador, pinos de entradas/saídas e memória. Através da programação dos microcontroladores podemos controlar
Leia maisPROGRAMAÇÃO DE UM MICROPROCESSADOR
Relatório de Microprocessadores 2007/2008 Engenharia Física Tecnológica PROGRAMAÇÃO DE UM MICROPROCESSADOR EM C PARA CONTROLO DE LEDS ATRAVÉS DE UMA CONSOLA E COMUNICAÇÃO EM SÉRIE Laboratório II Trabalho
Leia maisMICROCONTROLADORES NO RADIOAMADORISMO
MICROCONTROLADORES NO RADIOAMADORISMO CT2KAV CARLOS SOUSA Almeirim, 17 de Setembro de 2016 Único circuito com O MICROCONTROLADOR Processador Memória Ram, E2Prom, Flash Periféricos ADC, USART, USB Comparadores,
Leia maisArquitetura de Computadores. Tipos de Instruções
Arquitetura de Computadores Tipos de Instruções Tipos de instruções Instruções de movimento de dados Operações diádicas Operações monádicas Instruções de comparação e desvio condicional Instruções de chamada
Leia maisComponentes da linguagem C++
Componentes da linguagem C++ C++ é uma linguagem de programação orientada a objetos (OO) que oferece suporte às características OO, além de permitir você realizar outras tarefas, similarmente a outras
Leia maisMC102 Algoritmos e Programação de Computadores
MC102 Algoritmos e Programação de Computadores Instituto de Computação UNICAMP Primeiro Semestre de 2014 Roteiro 1 Maior número 2 Soma de n números 3 Fatorial 4 Máximo Divisor Comum (MDC) 5 Números primos
Leia maisProvisório. Development of integrated electroestimulation equipment for medical rehabilitation of spinal cord injuries. Universidade de Aveiro
Universidade de Aveiro Departamentos de Física e Mecânica 2007 Provisório Development of integrated electroestimulation equipment for medical rehabilitation of spinal cord injuries Referência ANEXO Eduardo
Leia maisÉrica Ltda. Microcontroladores PIC18 com Linguagem C. Wagner da Silva Zanco. Uma Abordagem Prática e Objetiva. Com Base no PIC18F4520.
Wagner da Silva Zanco Microcontroladores PIC18 com Linguagem C Uma Abordagem Prática e Objetiva Com Base no PIC18F4520 1a Edição São Paulo 2010 Editora Érica Ltda. 131 Memórias Sumário Parte 1 Microcontrolador
Leia maisEstruturas de Repetição. for() while() do-while() break; continue;
Estruturas de Repetição for() while() do-while() break; continue; 1 Auto-Ajuda (!) Como ajudar a solucionar erros básicos do meu programa? Verificar os ; Verificar se não há comandos em maiúsculas; Verificar
Leia maisJosé Romildo Malaquias 2011-1
Programação de Computadores I Aula 08 Programação: Estruturas de Repetição José Romildo Malaquias Departamento de Computação Universidade Federal de Ouro Preto 2011-1 1/58 Motivação Como imprimir os três
Leia maisKIT INICIANTE V7 PARA ARDUINO
Módulo 3 Componentes: 1 Sensor de Temperatura LM35 Descrição: Com o auxílio da porta serial e do monitor serial, o usuário irá fazer a leitura do sensor de temperatura em ºC para fazer o projeto seguinte.
Leia maisEdwar Saliba Júnior. Dicas, Comandos e Exemplos Comparativos entre Linguagem Algorítmica e Linguagem C
Edwar Saliba Júnior Dicas, Comandos e Exemplos Comparativos entre Linguagem Algorítmica e Linguagem C Belo Horizonte 2010 Sumário 1 Nota:... 2 2 Comandos e Palavras Reservadas:... 3 3 Dicas... 4 3.1 Strings
Leia maisint pinosensor = A0; //define a variável como entrada analógica //no pino A0 para o sensor LM35.
SENSOR TEMPERATURA LM-35 com DISPLAY LCD 16x02: O Arduino lê repetidamente uma entrada analógica e após esse valor lido passar por uma transformação matemática é impresso na tela do LCD. O LM35 é um sensor
Leia maisMicrocontroladores e FPGAs
Microcontroladores e FPGAs Aplicações em Automação Edward David Moreno Ordonez Cesar Giacomini Penteado Alexandre César Rodrigues da Silva Novatec Editora Capítulo 1 Microcontrolador PIC16F628, da Microchip
Leia maisIntrodução à Programação em C (I)
Introdução à Programação em C (I) Factorial Definição de função para cálculo de factorial Scheme (define (factorial n) (if (= n 1) 1 (* n (factorial (- n 1))))) C int factorial (int n) { if (n == 1) return
Leia mais2. OPERADORES... 6 3. ALGORITMOS, FLUXOGRAMAS E PROGRAMAS... 8 4. FUNÇÕES... 10
1. TIPOS DE DADOS... 3 1.1 DEFINIÇÃO DE DADOS... 3 1.2 - DEFINIÇÃO DE VARIÁVEIS... 3 1.3 - VARIÁVEIS EM C... 3 1.3.1. NOME DAS VARIÁVEIS... 3 1.3.2 - TIPOS BÁSICOS... 3 1.3.3 DECLARAÇÃO DE VARIÁVEIS...
Leia maisCURSO TERMO TURMA PERIODO DISCIPLINA ENGENHARIA MECATRÔNICA 8 A NOTURNO SISTEMAS DE AQUISIÇÃO DE DADOS
TRABALHO 01 Automação de Processo Proposta de solução. Parte I Análise de Hardware Configuração do circuito PAINEL DE COMANDO VDD Alimentação de 5V. Alimentação dos microcontroladores usada para ativar
Leia maisLinguagem C: variáveis, operadores, entrada/saída. Prof. Críston Algoritmos e Programação
Linguagem C: variáveis, operadores, entrada/saída Prof. Críston Algoritmos e Programação Linguagem C Linguagem de uso geral (qualquer tipo de aplicação) Uma das linguagens mais utilizadas Foi utilizada
Leia maisInstituto Federal de Educação, Ciência e Tecnologia da Paraíba. Microcontrolador PIC 16F877
Instituto Federal de Educação, Ciência e Tecnologia da Paraíba MINICURSO Microcontrolador PIC 16F877 Alison Lins de Lima Fábio Montenegro Pontes Jonathan B. da Silva Rafael Tavares Coutinho Thiago Pinto
Leia maisSuporta os microcontroladores: R. Leonardo da Vinci, 883 - Campinas/SP CEP 13.077-009 F.: (19) 4141.3351 / 3304.1605
Suporta os microcontroladores: PIC16F877A, PIC18F452, PIC18F4520, PIC18F4550, PIC 18F876A, PIC18F252, PIC18F2550 e outros com 28 e 40 pinos O Kit de desenvolvimento ACEPIC PRO V2.0 foi projetado tendo
Leia maisMicrocontroladores. Prof. Nivaldo T. Schiefler Jr. M.Eng Homepage: www.joinville.ifsc.edu.br/~nivaldo Email: nivaldo@ifsc.edu.br
Prof. Nivaldo T. Schiefler Jr. M.Eng Homepage: www.joinville.ifsc.edu.br/~nivaldo Email: nivaldo@ifsc.edu.br Conceito final será constituído de duas avaliações: 1ª Conceito avaliação teórica 2ª Conceito
Leia maisKit de desenvolvimento ACEPIC PRO V3.0
Kit de desenvolvimento ACEPIC PRO V3.0 O Kit de desenvolvimento ACEPIC PRO V3.0 foi desenvolvido tendo em vista a integração de vários periféricos numa só placa, evitando o uso de protoboards e facilitando
Leia maisABB Automação. Indicador Digital Processos Pt100 e TAP s MODO DE USO. Dados Técnicos Conexões elétricas Utilização do teclado Dimensional
Indicador Digital Processos Pt100 e TAP s MODO DE USO Dados Técnicos Conexões elétricas Utilização do teclado Dimensional ABB Automação Hartmann & Braun Dados Técnicos (NRB5180) Entrada Características
Leia maisComunicação Serial. Comunicação Serial
RECEPÇÃO TRANSMISSÃO D7 D6 D5 D4 D3 D2 D1 D0 DESLOCAMENTO DESLOCAMENTO D7 D6 D5 D4 D3 D2 D1 D0 D0 D0 D7 D6 D5 D4 D3 D2 D1 D1 D0 D1 D7 D6 D5 D4 D3 D2 D2 D0 D1 D2 D7 D6 D5 D4 D3 D3 D0 D1 D2 D3 D7 D6 D5 D4
Leia maisIntrodução a Computação
Introdução a Computação Aula 02 Introdução a Linguagem C Edirlei Soares de Lima Lógica de Programação Lógica de Programação é a técnica de criar sequências lógicas de ações para
Leia maisINF 1005 Programação I
INF 1005 Programação I Aula 12 Cadeia de Caracteres (Strings) Edirlei Soares de Lima Caracteres Até o momento nós somente utilizamos variáveis que armazenam números (int, float ou
Leia maisSumário. 1. Apresentação Hardware Microcontrolador PIC16F877A LCD alfanumérico Displays de 7 segmentos...
02/03/2011 Sumário 1. Apresentação... 4 2. Hardware... 5 2.1. Microcontrolador PIC16F877A... 5 2.2. LCD alfanumérico... 5 2.3. Displays de 7 segmentos... 6 2.4. Teclado... 6 2.5. Leds... 7 2.6. Buzzer...
Leia maisFunções em C. Lucas Ferrari de Oliveira Professor Adjunto. Linguagem de Programação Estruturada I. Universidade Federal do Paraná
em C Linguagem de Programação Estruturada I Lucas Ferrari de Oliveira Professor Adjunto Universidade Federal do Paraná Sumário Funções: Conceitos; Forma Geral das funções; Regras de Escopo; Argumentos
Leia maisProgramação em BASIC para o PIC Mostrando Mensagens no Display LCD Vitor Amadeu Souza
Programação em BASIC para o PIC Mostrando Mensagens no Display LCD Vitor Amadeu Souza Introdução Nesta terceira série de artigos que aborda a programação na linguagem BASIC para o microcontrolador PIC,
Leia maisMicroprocessadores e Aplicações
Microprocessadores e Aplicações Planificação das aulas teóricas e aulas práticas Ano Lectivo 2005/ 2006 Aula 1 Semana 26 a 30 de Setembro - Apresentação 1. Apresentação da disciplina aos alunos: a. Programa
Leia maisControlador de DMA. Gustavo G. Parma
Controlador de DMA Gustavo G. Parma Controlador de DMA Transferência de um dado de um dispositivo I/O para a memória Iniciada pela CPU Transferência efetuada e terminada pelo controlador de DMA CPU pode
Leia maisResumo da Introdução de Prática de Programação com C. A Linguagem C
Resumo da Introdução de Prática de Programação com C A Linguagem C O C nasceu na década de 70. Seu inventor, Dennis Ritchie, implementou-o pela primeira vez usando um DEC PDP-11 rodando o sistema operacional
Leia maisManipulação de Arquivos
1 Manipulação de Arquivos Para realizar E/S em arquivo, você precisa incluir o arquivo-cabeçalho fstream.h nos programas. Esse arquivo define muitas classes e valores importantes. Abrindo e fechando um
Leia maisOrganização e Arquitetura de Computadores I
Universidade Federal de Campina Grande Departamento de Sistemas e Computação Curso de Bacharelado em Ciência da Computação Organização e Arquitetura de Computadores I Circuitos Lógicos Sequenciais (Parte
Leia maisProgramação Daniel Corteletti Aula 3 Parte III Página 1/7
Programação Daniel Corteletti Aula 3 Parte III Página /7 LINGUAGEM DE PROGRAMAÇÃO - ASSEMLY - PARTE I Assembly - o que é "Assembly" significa montagem. "Assembler" significa montador. Montagem é o ato
Leia maisUNICEUB CENTRO UNIVERSITÁRIO DE BRASÍLIA FATECS FACULDADE DE TECNOLOGIA E CIÊNCIAS SOCIAIS APLICADAS CURSO DE ENGENHARIA DA COMPUTAÇÃO
UNICEUB CENTRO UNIVERSITÁRIO DE BRASÍLIA FATECS FACULDADE DE TECNOLOGIA E CIÊNCIAS SOCIAIS APLICADAS CURSO DE ENGENHARIA DA COMPUTAÇÃO FLÁVIA ROSA DE SOUSA PEREIRA MONITORAÇÃO DE NÍVEL SONORO BRASÍLIA/DF
Leia mais3. INTRODUÇÃO À LINGUAGEM C 3.1. CONCEITOS BÁSICOS. Lógica de Programação
Lógica de Programação 3. INTRODUÇÃO À LINGUAGEM C Caro Aluno Vamos iniciar o terceiro capítulo da nossa disciplina. Agora vamos começar a aplicar os conceitos vistos nos capítulos anteriores em uma linguagem
Leia maisPROGRAMAÇÃO DO TREINAMENTO:
PROGRAMAÇÃO DO TREINAMENTO: Página 2 0. Objetivos deste treinamento Quem está fazendo este módulo avançado II é porque já passou pelos módulos anteriores. Portanto não serão abordados aqui os tópicos já
Leia maisProfessor: Vlademir de Oliveira Disciplina: Microcontroladores e DSP. Memórias de Dados e de Programa
4. Memórias de Dados e de Programa Professor: Vlademir de Oliveira Disciplina: Microcontroladores e DSP 4.1 Memórias Semicondutoras Algumas definições Célula: Dispositivo de armazenamento de 1 bit. Palavra:
Leia mais12/11/13. Obje%vos do laboratório. SST20707 Síntese de Sistemas de Telecomunicações. Síntese de máquinas de estado (FSM) Finite State Machine (FSM)
Instituto Federal de Santa Catarina Área de Telecomunicações SST20707 Síntese de Sistemas de Telecomunicações Prof. Roberto de Matos Aviso de direitos Autorais: Transparências baseadas no trabalho do Prof.
Leia maisProgramação em BASIC para o PIC Projetos com Display Gráfico Vitor Amadeu Souza
Programação em BASIC para o PIC Projetos com Display Gráfico Vitor Amadeu Souza Introdução No artigo desta edição, veremos os passos para controlar um dispaly gráfico de 128 x 64 pixels. A idéia será apresentar
Leia maisDepartamento de Informática - PUC-Rio INF 1005 Programação I P1 22/09/2010 Nota
P1 22/09/2010 Matrícula: Turma: Questão 1) (3,5 pontos) O Índice de Desenvolvimento Humano (IDH) é uma medida do bemestar de uma população. Engloba três dimensões: educação (E), longevidade (L) e a riqueza
Leia maisFaculdade de Engenharia de Ilha Solteira- Departamento de Engenharia Elétrica
Faculdade de Engenharia de Ilha Solteira- Departamento de Engenharia Elétrica TEEE I- Projeto de Robôs Móveis - Profs. Nobuo Oki e Suely Cunha Amaro Mantovani 1 o.sem / 2013 TEEE I Projeto de Robôs Móveis
Leia maisAlgoritmos e Programação
Universidade Federal do Vale do São Francisco Curso de Engenharia da Produção / Elétrica Algoritmos e Programação Parte 05 Prof. Jorge Cavalcanti jorge.cavalcanti@univasf.edu.br www.univasf.edu.br/~jorge.cavalcanti
Leia maisCATÁLOGO ENERGIA SOLAR FOTOVOLTAICA CONTROLADORES SOLARES
CATÁLOGO ENERGIA SOLAR FOTOVOLTAICA CONTROLADORES SOLARES PLURIGÁS SOLAR ENERGIAS LDA. - End: Urb. António Aleixo -1, 4820-358 Fafe, Portugal Controlador Remoto para série MPPT Características Controlador
Leia mais