Arm7

Como sabemos, os microcontroladores pegam a entrada analógica de sensores analógicos e usam ADC (conversor analógico para digital) para processar esses sinais. Mas e se um microcontrolador quiser produzir um sinal analógico para controlar dispositivos operados por analogia, como um servo motor, motor CC, etc.? Microcontroladores não produzem voltagem de saída como 1 V, 5 V, em vez disso, eles usam uma técnica chamada PWM para operar dispositivos analógicos. Um exemplo de PWM é a ventoinha de resfriamento do nosso laptop (motor DC) que precisa ser controlada por velocidade de acordo com a temperatura, e a mesma é implementada usando a técnica de Modulação por Largura de Pulso (PWM) em placas-mãe.

Neste tutorial, controlaremos o brilho de um LED usando o PWM no microcontrolador ARM7-LPC2148.

PWM (modulação por largura de pulso)

O PWM é uma boa maneira de controlar os dispositivos analógicos usando valores digitais, como controlar a velocidade do motor, o brilho de um led, etc. Embora o PWM não forneça saída analógica pura, ele gera pulsos analógicos decentes para controlar os dispositivos analógicos. Na verdade, o PWM modula a largura de uma onda de pulso retangular para obter uma variação no valor médio da onda resultante.

Ciclo de trabalho do PWM

A porcentagem de tempo em que o sinal PWM permanece ALTO (no tempo) é chamada de ciclo de serviço. Se o sinal estiver sempre LIGADO, ele está em 100% do ciclo de trabalho e se estiver sempre desligado, ele está em 0% do ciclo de trabalho.

Ciclo de trabalho = tempo para ligar / (tempo para ligar + tempo para desligar)

Pinos PWM em ARM7-LPC2148

A imagem abaixo indica os pinos de saída PWM de ARM7-LPC2148. Há um total de seis pinos para PWM.

Canal PWM	Pinos de porta LPC2148
PWM1	P0.0
PWM2	P0.7
PWM3	P0.1
PWM4	P0.8
PWM5	P0,21
PWM6	P0.9

Registros PWM em ARM7-LPC2148

Antes de entrar em nosso projeto, precisamos saber sobre os registradores PWM no LPC2148.

Aqui está a lista de registros usados no LPC2148 para PWM

1. PWMPR: Registro de pré-escala PWM

Uso: É um registrador de 32 bits. Ele contém o número de vezes (menos 1) que o PCLK deve fazer um ciclo antes de incrementar o contador do temporizador PWM (ele realmente mantém o valor máximo do contador pré-escala).

2. PWMPC: PWM Prescaler Counter

Uso: É um registrador de 32 bits . Ele contém o valor do contador incremental. Quando este valor é igual ao valor PR mais 1, o PWM Timer Counter (TC) é incrementado.

3. PWMTCR: Registro de controle do temporizador PWM

Uso: Contém os bits de controle Habilitar Contador, Reinicializar Contador e Habilitar PWM. É um registro de 8 bits.

7: 4	3	2	1	0
RESERVADO	PWM ENABLE	RESERVADO	CONTADOR RESET	CONTADOR ATIVAR

Habilitar PWM: (Bit-3)
0- PWM desabilitado

1- PWM habilitado
Habilitar contador: (Bit-0)
0- Desabilitar Contadores

1- Habilitar Contador
Reset do contador: (Bit-1)

0- Não fazer nada.

1- Reinicia PWMTC e PWMPC na borda positiva de PCLK.

4. PWMTC: Contador de temporizador PWM

Uso: É um registrador de 32 bits. Ele contém o valor atual do cronômetro PWM incrementado. Quando o Contador do Prescaler (PC) atinge o valor do Registro do Prescaler (PR) mais 1, este contador é incrementado.

5. PWMIR: Registro de interrupção PWM

Uso: é um registrador de 16 bits. Ele contém os sinalizadores de interrupção para PWM Match Channels 0-6. Um sinalizador de interrupção é definido quando ocorre uma interrupção para aquele canal (MRx Interrupt), onde X é o número do canal (0 a 6).

6. PWMMR0-PWMMR6: PWM Match Register

