Microcontrolandos

MikroC PRO for PIC 7

2018-04-02T10:31:00.002-03:00

<br />
Esta é a nova versão do [MikroC PRO for PIC](https://www.mikroe.com/mikroc-pic). Contendo mais de 1000 funções em suas bibliotecas e suportando cerca de 800 microcontroladores PIC, é considerado um dos melhores compiladores existente no mercado.<br />
<br />
Obviamente que este maravilhoso compilador não sai de graça, e sugiro à aqueles que querem se profissionalizar no ramo, compre este software. É baratinho, apenas **U$249,00** rsrs.<br />
<br />
### Instalação<br />
1. Baixe e instale o executável clicando [aqui](https://download.mikroe.com/setups/compilers/mikroc/pic/mikroc-pic-setup-v720.zip);<br />
<br />
### Crackeando<br />
1. Baixe o crack clicando [aqui](https://rebrand.ly/mikroc-pro-pic-7-crack);<br />
2. Copie e cole o arquivo `HIDDongleDLL.dll` na pasta onde você instalou o MikroC. Irá aparecer uma janela de diálogo perguntando se você quer substituir o arquivo. Substitua-o;<br />
<br />
Pronto! Agora vocês podem se divertir sem aquela limitação de 2k de código!!!<br />

PIC: MCP4922

2018-03-11T10:55:00.000-03:00

[MCP4922](http://ww1.microchip.com/downloads/en/DeviceDoc/22250A.pdf) é um conversor digital-analógico (DAC) de 12-bits da Microchip.

### Características
* Tensão de operação: 2.7V até 5.5V;
* Comunicação via SPI;
* Resolução de 12-bits;
* 2 canais de saída;
* Ganho de saída (1x ou 2x);

### Funcionamento
O MCP4922 converte um valor digital de 12 bits em um valor de tensão de 0V até `VREF`. Ainda é possível ter um ganho de saída de `2 * VREF`. Cada canal possui um pino `VREF` externo.

O pino `SHDN` tem a finalidade de colocar ambos as saídas no modo *shutdown*. Também é possível configurá-los individualmente pelo registro de configuração. No modo *shutdown* a maioria dos circuitos internos são desligados e a saída é configurada para ter uma resistência de 500k.

O cálculo para a tensão de saída é: `((VREF * Valor) / 4096) * Ganho`.

Para definir o valor de um determinado canal:
* Definimos o pino `CS` com nível lógico baixo para habilitar a transmissão dos dados;
* Enviamos 16 bits:
![](https://www.dropbox.com/s/x2sgx9rbcyqxa2e/pic-mcp4922-write-command-register.png?dl=1)
   * O bit 15 seleciona o canal: `0` é o canal 0 e `1` é o canal 1;
   * O bit 13 indica o ganho de saída: `0` = ganho de 2x e `1` = não há ganho;
   * O bit 12 define se o canal selecionado será colocado no modo *shutdown*. `0` = modo shutdown e `1` = modo normal;
   * Os bit 11-0 sãos os 12 bits que definem o valor de saída do canal selecionado.
* Definimos o pino `CS` com nível lógico alto para finalizar a transmissão dos dados;

> Um projeto legal que poderíamos montar é um player de músicas no formato WAV (Mono ou Stereo) lidos de um SD Card.

### Download
[MCP4922.zip](http://bit.ly/2IjO33E)

### Código

PIC: TC1047A

2018-03-03T10:19:00.001-03:00

[TC1047A](http://ww1.microchip.com/downloads/en/DeviceDoc/21498D.pdf) é um sensor de temperatura.

### Características
* Tensão de operação: 2.5V até 5.5V;
* Acurácia de ±2°C;
* Faixa mensurável de temperatura: -40°C até 125°C;
* Baixo consumo de energia: 35uA.

### Funcionamento
O TC1047 converte o valor de temperatura em um valor de tensão linearmente proporcional. Cada 10mV corresponde a 1°C.

![](https://www.dropbox.com/s/bc2jxmy957gxlbn/pic-tc1047a-voltage-vs-temperature.png?dl=1)

Através do canal analógico do microcontrolador, iremos ler o valor digital da temperatura. Numa temperatura de -40°C o TC1047A tem uma tensão de saída de 0,1V. A 0°C o TC1047A tem uma tensão de saída de 0,5V e a 125°C tem uma tensão de saída de 1,75V.
Precisamos converter o valor lido do canal analógico em um valor de temperatura. Para isso vamos converter o valor lido em um valor de tensão. No caso de um microcontrolador com um ADC de 10 bits, o valor de tensão (em mV) será: `ADC * 5000 / 1024`. Ainda temos que subtrair `500`mV (pois a 0°C a tensão de saída é 0,5V). Como a resolução da tensão de saída é de 10mV/°C, temos que dividir tudo por `10`. Então nossa fórmula fica assim: `ADC * 500 / 1024 - 50`.

### Download
[TC1047A.zip](http://bit.ly/2GfTz6J)

### Código
<div data-gist="https://gist.github.com/tiagohm/4d1418020960e1707e214187bee5b214">
</div>

PIC: AD5206

2018-02-28T20:42:00.000-03:00

[AD5206](http://www.analog.com/media/en/technical-documentation/data-sheets/AD5204_5206.pdf) é um potenciômetro digital de 6 canais.

### Características
* Comunicação via SPI;
* 256 posições;
* Tensão de operação: 2.7V à 5.5V;

### Funcionamento

O AD5206 possui 6 canais. Cada canal contém um potênciômetro de 10k, 50k ou 100k. Cada potênciômetro possui três terminais: 2 fixos representados pelas letras `A` e `B` e um móvel representado pela letra `W`.

Para definir o valor do potenciômetro de um determinado canal, devemos enviar pelo menos 11 bits via comunicação SPI. Se mais de 11 bits forem enviados, somente os últimos 11 bits serão utilizados.

![](https://www.dropbox.com/s/db2ix2bjj4qi9f2/pic-ad5206-serial-data-word-format.png?dl=1)

* Os três bits mais significativos definem o endereço de um canal (de 0 à 5);
* Os 8 bits menos significativos definem o valor do potenciômetro (de 0 à 255).

Antes de iniciar a transmissão dos dados é necessário colocar o pino `CS` em nível lógico baixo e logo após o fim da transmissão, colocar em nível lógico alto, assim os 11 bits enviados serão armazenados num registrador interno e usados por um decodificador para selecionar o canal e definir o valor do potenciômetro.

### Download
[AD5206.zip](http://bit.ly/2Hrf0B7)

### Código
<div data-gist="https://gist.github.com/tiagohm/e6eff6aa1b080218de99678326c28cd3">
</div>

PIC: TH02

2018-02-25T18:29:00.001-03:00

[TH02](http://www.hoperf.com/upload/sensor/TH02_V1.1.pdf) é um sensor de temperatura e umidade.

![](https://www.dropbox.com/s/uerpkju4cmkcqkf/pic-th02-real.png?dl=1)

Apesar de ser desconhecido para mim, ele aparenta ser um excelente sensor. Baixo consumo de energia, rapidez na medição e boa resolução são os pontos destacáveis desse dispositivo.

### Características

* Tensão de operação: 2.1V à 3.6V;
* Comunicação via I2C;
* Acurácia de 0.5°C para temperatura e 4.5% para umidade;
* Faixa de operação: -40°C à 85°C e 0% - 100%;
* Baixo consumo de energia: 240uA à 320uA durante a conversão;
* Resolução de 14 ou 13 bits para temperatura;
* Resolução de 12 ou 11 bits para umidade;
* Tempo de conversão: 35ms no modo normal e 18ms no modo rápido.

### Funcionamento

O TH02 possui um registro de configuração `CONFIG` (0x03) na qual utilizamos para definir se estamos querendo ler a temperatura ou a umidade (`TEMP`), selecionar a velocidade da conversão (`FAST`) e iniciar a conversão (`START`).

![](https://www.dropbox.com/s/0nshs6vjx9z2siz/pic-th02-config-register.png?dl=1)

O bit `FAST` reduz o tempo de conversão de 35ms para 18ms e o consumo de energia. Além disso reduz a resolução da medição.

![](https://www.dropbox.com/s/tnpi9lkj2wt8wke/pic-th02-fast-conversion-mode.png?dl=1)

Então sempre que quisermos realizar uma leitura de temperatura ou umidade, devemos escrever no registro `CONFIG`.

Os valores de temperatura e umidade se encontram nos registros `DATAH` (0x01) e `DATAL` (0x02).

![](https://www.dropbox.com/s/lodm65682v1chtm/pic-th02-temp-register.png?dl=1)

![](https://www.dropbox.com/s/pmgembesbcgtjz4/pic-th02-humidity-register.png?dl=1)

A sequência para iniciar a conversão e ler os valores é:
* Iniciar a transmissão (pulso de START);
* Enviar o endereço do dispositivo (0x80) + modo de escrita (0);
* Enviar o endereço do registro `CONFIG`;
* Enviar o valor do registro `CONFIG`: Ler temperatura ou umidade, modo rápido ou normal, iniciar a conversão;
* Encerrar a transmissão (pulso de STOP);
* Aguardar o fim da conversão;
* Iniciar a transmissão (pulso de START);
* Enviar o endereço do dispositivo (0x80) + modo de escrita (0);
* Enviar o endereço do registro `DATAH`;
* Encerrar a transmissão (pulso de STOP);
* Iniciar a transmissão (pulso de START);
* Enviar o endereço do dispositivo (0x80) + modo de leitura (1);
* Ler os dois bytes (MSB e LSB);
* Encerrar a transmissão (pulso de STOP);

### Download
[TH02.zip](http://bit.ly/2tEVbo6)

### Código

PIC: PCF8591

2018-02-21T22:14:00.000-03:00

[PCF8591](https://www.nxp.com/docs/en/data-sheet/PCF8591.pdf) é tanto um conversor analógico-digital (ADC) quanto um conversor digital-analógico (DAC).

Possui 3 pinos (A0, A1, A2) responsáveis pelo seu endereçamento no barramento I2C, permitindo conectar até 8 dispositivos.

### Pinagem

![](https://www.dropbox.com/s/tyk4ey5q1wdm9tj/pic-pcf8591-pinagem.png?dl=1)

* AIN0-AIN3: São as entradas analógicas;
* A0-A2: Pinos de endereçamento;
* AOUT: É a saída anlógica;
* VREF: Tensão de referência das entradas e saídas analógicas;
* AGND: Terra das entradas e saídas analógicas.

### Características

* Tensão de operação: 2.5V à 6V;
* Comunicação via I2C;
* Entradas analógicas configuráveis;
* Resolução de 8 bits.
* 4 entradas analógicas;

### Funcionamento

O primeiro byte enviado para o dispositivo é o byte de endereço.

![](https://www.dropbox.com/s/74czoszxj3pa0ui/pic-pc8591-address-byte.png?dl=1)

O segundo byte enviado para o dispositivo é responsável por habilitar a saída analógica, configurar as entrada analógicas e selecionar o canal analógico.

![](https://www.dropbox.com/s/zn45gv3zfekno3f/pic-pcf8591-control-byte.png?dl=1)

* Bit 0-1: Seleciona os canais analógicos de 0 a 3;
* Bit 2: Se for igual à `1`, o número do canal analógico é incrementado automaticamente após cada conversão AD. Em toda a leitura o canal selecionado será o canal 0;
* Bit 4-5: Define o modo de configuração das entradas analógicas. Veja a figura acima;
* Bit 6: Habilita com `1` a saída analógica.

O terceiro byte enviado, quando quiser usar o DAC, é armazenado no registro do conversor digital-analógico (DAC) e é convertido para o valor correspondende de tensão. O DAC nada mais é do que uma série de resistores formando vários divisores de tensão de até 256 níveis.

A fórmula para o cálculo da tensão de saída é `AGND + ((VREF - AGND) / 256) * valor armazenado no DAC`.

> O Datasheet indica um erro de compensação de 50mv.

### Download
[PCF8591.zip](http://bit.ly/2Il2T9R)

### Código

PIC: MCP3201

2015-06-06T20:57:00.000-03:00

PIC: DS1631

2015-04-26T17:29:00.000-03:00

[DS1631](https://datasheets.maximintegrated.com/en/ds/DS1631-DS1731.pdf) é um termômetro/termostato digital que realiza a leitura de temperaturas entre -55°C e 125°C com resolução ajustável de 9, 10, 11 ou 12 bits.

A comunicação é feita através da inteface I2C.

### Características
* Acurácia de ±0.5°C;
* Tensão de alimentação: 3V a 5,5V;
* Baixo consumo de energia.

### Registros
Possui 4 registros, `TH` e `TL` (ambos 2 bytes) usados no modo Termostato, o registro `T` (2 bytes) usado no modo Termômetro e o registro de Configuração `CONFIG` (1 byte).

Os registros `TH`, `TL` e `T` são formados pelos seguintes bits:
![](https://www.dropbox.com/s/wtvt1sxe3z7z1it/pic-ds1631-temperature-registers.png?dl=1)

### Modo Termômetro
Por meio de um conversor analógico Delta-Sigma coverte a temperatura num valor digital de 9, 10, 11 ou 12 bits, configurados pelos bits `R0` e `R1` do registro de `CONFIG`. A conversão demora um certo tempo dependendo da resolução, veja a tabela abaixo:

###### bits de resolução e tempo de conversão
![](https://www.dropbox.com/s/8hcsx2eths4xixj/pic-ds1631-bits-resolucao.png?dl=1)

O DS1631 inicia em *stand-by* (modo de baixo consumo), e através de um comando enviado, realiza a conversão da temperatura em modo *contínuo* ou *one-shot*.

No modo *one-shot* a conversão da temperatura é feita sempre que recebe o comando `START CONVERT`.

No modo *contínuo* a conversão é realiza continuamente. É necessário enviar `START CONVERT` pelo menos uma vez só pra dar aquele empurrão inicial.

Podemos configurá-los através do bit `ONE-SHOT` do registro `CONFIG`. Setando com `1` estaremos definindo com o modo *one-shot* e com `0` para o modo *contínuo*.

Para encerrar a conversão usamos o comando `STOP CONVERT`. Isto faz com que entre no modo *stand-by*. Isto é útil quando está no modo *contínuo* e não queremos mais ler o valor de temperatura, fazendo o dispositivo economizar em energia. No modo *one-shot* não é necessário enviar este comando, pois após a conversão automaticamente o dispositivo entra em *stand-by*.

Para ler a temperatura use o comando `READ TEMPERATURE`.

### Modo Termostato
No modo termostato temos dois registros, `TH` e `TL`, que são usados para armazenar os dois valores de temperatura. Quando a temperatura ultrapassar o valor de `TH` o pino `TOUT` é `ativado`. O pino `TOUT` permanece ativado até que a temperatura caia e fique abaixo de `TL`.

Podemos configurar se o pino `TOUT` será ativado com nível lógico `alto` ou `baixo`, através do bit `POL` do registro `CONFIG`. Defina com `1` para ativá-lo com nivel lógico `alto`.

### Endereçamento
O DS1631 possui três pinos `A0`, `A1` e `A2` responsáveis por alterar seu endereço no barramento.

O bit `0` define se nós iremos ler(1) ou escrever(0) no dispositivo.

O endereço é composto por:
![](https://www.dropbox.com/s/yl16shd45db1zw4/pic-ds1631-endereco.png?dl=1)

### Biblioteca

AVR: Display 7 Segmentos

2015-03-30T11:24:00.000-03:00

Mais um projeto envolvendo o ATMEGA328P. Desta vez iremos criar um simples contador de 0 até 99 acionado por um botão.

O projeto utiliza um display de 7 segmentos de 2 dígitos com catodo comum (cada segmento tem em comum um pino GND, são os pinos 1 e 2, um para cada dígito). Um segmento é aceso quando aplicamos uma corrente em seu pino de entrada (pinos A ao G).

Se vocês perceberam, não dá pra exibir dois números ao mesmo tempo, já que compartilham os mesmos pinos de entrada. Por isso precisamos intercalar a exibição de um dígito. Nós setamos os pinos de entrada para que possa exibir algo e habilitamos o primeiro dígito e desabilitamos o segundo digito. Algum tempo depois, nós setamos os pinos de entrada para o segundo dígito e desabilitamos o primeiro e habilitamos o segundo dígito. E o ciclo se repete. Todo o tempo de transição de um digito para o outro deve ser feito de modo que nossos olhos não perceba essa mudança.

### Código

AVR: Pull-ups

2015-03-26T21:07:00.001-03:00

Pisca-Pisca com ATMEGA328P

2015-03-23T10:15:00.000-03:00

AVR: Pisca-Pisca com ATMEGA328P

Olá de novo! Está começando a série de projetos com AVR.

Este primeiro projeto será de um pisca-pisca com o microcontrolador ATMEGA328P ( o mesmo utilizado no Arduino Uno ).

Precisamos ter um conhecimento básico sobre pinos I/O, então, clique aqui.

Para criar um simples pisca-pisca, não tem nenhum segredo né! Precisamos apenas de um resistor de 220Ohms e um LED. A conexão é vista na imagem acima.

Neste primeiro exemplo utilizamos o método trivial para fazer o led piscar. Dentro de um loop infinito, ligamos e desligamos o led num intervalo de 500ms.

Outro jeito de fazer o led piscar é utilizar o operador de complemento "~".

Também podemos assim: Quando escrevemos 1 num determinado bit do registro PINB, estamos alternando o valor do bit correspondente do registro PORTB.

またね、バイバイ

PIC: 25XX320

2015-01-05T13:09:00.001-02:00

[25XX320](http://ww1.microchip.com/downloads/en/DeviceDoc/21227E.pdf) corresponde as memórias eeprom's (25AA320, 25LC320, 25C320) de 32Kb da Microchip. Comunica-se via SPI, utilizando apenas 4 fios (CLK, SDO, SDI, CS).

### Características
* Tensão de alimentação: 5V;
* 4096 x 8 bit;
* Tempo de escrita: 5ms;
* Proteção de memória;

### Funcionamento

![](https://www.dropbox.com/s/3m2kgi7d7xm27c2/pic-25x320-sequence.png?dl=1)

Para realizar a escrita:
1. Habilitar o dispositivo (CS = 0);
2. Enviar a instrução de escrita;
3. Enviar um endereço de 16 bits. Enviar os 8 bits mais significativos, depois os 8 bits menos significativos.
4. Enviar o dado (1 byte) que será gravado no endereço.
5. Desabilitar o dispositivo (CS = 1);

> Antes de cada operação de escrita é necessário enviar o comando que dá a permição de escrita e após a operação de escrita é necessário enviar o comando que revoga a permissão de escrita.

Para realizar a leitura:
1. Habilitar o dispositivo (CS = 0);
2. Enviar a instrução de leitura;
3. Enviar um endereço de 16 bits. Enviar os 8 bits mais significativos, depois os 8 bits menos significativos.
4. Realizar a leitura de 1 byte do endereço.
5. Desabilitar o dispositivo (CS = 1);

O dispositivo possui o seguinte registro de `STATUS`:

![](https://www.dropbox.com/s/s5cfg1wy9s5erl5/pic-25x320-status-register.png?dl=1)

`WPEN`: Habilita/Desabilita a proteção de escrita. Trabalha em conjunto com o pino externo WP. Para mais detalhes, veja a tabela 3-3 do datasheet.  
`BP1-BP0`: Protege um bloco de memória. 00 - nenhum bloco está protegido; 01 - 0x0C00 até 0x0FFF está protegido; 10 - 0x0800 até 0x0FFF está protegido. 11 - todos os blocos estão protegidos.  
`WEL`: Indica se está autorizado a realizar uma operação de escrita.  
`WIP`: Indica se está ocorrendo uma operação de escrita.

### Biblioteca

PIC: RDA5807

2014-12-30T11:17:00.002-02:00

PIC: RDA5807

RDA5807P é um circuito integrado que é capaz de sintonizar emissoras de rádio FM, operando na faixa de 76MHz até 108MHz.

CARACTERÍSTICAS

Duas bandas de frequência;
Mono ou Stereo;
Indicador de força do sinal ( RSSI );
Controle de volume;
Comunicação I2C;
Tensão de alimentação: 5V;

VANTAGENS

Este chip possui as mesmas características do TEA5767. A vantagem de utilizá-lo é que eu encontrei uma placa pronta para utilizar, precisando apenas conectar os fios, ao contrário do TEA5767 ( talvez exista um módulo para ele, mas não encontrei ) que precisa soldar os fios e correr o risco de destruir a plaquinha ( acabei arrancando uns componentes, rs ). Outra vantagem do RDA5807P é que é possível controlar o volume da saída, mesmo utilizando fones de ouvido, o som é muito alto.

FUNCIONAMENTO

Possui 4 registradores internos de 16 bits, utilizados para sua configuração, como a frequência atual, volume, seleção da banda, ativar o modo de busca, entre outros. Para realizar a operação de escrita, basta enviar o endereço do dispositivo ( 0x20 ) e os 8 bytes.

Para poder sintonizar uma frequência, devemos escrever nos bits CHAN, setar o bit TUNE e enviar os todos os bytes. Podemos calcular o valor da frequência através dessa fórmula: F = SPACE * CHAN + ( 87000 ou 76000 );

Para realizar uma busca, devemos definir a direção da busca ( pra cima ou pra baixo ) definindo um valor para o bit SEEKUP. Também devemos setar o bit SEEK e enviar todos os bytes.

Também possui 2 registradores de 16 bits, que são utilizados para leitura, informando a frequência atual, a força do sinal captado e contendo vários bits de sinalização.

CÓDIGO DA BIBLIOTECA

MikroC PRO PIC

EXEMPLO:

PIC: SSD1306

2014-12-26T20:45:00.000-02:00

PIC: SSD1306

SSD1306 é um controlador para display OLED. Este display pode ser encontrado no Mercado Livre, possui uma resolução de 128x64 pixels e tem o mesmo tamanho de uma moeda de 1 real.

Comunica-se através do barramento I2C, por isso utiliza apenas dois fios ( Clock e Data ).

CARACTERÍSTICAS

Resolução de 128x64 pixels;
Tensão de alimentação: 3.3V ou 5V ( O display que eu comprei no Mercado Livre suporta esta tensão. Verifique se o seu display também suporta ).
Contraste ajustável;

FUNCIONAMENTO

A interface I2C com o display consiste no envio de um endereço ( 0b011110XY ), na qual o bit X corresponde ao endereço do display ( 0 ou 1 ). Na parte de trás do display há um jumper com um pingo de solda, selecionando por padrão o endereço 0. Com isso, você é capaz de ligar até dois displays no mesmo barramento. O bit Y informa se a operação será de escrita(0) ou leitura(1). Após isso, é necessário enviar no mínimo dois bytes ( um de comando e outro de dado ). O byte de comando ( 0bXY000000 ) é composto pelo bit X que, uma vez setado, você poderá enviar n dados na sequência. O bit Y quando for igual a 1, diz que o próximo dado corresponde a um comando interno do display. Quando for igual à 0, diz que o próximo dado corresponde a uma carácter, por exemplo, que é gravado na GDDRAM ( memoria utilizada pelo display para exibir as informações na tela ).

CÓDIGO DA BIBLIOTECA

MikroC PRO PIC

EXEMPLO

MikroC PRO PIC

PIC: PCF8583

2014-11-03T10:09:00.004-02:00

PIC: PCF8583

O PCF8583 é um relógio/calendário e alarme digital da NXP Semiconductors com uma memória RAM de 256 x 8 bits, que controlado através de um microcontrolador, fornece data e hora em tempo real.

Utiliza o barramento I2C. Possui endereçamento selecionável através do pino A0, podendo assim, ligar até dois relógios no mesmo barramento.

O PCF8583 fornece informações do ano, mês, dia e dia da semana, hora, minuto, segundo e centissegundo. Todos no formato BCD.

O endereço 0x00 é usado como um registro de controle e status. Os endereços de 0x01 até 0x07 são usados como contador para a função relógio. Os endereços de 0x08 até 0x0F podem ser programados como registro do alarme ou utilizado como memória RAM livre, quando o alarme está desativado.

CARACTERÍSTICAS

Barramento I2C;
Tensão de alimentação de 1.0V à 6.0V. Isso permite adicionar uma pequena bateria de backup de 3V no caso de ocorrer uma falha de energia;
Memória RAM de 256 x 8 bits;
Função relógio com 4 anos ( incluindo ano bissexto );
Formato de horas: 24h ou 12h ( AM/PM );
Alarme e Timer com interrupção programável.

REGISTRO DE CONTROLE E STATUS

Este registro contém as flags de interrupção do alarme e do timer, que são os bit 1 e 0, respectivamente. O bit 7 quando setado pausa o relógio. Os bits 5 e 4 configuram o clock. O bit 3 funciona como uma chave para habilitar/desabilitar todas as interrupções.

REGISTRO DE CONTROLE DO ALARME

Este registro contém a configuração de contagem do timer ( bits 2, 1 e 0 ). O bit 3 é usado para habilitar/desabilitar a interrupção do timer. Os bits 5 e 4 configuram o modo do alarme e o bit 7 habilita/desabilita a interrupção do alarme.

MODO ALARME

No modo alarme você define a hora para ele disparar. Quando a hora atual e a hora do alarme forem iguais uma interrupção será gerada, e a flag será setado. Esta flag deverá ser limpa via software. Para configurar como alarme você deve:

Definir a hora do alarme ( endereços 0x09 até 0x0E )
Configurar o modo do alarme ( bits 5 e 4 do registro de controle do alarme )
Habilitar a interrupção do alarme ( bit 7 do registro de controle do alarme )

MODO TIMER

No modo timer você define um tempo para ele disparar. Esse tempo pode ser incrementado de segundos em segundos, ou minutos ou horas ou dias, configurando os bits 2, 1 e 0 do registro de controle do alarme. A contagem inicia a partir do valor definido pelo usuário até 99. Após isso ocorrerá um estouro, retornando a contagem para 0 e gerando uma interrupção. A flag também será setado. Esta flag deverá ser limpa via software, assim como o valor do timer. Para configurar o timer você deve:

Definir um valor inicial do timer ( endereço 0x0F )
Configurar o modo de contagem ( bits 2, 1 e 0 do registro de controle do alarme )
Habilitar a interrupção do timer ( bit 3 do registro de controle do alarme )

BIBLIOTECA

MikroC PRO PIC

EXEMPLO

MikroC PRO PIC

TUTORIAL: Ellipsis

2014-10-18T12:00:00.002-03:00

PIC: MCP41XXX

2014-10-17T22:23:00.002-03:00

Arduino Uno para Proteus

2014-10-14T13:24:00.004-03:00

ARDUINO UNO PARA O PROTEUS

Esta é a nova versão do simulador de Arduino Uno R3 para o Proteus. Nessa nova versão modifiquei o design para ficar mais bonito, deixando seus novos projetos mais atraentes.

INSTALAÇÃO
Copie o arquivo ARDUINO.LIB para a pasta:
C:\Arquivos de Programas\Labcenter Electronics\Proteus 8 Professional\LIBRARY ou C:\ProgramData\Labcenter Electronics\Proteus 8 Professional\LIBRARY.

DOWNLOAD

Biblioteca Arduino para Proteus : Arduino.lib

PIC: LCD com Menus

2014-07-12T21:45:00.000-03:00

PIC: LCD com Menus

Como foi me pedido, neste post irei explicar como criar um menu, bem sofisticado, para um display de LCD.

Nesse menu, cada item pode conter um submenu, cada submenu pode conter outro submenu, e assim por diante, infinitamente( até acabar a memória ). Cada item pode também executar uma rotina ao ser selecionado.

Primeiramente cria-se um registro que irá armazenar as informações de cada item:

struct MenuItem
{
        const Item** mItem;     //SubMenu
        char Texto[16];         //texto
        void(*Tarefa)(char);    //Funcao a ser executada
        char Parms;             //valor do parametro da funcao
};

Depois criamos os items...

const  Item Menu01 = { Screen1, "FUNCAO 1", &SuaFuncao, 0 };
const  Item Menu02 = { Screen2, "FUNCAO 2", NULL, 0 };

Screen1 - é o vetor de itens do submenu. Se não possui um submenu colocar 0.

"FUNCAO 1" - É o texto do item a ser exibido.

&SuaFuncao - É o endereço da função a ser executada pelo item ao ser selecionado. Se não tiver, colocar 0.

0 - é o valor do parâmetro a ser passado para a função dita anteriormente.

e um vetor que armazena os itens da primeira tela a ser exibida.

//Terminar sempre com 0(Zero).
const Item* TelaInicial[] = { &Menu01, &Menu02, 0 };

Criamos tambem os itens de uma segunda, terceira, ... , tela:

const Item Menu10 = { Screen3, "Outra Funcao", 0, 0 };
const Item Menu11 = { NULL, "Ativar Saidas", &DefinirSaidas, 255 };
const Item Menu12 = { NULL, "Alternar Saidas", &AlternarSaidas, 0 };
const Item Menu13 = { NULL, "Desligar Saidas", &DefinirSaidas, 0 };
const Item* Screen1[] ={ &Menu10, &Menu11, &Menu12, &Menu13, 0 };

Esse código é mais fácil no sentido de poder acrescentar quantos itens e subitens quiser, sem ter que adicionar mais instruções "if", "else", "switch", etc, deixando o código mais limpo. Por outro lado, é necessário um conhecimento sobre o uso de estruturas( struct ) e ponteiros. Vocês podem ficar espantados ao ver tanto asterisco, como nesse trecho do código "static const Item*** MenuAnterior". Para quem quiser entender, irei explicar:
Com Apenas um asterisco: Item* - É um simples ponteiro para um struct Item.
Com dois asterisco: Item** - É um vetor de *Item.
Com três asterisco: Item*** - É um vetor de **Item. ( ou matriz de *Item ).

CÓDIGO:

/*
  PROJETO: LCD com MENUS
  MCU: PIC18F4550
  CLOCK: 48MHz ( 20MHz + PLL )
  COMPILADOR: MIKROC PRO PIC
  AUTOR: Tiago Henrique
*/

#define NULL 0

//PINOS DO LCD
sbit LCD_RS at RB0_bit;
sbit LCD_EN at RB1_bit;
sbit LCD_D4 at RB2_bit;
sbit LCD_D5 at RB3_bit;
sbit LCD_D6 at RB4_bit;
sbit LCD_D7 at RB5_bit;

sbit LCD_RS_Direction at TRISB0_bit;
sbit LCD_EN_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB4_bit;
sbit LCD_D7_Direction at TRISB5_bit;


/*
       PROTOTIPOS
*/
typedef struct MenuItem Item;
static void LcdWriteFromROM( const char* texto );
//Suas Funcoes
void DefinirSaidas( char );
void AlternarSaidas( char );



struct MenuItem
{
        const Item** mItem;     //submenu
        char Texto[16];         //texto
        void(*Tarefa)(char);    //Funcao a ser executada
        char Parms;             //valor do parametro da funcao
};

/*
       VARIAVEIS GLOBAIS
*/
static char selecao = 0;        //posicao do item selecionado
static const Item** MenuAtual;  //Menu Atual
static const Item*** MenuAnterior; //Pilha de Menus
static unsigned Stack[16];      //Aloca memoria para a pilha



/*
       MENU
*/

//Terceiro Nivel
const Item Menu30 = { NULL, "PORTD = 32", &DefinirSaidas, 32 };
const Item* Screen3[] = { &Menu30, 0 }; //Terminar sempre com o valor 0(NULO)

//Segundo Nivel
const  Item Menu10 = { Screen3, "Outra Funcao", 0, 0 };
const  Item Menu11 = { NULL, "Ativar Saidas", &DefinirSaidas, 255 };
const  Item Menu12 = { NULL, "Alternar Saidas", &AlternarSaidas, 0 };
const  Item Menu13 = { NULL, "Desligar Saidas", &DefinirSaidas, 0 };
const Item* Screen1[] = { &Menu10, &Menu11, &Menu12, &Menu13, 0 };  //Terminar sempre com o valor 0(NULO)

const  Item Menu20 = { NULL, "PORTD = 1", &DefinirSaidas, 1 };
const  Item Menu21 = { NULL, "PORTD = 2", &DefinirSaidas, 2 };
const  Item Menu22 = { NULL, "PORTD = 4", &DefinirSaidas, 4 };
const  Item Menu23 = { NULL, "PORTD = 8", &DefinirSaidas, 8 };
const Item* Screen2[] = { &Menu20, &Menu21, &Menu22, &Menu23, 0 }; //Terminar sempre com o valor 0(NULO)

//Primeiro Nivel
const  Item Menu01 = { Screen1, "FUNCAO 1", NULL, 0 };
const  Item Menu02 = { Screen2, "FUNCAO 2", NULL, 0 };
const Item* TelaInicial[] = { &Menu01, &Menu02, 0 }; //Terminar sempre com o valor 0(NULO)




/*
      Exibe os items do menu atual no display LCD
*/
static char MostrarItens( const Item* menu[], char sel )
{
char index = 0, row = 1;

     Lcd_Cmd( _LCD_CLEAR );

     if( menu == 0 )
         return 0;

     while( menu[index] )
     {
             if( index < sel ) { index++; continue; }
             if( index == sel ) Lcd_Chr( row, 1, '>' );
             else Lcd_Chr( row, 1, ' ' );
             row++;
             LcdWriteFromROM( menu[index++]->Texto );
     }

     if( index <= sel )
         return 1;
     return 0;
}

static void LcdWriteFromROM( const char* texto )
{
    while( *texto )
    {
           Lcd_Chr_CP( *texto++ );
    }
}



void main()
{
char flags = 0; //flags dos botoes

    CMCON = 7;
    ADCON1 = 15;
    //Botoes
    TRISA.B0 = 1;
    TRISA.B1 = 1;
    TRISA.B2 = 1;
    TRISD = 0;
    PORTD = 0;
    
    Lcd_Init();
    Lcd_Cmd( _LCD_CURSOR_OFF );

    MenuAtual = TelaInicial; //A tela atual = tela inicial
    MenuAnterior = &Stack;   //Aponta para a pilha
    
    MostrarItens( MenuAtual, selecao ); //Exibe os itens

    while( 1 )
    {
         if( PORTA.B0 ) flags.B0 = 1;
         else if( PORTA.B1 ) flags.B1 = 1;
         else if( PORTA.B2 ) flags.B2 = 1;

         //Botao Proximo foi pressionado
         if( !PORTA.B0 && flags.B0 )
         {
             ++selecao; //seleciona o proximo item
             //Exibe os itens da tela selecionada e
             //se o indice do item estourar
             //retorna para o primeiro item
             if( MostrarItens( MenuAtual, selecao ).B0 )
             {
                  selecao = 0;
                  MostrarItens( MenuAtual, selecao );
             }
             flags.B0 = 0;
         }
         
         //Botao Enter foi pressionado
         if( !PORTA.B1 && flags.B1 )
         {
             //Recebe o ponteiro da funcao a ser executada
             void(*Func)(char) = MenuAtual[selecao]->Tarefa;
             

             //Caso exista uma funcao a ser executada...
             if( Func != NULL )
             {
                 //Executa a função
                 Func( MenuAtual[selecao]->Parms );
             }

             //Se existir um submenu
             if( MenuAtual[selecao]->mItem != NULL )
             {
                 //Salva o menu atual no MenuAnteror
                 *MenuAnterior++ = MenuAtual;
                 //atualiza o menu atual com o proximo menu
                 MenuAtual = MenuAtual[selecao]->mItem;
                 //Exibe os itens deste proximo menu
                 selecao = 0;
                 MostrarItens( MenuAtual, selecao );
             }
             
             flags.B1 = 0;
         }
         
         //Botao Voltar foi pressionado
         if( !PORTA.B2 && flags.B2 )
         {
              selecao = 0;
              //Se não for o primeiro menu( Tela Inicial )
              if( ((unsigned*)&MenuAnterior)[0] > (unsigned)&Stack )
              {
                 //MenuAtual recebe o menu salvo no MenuAnterior
                 MenuAtual = *--MenuAnterior;
                 MostrarItens( MenuAtual, selecao );
              }
              flags.B2 = 0;
         }
    }

}

//Suas Funcoes

void DefinirSaidas( char valor )
{
    PORTD = valor;
}

void AlternarSaidas( char valor )
{
     PORTD = ~PORTD;
}

DOWNLOAD:
Projeto: LCD_com_menus.rar

O código pode ser um pouco difícil de entender, então, qualquer dúvida é só perguntar. Até mais!!!!

Livros Sobre Programação

2014-07-10T10:46:00.000-03:00

Livros Sobre Programação

Quem quer aprender mais sobre programação, disponibilizo vários links de livros em pdf. São várias as linguagens de programação, desenvolvimento de aplicativos Mobile, programação Web e programação orientada à objetos. Também vou estar disponibilizando outros livros relacionadas à computação, pois irá ajudar muito para aqueles que estão cursando Ciência da Computação...Se você gostou de algum livro, sugiro que comprem, pois assim, estarão ajudando seus desenvolvedores.

USE A CABEÇA - C# - DOWNLOAD

USE A CABEÇA - AJAX - DOWNLOAD

USE A CABEÇA - HTML com CSS - DOWNLOAD

USE A CABEÇA - JAVA - DOWNLOAD

USE A CABEÇA - JAVASCRIPT - DOWNLOAD

USE A CABEÇA - PADRÕES DE PROJETO - DOWNLOAD

USE A CABEÇA - PHP - DOWNLOAD

USE A CABEÇA - RAILS - DOWNLOAD

USE A CABEÇA - SQL - DOWNLOAD

DESENVOLVENDO APLICATIVOS MOBILE - ANDROID - DOWNLOAD

ORGANIZAÇÃO ESTRUTURA DE COMPUTADORES - DOWNLOAD

GOOGLE ANDROID - DOWNLOAD

APLICATIVOS WEB PRO ANDROID - DOWNLOAD

PROGRAMMING ANDROID ( Inglês ) - DOWNLOAD

NOVOS

DESENVOLVA JOGOS COM HTML5 e JAVASCRIPT - DOWNLOAD

DOMINANDO JAVASCRIPT COM JQUERY - DOWNLOAD

JAVA 8 PRÁTICO - DOWNLOAD

COMPILADORES, PRINCÍPIOS, TÉCNICAS E FERRAMENTAS - DOWNLOAD

JAVA - COMO PROGRAMAR - 8ª EDIÇÃO - DOWNLOAD

LÓGICA DE PROGRAMAÇÃO - DOWNLOAD

PROGRAMANDO EM C/C++ - A BÍBLIA - DOWNLOAD

ALGORITMOS - TEORIA E PRÁTICA - DOWNLOAD

PIC: Sensor PIR

2014-06-21T13:54:00.000-03:00

PIC: SENSOR PIR

Sensor PIR ( Passive Infra-Red ) são usados para detectar movimentos, através da radiação infravermelha liberada por uma pessoa. Podemos ligar este sensor para acender uma lâmpada, acionar portas, portões, sirenes, etc.

Este módulo possui um ajuste de sensibilidade, podendo aumentar ou diminuir o alcance do sensor( 3 a 7 metros ). Também possui um ajuste do tempo que a saída permanecerá acionada ( nível alto ), variando de 5 a 200 segundos. Estes ajustes são feitos através de dois potenciômetros:

Quando o sensor detecta a presença de alguém, a saída ( OUTPUT ) ficará em nível lógico alto. Após um determinado tempo ( ajustado pelo potenciômetro ) ele voltará para o estado lógico baixo.

EXEMPLO

MikroC PRO PIC

//PROJETO: SENSOR DE MOVIMENTO
//MCU: PIC12F675
//CLOCK: 4MHz INTOSC
//COMPILADOR: MikroC PRO PIC
// Habilitar a seguinte biblioteca:
// - Sound

sbit Sensor at GPIO.B2;

void main()
{
    ANSEL = 0; //desabilita o canal analogico
    CMCON = 0; //desabilita o comparador analogico
    TRISIO.B2 = 1; //define o pino GP2 como entrada
    
    Sound_Init( &GPIO, 0 );

    while(1)
    {
        if( Sensor )
        {
            Sound_Play( 1500, 200 ); //toca um som relaxante
            Delay_ms( 400 );
        }
    }
}

PIC: TEA5767

2014-06-20T17:00:00.000-03:00

PIC: TEA5767

Dessa vez, iremos montar um rádio FM digital, utilizando o módulo TEA5767.

O circuito integrado TEA5767 é um rádio FM estéreo em um único chip. Possui um baixo consumo de energia e não requer nenhum tipo de ajuste no circuito. Sintoniza bandas FM Japonesas( 76 - 91 MHz ) ou Europeias ( 87.5 - 108 MHz ). Comunica-se com o microcontrolador através de um barramento I2C.

O módulo possui 10 pinos. O pino BUS MODE quando em nível baixo habilita a comunicação via I2C. Para habilitar a comunicação 3-Wire apenas coloque o pino em nível alto. Os pinos SDA ( dados ) e SCL ( clock ) são os pinos da interface I2C. É alimentado com tensão entre 2.5V até 5V. Possui duas saídas para o áudio estéreo ( LEFT e RIGHT ). O pino 10 é para a ligação de uma antena.

BIBLIOTECA

MikroC PRO PIC

#define TEA5767_ADDRESS 0xC0

static char WriteBytes[5] = { 0x00, 0x00, 0xD0, 0x10, 0x00 };

struct
{
    union
    {
        char FREQUENCIA_H : 6;
        char SEARCH_MODE : 1;
        char MUTE : 1;
    };

    char FREQUENCIA_L;

    union
    {
        char SWP1 : 1;
        char MUTE_LEFT : 1;
        char MUTE_RIGHT : 1;
        char MONO_TO_STEREO : 1;
        char HLSI : 1;
        char SEARCH_STOP_LEVEL : 2;
        char SEARCH_UP_DOWN : 1;
    };

    union
    {
        char : 5;
        char BAND_LIMIT : 1;  //1 = Japan FM Band, 0 = US/Europe FM Band
        char STANDY_BY_ON : 1;
        char SWP2 : 1;
    };

} TEA5767 at WriteBytes;

void TEA5767_Write()
{
    Soft_I2C_Start();
    Soft_I2C_Write( TEA5767_ADDRESS );
    Soft_I2C_Write( WriteBytes[0] );
    Soft_I2C_Write( WriteBytes[1] );
    Soft_I2C_Write( WriteBytes[2] );
    Soft_I2C_Write( WriteBytes[3] );
    Soft_I2C_Write( WriteBytes[4] );
    Soft_I2C_Stop();
}

void TEA5767_Read( unsigned long *freq_hz, char *flags, char *sinal )
{
unsigned long Freq_Tmp = 0;
char ReadBytes[5];

    //Faz a leitura de 4 bytes
    Soft_I2C_Start();
    Soft_I2C_Write( TEA5767_ADDRESS | 1 );
    ReadBytes[0] = Soft_I2C_Read( 1 );
    ReadBytes[1] = Soft_I2C_Read( 1 );
    ReadBytes[2] = Soft_I2C_Read( 1 );
    ReadBytes[3] = Soft_I2C_Read( 1 );
    ReadBytes[4] = Soft_I2C_Read( 0 );
    Soft_I2C_Stop();

    //Calcula a frequencia em hz
    ((char*)&Freq_Tmp)[1] = ReadBytes[0] & 0x3F;
    ((char*)&Freq_Tmp)[0] = ReadBytes[1];

    Freq_Tmp <<= 13;

    if( TEA5767.HLSI )
          Freq_Tmp -= 225000;
      else
          Freq_Tmp += 225000;

    *freq_hz = Freq_Tmp;

    //Nivel do sinal recebido
    *sinal = ReadBytes[3] >> 4;

    //flags
    (*flags).B0 = ReadBytes[2].B7;  //mono ou stereo
    (*flags).B1 = ReadBytes[0].B7; //estacao foi encontrada, caso o scan estiver ativado
    (*flags).B2 = ReadBytes[0].B6;  //atingiu o limite de banda
}

void TEA5767_Sintonizar( unsigned long freq_hz )
{
      //Formula = 4 * ( FREQ + 225000 ) / 32768

      if( TEA5767.HLSI )
          freq_hz += 225000;
      else
          freq_hz -= 225000;

      freq_hz >>= 13;

      TEA5767.FREQUENCIA_H = ((char*)&freq_hz)[1];
      TEA5767.FREQUENCIA_L = ((char*)&freq_hz)[0];
      TEA5767.SEARCH_STOP_LEVEL = 1;

      TEA5767_Write();
}

void TEA5767_Scan( char direcao )
{
     TEA5767.SEARCH_MODE = 1;
     TEA5767.SEARCH_UP_DOWN = direcao.B0;
     TEA5767.SEARCH_STOP_LEVEL = 2;
     TEA5767_Write();
}

EXEMPLO

No exemplo, há dois botões, que são utilizados para sintonizar a frequência e, também para procura automática das estações de rádio. A procura das estações ocorre quando o botão é pressionado por mais de 1 segundo. Para sintonizar, basta pressionar o botão, que a frequência irá decrementar ou incrementar em 100KHz ( 0.1MHz ).

O Display de LCD exibirá a frequência da rádio, o tipo da saída de áudio ( Stereo ou Mono ) e também o nível do sínal recebido.

MikroC PRO PIC

//Projeto: Radio FM com TEA5767
//MCU: PIC18F4550
//CLOCK: 48MHz ( 20MHz + PLL )
//Autor: Tiago Henrique
//Compilador: MikroC PRO PIC
//Habilitar as seguintes bibliotecas:
// - Conversions
// - Software_I2C
// - LCD


//copie e cole o código da biblioteca aqui!!!

sbit Soft_I2C_Scl           at RD1_bit;
sbit Soft_I2C_Sda           at RD0_bit;
sbit Soft_I2C_Scl_Direction at TRISD1_bit;
sbit Soft_I2C_Sda_Direction at TRISD0_bit;

sbit LCD_RS at RD2_bit;
sbit LCD_EN at RD3_bit;
sbit LCD_D4 at RD4_bit;
sbit LCD_D5 at RD5_bit;
sbit LCD_D6 at RD6_bit;
sbit LCD_D7 at RD7_bit;

sbit LCD_RS_Direction at TRISD2_bit;
sbit LCD_EN_Direction at TRISD3_bit;
sbit LCD_D4_Direction at TRISD4_bit;
sbit LCD_D5_Direction at TRISD5_bit;
sbit LCD_D6_Direction at TRISD6_bit;
sbit LCD_D7_Direction at TRISD7_bit;

sbit ButtonUp at PORTB.B2;
sbit ButtonDown at PORTB.B3;

unsigned long frequencia = 103500000; //frequencia de uma rádio em Hz
char nivel;
char radio_flags = 0;
char texto[12];
char tempo = 0;

void main()
{
        ADCON1 = 0x0F;    //desativa o canal analogico
        CMCON = 7; //desativa o comparador analogico
        NOT_RBPU_Bit = 0; //habilita os resistores de pull-up da PORTB

        Soft_I2C_Init(); //inicializa a comunicacao I2C

        Lcd_Init(); //iniciliaza o display lcd
        Lcd_Cmd( _LCD_CURSOR_OFF );
        Lcd_Cmd( _LCD_CLEAR );

        TRISB.B3 = 1; //botao de sintonia ( - ), botao de procura ( down )
        TRISB.B2 = 1; //botao de sintonia ( + ), botao de procura ( up )

        TEA5767_Sintonizar( frequencia ); //Sintoniza o radio

        while( 1 )
        {
             if( !ButtonUp )
             {
              tempo = 0;

              while( !ButtonUp )//enquanto o botao estiver pressionado
              {
                tempo++;
                if( tempo >= 200 )
                    break;
                Delay_ms( 5 );
              }
               
              frequencia += 100000;
              TEA5767_Sintonizar( frequencia );
              
              if( tempo >= 200 )  //1 segundo pressionado?
              {
                   TEA5767_Scan( 1 );
                  Lcd_Out( 2, 8, "SCAN" );
              }
             }
             else if( !ButtonDown )
             {
              tempo = 0;

              while( !ButtonDown )//enquanto o botao estiver pressionado
              {
                tempo++;
                if( tempo >= 200 )
                    break;
                Delay_ms( 5 );
              }
               
               frequencia -= 100000;
               TEA5767_Sintonizar( frequencia );
               
               if( tempo >= 200 ) //1 segundo pressionado
               {
                  TEA5767_Scan( 0 );
                  Lcd_Out( 2, 8, "SCAN" );
               }
             }

             TEA5767_Read( &frequencia, &radio_flags, &nivel );
             
             //imprime no display lcd
             Lcd_Out( 1, 1, "FREQ: " );
             WordToStr( frequencia / 100000, texto );
             Lcd_Chr_CP( texto[1] );
             Lcd_Chr_CP( texto[2] );
             Lcd_Chr_CP( texto[3] );
             Lcd_Chr_CP( '.' );
             Lcd_Chr_CP( texto[4] );
             Lcd_Out_CP( " MHz" );
             
             ByteToStr( nivel, texto );
             Lcd_Out( 2, 12, texto );

             if( radio_flags.B0 )
                 Lcd_Out( 2, 1, "STEREO" );
             else
                 Lcd_Out( 2, 1, " MONO " );

             if( radio_flags.B1 )  //Estacao encontrada
             {
                   TEA5767.SEARCH_MODE = 0;
                   Lcd_Out( 2, 8, "    " );
             }
             
             Delay_ms( 50 );
        }
}

PIC: LCD com 74HC595

2014-06-18T21:39:00.000-03:00

PIC: Controlando Motores DC com L293D

2014-04-25T15:29:00.002-03:00

PIC: Controlando Motores DC com L293D

O CI L293D é um controlador que possui duas Ponte-H. Pode controlar motores de corrente contínua (DC) de 4.5V até 36V. O L293D suporta uma corrente constante de 600mA e uma corrente de pico de 1.2A. Portanto, tome cuidado para não utilizar motores que exijam correntes maiores que 600mA. Também possuem diodos de proteção internamente.

É possível ligar até dois motores ( ou três, para isso consulte o datasheet ).

FUNCIONAMENTO:

EN1	IN1	IN2	Função
H	L	H	Girar para um lado
H	H	L	Girar para outro lado
H	L	L	Motor1 Parado
H	H	H	Motor1 Parado
L	X	X	Motor1 Parado

Os pinos 2 e 7 são a entrada de controle para um motor. Os pinos 10 e 15 são a entrada de controle para um segundo motor.

Os pinos 3 e 6 são a saída do motor 1 e os pinos 11 e 14 para o motor 2.

Os pinos 1 e 9 habitam as saídas dos motores 1 e 2, respectivamente.

O pino 16 é a alimentação do circuito interno, 5V.

O pino 8 é a alimentação do motor, de 4.5V a 36V.

Neste projeto há 4 botões: um para acionar ou desacionar o motor, outro para alterar a direção da rotação e outros dois para aumentar e diminuir a velocidade.

A velocidade do motor é controlada através do canal PWM do PIC conectando no pino 1 (EN1) do L293D.

Para alterar o giro, é só alterar os níveis lógicos nos pinos 2 (IN1) e 7 (IN2), de acordo com a tabela acima.

DOWNLOAD:

Projeto: motor_dc_com_l293d.rar

CÓDIGO:

MikroC PRO PIC

/*
  Autor: Tiago Henrique
  MCU: PIC16F628A
  Clock: INTOSC 4MHz
  
  Bibliotecas:
  PWM
*/

//Pinos de ligacao do L293D
sbit L293D_M1_P1 at RA1_Bit;
sbit L293D_M1_P2 at RA2_Bit;
sbit L293D_M1_P1_Direction at TRISA1_Bit;
sbit L293D_M1_P2_Direction at TRISA2_Bit;

void L293D_Init()
{
    L293D_M1_P1_Direction = 0;
    L293D_M1_P2_Direction = 0;
    L293D_M1_P1 = 0;
    L293D_M1_P2 = 0;
    PWM1_Init( 500 );
    PWM1_Set_Duty( 127 ); //Velocidade inicial 50%
    PWM1_Start();
}

//direcao == 1 -> gira para um lado
//direcao == 2 -> gira para outro lado
//direcao == 0 -> motor parado
void L293D_Girar( char direcao )
{
    //Define as saidas dos pinos
    L293D_M1_P1 = direcao.B0;
    L293D_M1_P2 = direcao.B1;
}

void main() 
{
char velocidade = 255; //100%
char flags = 0;

    L293D_Init();
    
    CMCON = 7; //Desativa o comparador analogico
    
    //Define os pinos como entrada
    TRISB1_Bit = 1;  //botao de giro
    TRISA4_Bit = 1;  //botao de ligar/ desligar
    TRISB4_Bit = 1;  //botao aumentar velocidade
    TRISB5_Bit = 1;  //botao dimunir velocidade

    while(1)
    {
       //botao RB0 pressionado = girar para direita
       //botao RB0 liberado = girar para esquerda
       //botao RA4 pressionado = motor ligado
       //botao RA4 liberado = motor desligado
       //Essa linha de comando ficou show hein!!!!
       L293D_Girar( PORTA.B4 << PORTB.B0 );
       
       //controlando a velocidade
       
       if( PORTB.B4 ) flags.B0 = 1;
       else if( PORTB.B5 ) flags.B1 = 1;

       if( !PORTB.B4 && flags.B0 )
       {
           flags.B0 = 0;
           velocidade += 5;
           PWM1_Set_Duty( velocidade );
       }
       else if( !PORTB.B5 && flags.B1 )
       {
           flags.B1 = 0;
           velocidade -= 5;
           PWM1_Set_Duty( velocidade );
       }
    }
}

One-Wire com 74HC595

2014-04-14T21:26:00.000-03:00

One-Wire com 74HC595

Navegando pela internet, achei um projeto muito interessante na qual utilizava um registrador de deslocamento, o 74HC595, comunicando com o PIC através apenas de 1 pino.( One-Wire )

Com um pequeno circuito RC, proporciona um tempo de atraso para a linha de dados. Pulsos muito curto significa que foi deslocado o bit 1. Pulsos um pouco mais longo, significa bit 0. Pulsos muito longo é usado para pulsar o latch atualizando as saídas do registrador.

Veja o projeto completo aqui.

Observações:

Funciona com clock superior ou igual à 8MHz;

O Pino Q0 do 74HC595 será sempre 0.

Criei uma biblioteca mais enxuta. Veja:

BIBLIOTECA

MikroC PRO PIC


extern sfr sbit Ow74HC595_Out;
extern sfr sbit Ow74HC595_Out_Direction;

void OneWire74HC595_Init()
{
    Ow74HC595_Out_Direction = 0;
    Ow74HC595_Out = 1;
}

void OneWire74HC595_Write( char wData )
{
char i;
    Ow74HC595_Out = 1;
    for( i = 0; i < 8; i++ )
    {
        if( wData.B7 )
        {
           Ow74HC595_Out = 0;
           Delay_us( 1 );
           Ow74HC595_Out = 1;
           Delay_us( 15 );
        }
        else
        {
           Ow74HC595_Out = 0;
           Delay_us( 15 );
           Ow74HC595_Out = 1;
           Delay_us( 30 );
        }
        
        wData <<= 1;
        Delay_us( 30 );
    }
    //Latch
    Ow74HC595_Out = 0;
    Delay_us( 200 );
    Ow74HC595_Out = 1;
    Delay_us( 300 );
}

Exemplo:

sbit Ow74HC595_Out at RD0_Bit;
sbit Ow74HC595_Out_Direction at TRISD0_Bit;

//copie e cole o código da biblioteca aqui!!!

void main()
{
char i = 0;
 OneWire74HC595_Init();
 
 while( 1 )
 {
     OneWire74HC595_Write( i++ );
     Delay_ms( 1000 );
 }
}

Referência: http://www.romanblack.com/shift1.htm