Uso: É um registrador de 32 bits . Na verdade, o grupo Match Channel permite a configuração de 6 saídas PWM controladas por borda única ou 3 saídas PWM controladas por borda dupla. Você pode modificar os sete canais de correspondência para configurar essas saídas PWM para atender aos seus requisitos em PWMPCR.

7. PWMMCR: PWM Match Control Register

Uso: É um registrador de 32 bits. Ele contém os bits de interrupção, reinicialização e parada que controlam o canal de correspondência selecionado. Uma correspondência ocorre entre os registros de correspondência PWM e os contadores do temporizador PWM.

31:21	20	19	18	..	5	4	3	2	1	0
RESERVADO	PWMMR6S	PWMMR6R	PWMMR6I	..	PWMMR1S	PWMMR1R	PWMMR11	PWMMR0S	PWMMR0R	PWMMR01

Aqui x é de 0 a 6

PWMMRxI (Bit-0)

ATIVAR OU DESATIVAR interrupções PWM

0- Desabilite as interrupções PWM Match.

1- Habilite a interrupção PWM Match.

PWMMRxR: (Bit-1)

RESET PWMTC - valor do contador do temporizador sempre que corresponder a PWMRx

0- Não faça nada.

1- Reinicia o PWMTC.

PWMMRxS: (Bit 2)

PARE PWMTC e PWMPC quando PWMTC atingir o valor de registro Match

0- Desabilite o recurso de parada PWM.

1- Habilite o recurso PWM Stop.

8. PWMPCR: Registro de controle PWM

Uso: É um registrador de 16 bits. Ele contém os bits que habilitam as saídas PWM 0-6 e selecionam o controle de borda única ou dupla para cada saída.

31:15	14: 9	8: 7	6: 2	1: 0
NÃO UTILIZADO	PWMENA6-PWMENA1	NÃO UTILIZADO	PWMSEL6-PWMSEL2	NÃO UTILIZADO

PWMSELx (x: 2 a 6)

Modo de borda única para PWMx
1- Modo de borda dupla para PWMx.

PWMENAx (x: 1 a 6)

Desativar PWMx.
1- PWMx ativado.

9. PWMLER: PWM Latch Enable Register

Uso: é um registrador de 8 bits. Ele contém os bits Match x Latch para cada Match Channel.

31: 7	6	5	4	3	2	1	0
NÃO UTILIZADO	LEN6	LEN5	LEN4	LEN3	LEN2	LEN1	LEN0

LENx (x: 0 a 6):

0- Desabilitar o carregamento de novos Valores de Correspondência

1- Carregar os novos valores de Correspondência do (PWMMRx) Registrador PWMMatch quando o cronômetro for zerado.

Agora vamos começar a construir a configuração do hardware para demonstrar a modulação por largura de pulso no microcontrolador ARM.

Componentes necessários

Hardware

Microcontrolador ARM7-LPC2148
IC regulador de tensão de 3,3 V
Potenciômetro de 10k
LED (qualquer cor)
Módulo de exibição LCD (16x2)
Tábua de pão
Fios de conexão

Programas

Keil uVision5
Ferramenta Flash Magic

Diagrama de circuito e conexões

Conexões entre LCD e ARM7-LPC2148

ARM7-LPC2148	LCD (16x2)
P0.4	RS (Seleção de Registro)
P0.6	E (habilitar)
P0,12	D4 (dados pino 4)
P0.13	D5 (pino de dados 5)
P0.14	D6 (pino de dados 6)
P0.15	D7 (dados pino 7)
GND	VSS, R / W, K
+ 5V	VDD, A

Conexão entre LED e ARM7-LPC2148

O ANODE do LED está conectado à saída PWM (P0.0) do LPC2148, enquanto o pino CATHODE do LED está conectado ao pino GND do LPC2148.

Conexão entre ARM7-LPC2148 e potenciômetro com regulador de tensão de 3,3 V

IC regulador de tensão de 3,3 V	Função de pino	Pin ARM-7 LPC2148
1. Pino esquerdo	- Ve do GND	PIN GND
2. Pino central	Saída regulada de + 3,3 V	Para a entrada do potenciômetro e a saída do potenciômetro para P0.28 de LPC2148
3. Pino direito	+ Ve de 5V ENTRADA	+ 5V

Pontos a serem observados

1. Um regulador de tensão de 3,3 V é usado aqui para fornecer o valor de entrada analógica para o pino ADC (P0,28) do LPC2148 e, como estamos usando uma alimentação de 5 V, precisamos regular a tensão com um regulador de tensão de 3,3 V.

2. Um potenciômetro é usado para variar a tensão entre (0V a 3,3V) para fornecer entrada analógica (ADC) para o pino P0.28 do LPC2148

Programando ARM7-LPC2148 para PWM

Para programar o ARM7-LPC2148, precisamos da ferramenta Keil uVision e Flash Magic. Estamos usando o cabo USB para programar o ARM7 Stick via porta micro USB. Nós escrevemos código usando Keil e criamos um arquivo hexadecimal e então o arquivo HEX é enviado para o stick ARM7 usando Flash Magic. Para saber mais sobre como instalar keil uVision e Flash Magic e como usá-los, siga o link Getting Started With ARM7 LPC2148 Microcontroller e programe-o usando Keil uVision.

Neste tutorial usaremos as técnicas ADC e PWM para controlar o brilho do LED. Aqui, o LPC2148 recebe uma entrada analógica (0 a 3,3 V) por meio do pino de entrada ADC P0.28, então essa entrada analógica é convertida em valor digital (0 a 1023). Em seguida, esse valor é novamente convertido em valor digital (0 - 255), pois a saída PWM do LPC2148 tem apenas resolução de 8 bits (2 ⁸). O LED é conectado ao pino PWM P0.0 e o brilho do LED pode ser controlado usando o potenciômetro. Para saber mais sobre ADC em ARM7-LPC2148, siga o link.

Etapas envolvidas na programação LPC2148 para PWM e ADC

Etapa 1: - A primeira coisa é configurar o PLL para geração de relógio, pois ele define o relógio do sistema e o relógio periférico do LPC2148 de acordo com a necessidade do programador. A frequência máxima do relógio para LPC2148 é 60Mhz. As linhas a seguir são usadas para configurar a geração do relógio PLL.

void initilizePLL (void) // Função para usar PLL para geração de relógio { PLL0CON = 0x01; PLL0CFG = 0x24; PLL0FEED = 0xAA; PLL0FEED = 0x55; enquanto (! (PLL0STAT & 0x00000400)); PLL0CON = 0x03; PLL0FEED = 0xAA; PLL0FEED = 0x55; VPBDIV = 0x01; }

Passo 2: - O próximo passo é selecionar os pinos PWM e a função PWM do LPC2148 usando o registro PINSEL. Usamos PINSEL0 como usamos P0.0 para saída PWM de LPC2148.

PINSEL0 = 0x00000002; // Configurando o pino P0.0 para saída PWM

Passo 3: - Em seguida, precisamos RESETAR os timers usando PWMTCR (Timer Control Register).

PWMTCR = (1 << 1); // Configurando o registro de controle do temporizador PWM como redefinição do contador

E então, defina o valor pré-escala que decide a resolução do PWM. Estou configurando para zero

PWMPR = 0X00; // Definindo o valor de pré-escala PWM

Passo 4: - Em seguida, precisamos definir o PWMMCR (PWM match control register), pois ele define a operação como reset, interrupções para PWMMR0.

PWMMCR = (1 << 0) - (1 << 1); // Configurando o registro de controle de correspondência PWM

Etapa 5: - O período máximo do canal PWM é definido usando PWMMR.

PWMMR0 = PWMvalue; // Dando valor PWM Valor máximo

No nosso caso, o valor máximo é 255 (para brilho máximo)

Etapa 6: - Em seguida, precisamos definir o Latch Enable para os registros de correspondência correspondentes usando PWMLER

PWMLER = (1 << 0); // Enalbe PWM trava

(Usamos PWMMR0) Portanto, habilite o bit correspondente configurando 1 em PWMLER

Etapa 7: - Para habilitar a saída PWM para o pino, precisamos usar o PWMTCR para habilitar os contadores de temporizador PWM e os modos PWM.

PWMTCR = (1 << 0) - (1 << 3); // Habilitando PWM e contador PWM

Passo 8: - Agora precisamos obter os valores do potenciômetro para definir o ciclo de trabalho do PWM do pino P0.28 do ADC. Portanto, usamos o módulo ADC no LPC2148 para converter a entrada analógica dos potenciômetros (0 a 3,3 V) para os valores ADC (0 a 1023).

Aqui, estamos convertendo os valores de 0-1023 para 0-255 dividindo-o por 4, pois o PWM de LPC2148 tem resolução de 8 bits (2 ⁸).

Etapa 9: - Para selecionar o pino ADC P0.28 em LPC2148, usamos

PINSEL1 = 0x01000000; // Configurando P0.28 como ADC INPUT AD0CR = (((14) << 8) - (1 << 21)); // Configurando o relógio e PDN para conversão A / D

As linhas a seguir capturam a entrada analógica (0 a 3,3 V) e a convertem em valor digital (0 a 1023). E então esses valores digitais são divididos por 4 para convertê-los em (0 a 255) e finalmente alimentados como saída PWM no pino P0.0 do LPC2148 no qual o LED está conectado.

AD0CR - = (1 << 1); // Seleciona o canal AD0.1 no registro ADC delaytime (10); AD0CR - = (1 << 24); // Iniciar a conversão A / D while ((AD0DR1 & (1 << 31)) == 0); // Verifique o bit DONE no registro de dados ADC adcvalue = (AD0DR1 >> 6) & 0x3ff; // Pega o RESULTADO do registro de dados ADC dutycycle = adcvalue / 4; // fórmula para obter os valores do ciclo de serviço de (0 a 255) PWMMR1 = ciclo de serviço; // definir o valor do ciclo de dever para o registro de correspondência PWM PWMLER - = (1 << 1); // Habilita a saída PWM com o valor do ciclo de trabalho

Etapa 10: - Em seguida, exibimos esses valores no módulo de exibição LCD (16X2). Portanto, adicionamos as seguintes linhas para inicializar o módulo de display LCD

Void LCD_INITILIZE (void) // Função para preparar o LCD { IO0DIR = 0x0000FFF0; // Define os pinos P0.12, P0.13, P0.14, P0.15, P0.4, P0.6 como tempo de retardo de SAÍDA (20); LCD_SEND (0x02); // Inicializa o LCD no modo de operação de 4 bits LCD_SEND (0x28); // 2 linhas (16X2) LCD_SEND (0x0C); // Exibe o cursor desligado LCD_SEND (0x06); // Cursor de incremento automático LCD_SEND (0x01); // Mostra limpar LCD_SEND (0x80); // Primeira linha, primeira posição }

Como conectamos o LCD no modo de 4 bits com o LPC2148, precisamos enviar os valores a serem exibidos como nibble a nibble (Upper Nibble e Lower Nibble). Portanto, as seguintes linhas são usadas.

void LCD_DISPLAY (char * msg) // Função para imprimir os caracteres enviados um a um { uint8_t i = 0; enquanto (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Envia o nibble superior IO0SET = 0x00000050; // RS HIGH & ENABLE HIGH para imprimir os dados IO0CLR = 0x00000020; // RW LOW Modo de gravação delaytime (2); IO0CLR = 0x00000040; // EN = 0, RS e RW inalterados (ou seja, RS = 1, RW = 0) delaytime (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Envia o nibble inferior IO0SET = 0x00000050; // RS & EN HIGH IO0CLR = 0x00000020; tempo de atraso (2); IO0CLR = 0x00000040; tempo de atraso (5); i ++; } }

Para exibir esses valores ADC e PWM, usamos as seguintes linhas na função int main () .

LCD_SEND (0x80); sprintf (displayadc, "adcvalue =% f", adcvalue); LCD_DISPLAY (displayadc); // Exibir valor ADC (0 a 1023) LCD_SEND (0xC0); sprintf (ledoutput, "PWM OP =%. 2f", brilho); LCD_DISPLAY (ledoutput); // Exibe os valores do ciclo de serviço de (0 a 255)

O código completo e a descrição do vídeo do tutorial são fornecidos abaixo.