Arduino - Display LCD 16×2

 O display LCD 16×2 é uma das opções mais usadas quando se necessita de uma interface para os projetos. Isso porque ele é barato e relativamente simples de usar. Além do fato de que é possível encontrar shields para o Arduino, facilitando bastante o processo de montagem do circuito.

 

O que é

A sigla LCD significa Liquid-Crystal Display, isto é, um display de cristal líquido. Isso implica que ele é um componente capaz de formar “imagens”.

O LCD está presente em diversos equipamentos, mas, neste caso, nós vamos falar do LCD 16×2 que é um componente pequeno, comparado com as televisões LCD. E ele pode ser programado facilmente usando as bibliotecas já existentes, tanto para o Arduino (AVR), quanto para o PIC ou outro microcontrolador em questão.

Fonte: Wikipedia

O fato dele ser 16×2 significa que ele é capaz de mostrar 16 caracteres por linha e que ele possui duas linhas. Se você tiver interesse em saber como programar o display sem usar a biblioteca pronta, os dois pdfs abaixo são muito interessantes e podem te ajudar muito nesse processo:

 

Características

 

 

O display em si é só o que está na placa verde da imagem acima. Mas, como é o caso da imagem, é possível encontrar shields ou módulos que acoplam o display em uma placa. Isso serve para facilitar a ligação do display com o Arduino e para adicionar alguns componentes interessantes a mais.

O shield da imagem, por exemplo, acompanha 6 botões (normalmente conectados ao A0) que auxiliam bastante a criar aplicações em que o usuário tem que interagir com o display. E também tem um potenciômetro para regular o brilho.

Pinos

O LCD 16×2 contem 16 pinos, pela ordem:

1. GND ou Vss – Pino de alimentação que deve ser ligado ao GND
2. Vcc ou Vdd – Pino de alimentação que deve ser ligado no 5V (Pode variar em torno de 4,7V – 5,3V)
3. VO ou Vee – Pino que regula o contraste. Quanto maior for a tensão (0-5v), mais o display ficará nítido.
4. RS – Pino para controlar o display. Quando recebe sinal baixo seleciona o registrador de comando e, quando recebe sinal alto, seleciona o registrador de dados.
5. RW – Pino de leitura ou escrita. Quando recebe sinal baixo entra no modo escrita e, quando recebe sinal alto, entra no modo leitura.
6. E – Manda dados para os pinos de dados quando um pulso de sinal alto para baixo é dado.
7. ao 14. D0 à D7 – Pinos de dados. Normalmente o display é controlado no modo 4bits, ou seja, usa-se só do D4 ao D7.

15. e 16. A (ou Led+) e K (ou Led -) – Pinos que alimentam o LED responsável pela luz de fundo do display.

Circuito

Se você possui um shield, então basta encaixá-lo no Arduino. Mas, se esse não for o seu caso, a ligação do display com o Arduino está mostrada abaixo:

 

 

Apesar de parecer complicado, é um circuito bem simples até. O pino GND deve ser ligado ao GND do Arduino. O Vdd ao 5v. O VO deve ser ligado ao terminal central de um potenciômetro e os outros pinos do potenciômetro devem ser ligados, um ao GND e o outro ao 5v. Se você quiser eliminar o potenciômetro, tente ligar o VO direto ao GND. O pino RW deve ser ligado ao GND.

Em relação aos pinos de dados, você pode mudá-los, mas vou mostrar a ligação padrão: o pino RS deve ser ligado ao pino 12 do Arduino, o pino E ao pino 11, e do pino D4 ao D7, devem ser ligados do pino 5 ao pino 2 respectivamente.

Os ultimos dois pinos (A e K) talvez não precisem ser ligados, portanto teste sem ligá-los para economizar recursos. Se não funcionar, basta ligar um resistor (não tem valor exato, recomendo 220Ω) no pino A e a outra ponta do resistor no 5v. E o pino K deve ser ligado no GND. Feito isso, basta programar.

 

Programação

Comandos de inicialização

Vamos utilizar a biblioteca pronta que já vem com a IDE do Arduino, que é a LiquidCrystal. Nos exemplos, é possível encontrar diversos códigos interessantes para poder testar o display, mas vamos entender os comandos básicos:

A instância (uma forma de referenciar o display dentro do código) do lcd precisa ser definida e fazemos isso com o seguinte comando:

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

Os números correspondem aos pinos que ligamos anteriormente. Traduzindo para ficar mais fácil entender.

LiquidCrystal lcd(pino Rs, pino E, D4, D5, D6, D7);

Então, se você deseja ligar os pinos de dados diferente do circuito que mostrei, é só lembrar de mudá-los na programação também. No caso do shield que mostrei, a pinagem certa é a seguinte:

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

Enfim, o segundo passo é iniciar o display:

lcd.begin(16, 2);

 

O 16,2 se refere justamente aos 16 caracteres e as duas linhas que mencionei anteriormente.

 

Comandos de escrita

Agora, basta usar o display como você quiser, e os comandos que vão te ajudar nesse processo são:

• lcd.print(“AlgumaCoisa”);
  • Se você quiser escreve algo, é só usar esse comando. Retire as aspas e coloque o nome de uma variável para printar o valor dela.
• lcd.setCursor(0, 0);
  • Obvio, você não quer sair escrevendo em qualquer lugar, e pra isso existe o comando acima que define a posição do cursor, que é a posição onde o LCD irá escrever a partir do momento que o comando foi digitado. O primeiro parâmetro define a coluna e o segundo a linha. Por padrão, a escrita ocorre em 0,0 que é: na primeira linha, a partir da primeira coluna.
• lcd.clear();
  • Esse comando basicamente limpa a tela e volta o cursor pra 0,0.
  • Ele pode ser um pouco lento para ser executado, então talvez seja mais interessante limpar o display utilizando o comando lcd.print(”     “) com vários espaços.

Criando Caracteres

O LCD ainda te permite criar caracteres customizados, isto é, criar símbolos para você printar no display. Cada quadrado do display, que representa um caractere, possui 8 quadradinhos menores no sentido vertical e 5 no sentido horizontal. Então, para criar símbolos, você deve desenhar usando esses quadradinhos e isso é feito da seguinte forma:

1 2 3 4 5 6 7 8 9 10

byte heart[8] = { //Codigo que está no exemplo da biblioteca do liquidcrystal   0b00000,   0b01010,   0b11111,   0b11111,   0b11111,   0b01110,   0b00100,   0b00000 };

Onde cada linha que começa com 0b representa uma linha de quadradinhos. O 0 representa um quadrado apagado e o 1, um quadrado aceso. Então, basta desenhar o seu símbolo usando 1s e 0s. Repare que no código acima (simbolo de um coração), os números 1s formam um coração, de fato.

Caso você tenha dificuldades nessa parte, existe um programa que desenvolveram no Excel que gera o código do símbolo automaticamente a partir de um desenho que você fizer. E você pode baixar ele aqui.

Agora que nós desenhamos o símbolo, precisamos ainda fazer duas coisas. A primeira é declarar para o programa o símbolo:

lcd.createChar(0, heart);

No primeiro parâmetro, você coloca o número ao qual seu símbolo está endereçado, no exemplo acima é o 0. E, depois coloca o nome da variável que está guardado seu desenho. No exemplo acima, fizemos o desenho do coração na variável chamada heart. Por fim, a segunda etapa é desenhar o símbolo. Defina onde quer colocá-lo (a posição do cursor) e use o comando:

lcd.write(0);

O número dentro do parêntese é o número que você definiu como o “endereço” do símbolo. No nosso exemplo, o simbolo do coração está endereçado ao 0.

Exemplo de códigos

 

//Programa: Teste de Display LCD 16 x 2
//Autor: FILIPEFLOP
 
//Carrega a biblioteca LiquidCrystal
#include <LiquidCrystal.h>
 
//Define os pinos que serão utilizados para ligação ao display
LiquidCrystal lcd(22,23, 24, 25, 26, 27);
 
void setup()
{
  //Define o número de colunas e linhas do LCD
  lcd.begin(16, 2);
}
 
void loop()
{
  //Limpa a tela
  lcd.clear();
  //Posiciona o cursor na coluna 3, linha 0;
  lcd.setCursor(3, 0);
  //Envia o texto entre aspas para o LCD
  lcd.print("FILIPEFLOP");
  lcd.print("\n");
  lcd.print("ANDERSON OK");
  lcd.setCursor(3, 1);
  lcd.print(" LCD 16x2");
  delay(5000);
   
  //Rolagem para a esquerda
  for (int posicao = 0; posicao < 3; posicao++)
  {
    lcd.scrollDisplayLeft();
    delay(300);
  }
   
  //Rolagem para a direita
  for (int posicao = 0; posicao < 6; posicao++)
  {
    lcd.scrollDisplayRight();
    delay(300);
  }
}

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() {   lcd.begin(16, 2); } void loop() {   lcd.clear();   lcd.setCursor(2, 0);   lcd.print("Bem-vindo ao");   lcd.setCursor(0, 1);   lcd.print("Mundo Projetado");   delay(3000);   lcd.clear();   lcd.setCursor(1, 0);   lcd.print("Curta a pagina");   lcd.setCursor(3, 1);   lcd.print("no Facebook");

 Fonte:\\

http://mundoprojetado.com.br/display-lcd-com-arduino/

 

 

 

Read More

Kernel panic

 

Fonte:www.google.com

 Kernel panic, em português Pânico do núcleo, é uma situação em que sistemas operacionais Unix e tipo Unix encontram um erro do qual não é possível recuperar-se de modo seguro. No sistema operacional Windows a mesma situação é apresentada com a Tela azul da morte (em inglês: Blue Screen of Death). 

 

Kernell Panic - Ubuntu

Fonte:www.google.com

 

 

Há uma rotina no código fonte do Linux e dos sistemas BSD chamada panic(), que trata uma situação de pânico do núcleo. Ela é projetada para mostrar uma mensagem no console, gravar uma imagem da memória do núcleo no disco para depuração após a falha e então aguardar o sistema ser reiniciado manualmente, ou reiniciar automaticamente. A informação fornecida para a tela é técnica, e é direcionada aos desenvolvedores de software e administradores de sistema para que possam diagnosticar o problema.

Fontes comuns de pânicos do núcleo são tentativas do sistema operacional ler endereços de memória não permitidos, ou falhas no hardware. Outro motivo é a existência de um erro no próprio sistema. Em muitos casos esta situação é induzida pelo próprio sistema, que pode continuar a operação, mesmo depois de violações de memória terem ocorrido. No entanto, nesta situação o estado do sistema é instável, e mais do que arriscar brechas de segurança ou corrupção de dados, é preferível terminar a operação para evitar mais danos, e facilitar o diagnóstico do erro.

O pânico do núcleo foi incluído numa versão inicial do Unix e demonstrou uma grande diferença de filosofia entre o Unix e o Multics. O desenvolvedor do Multics Tom van Vleck, relembra uma discussão com o desenvolvedor do Unix Dennis Ritchie:

Eu comentei com o Dennis que facilmente metade do código que eu estava escrevendo no Multics era para recuperação de erros. Ele disse: "Deixamos tudo isso de fora. Se houver um erro, temos uma rotina chamada panic, que quando é chamada, trava a máquina e você grita lá no corredor, 'Ei, reinicie.'"^[1]

A função original permaneceu essencialmente inalterada desde a quinta edição do Unix até o Unix 32V baseado no VAX apenas emitindo uma mensagem de erro sem mais informações, deixando o sistema num looping infinito. Na medida em que o Unix foi melhorado, a função panic() foi aprimorada para exibir várias informações úteis para depuração no console. 

 

Fonte:

 

https://pt.wikipedia.org/wiki/Kernel_panic

Read More

Processadores CISC X RISC: qual a diferença entre essas duas arquiteturas?

 Capacidade e modo de processamento. Ao final deste post, você vai concluir que essas são as principais diferenças entre as arquitetura CISC e RISC. Mas para chegar lá, vamos começar do início.    

O que o processador faz?

Considerado o cérebro de um computador, o processador – ou Unidade Central de Processamento (CPU) – é um circuito eletrônico responsável por executar uma série de instruções dadas pela máquina.   Essas instruções são pré-definidas e armazenadas na memória principal do computador e chegam ao processador em linguagem assembly, que é o padrão reconhecido e compreendido por ele.   O processador pode receber diferentes tipos de instrução:

• Operações aritméticas (adição, subtração, multiplicação e divisão);
• Acesso à memória para, por exemplo, mover dados de um local para outro;
• Operações lógicas;
• Controle, etc...

 É aqui que as diferenças entre RISC e CISC começam a surgir. CISC é o acrônimo de Complex Instruction Set Computer, ou seja, executa instruções complexas.

 E qual é a complexidade por trás dessas instruções?  

• Elas são normalmente longas e repletas de operações matemáticas distintas.
• Não possuem um tamanho padrão, podendo assumir dimensões variáveis de acordo com a quantidade de operações que deverão ser executadas.
• Exigem que o processador acesse a memória para executar essa instrução.

Resultado: o tempo de processamento será maior afetando, portanto, a capacidade de processamento.  Para executar uma só instrução, um processador CISC pode exigir vários ciclos de relógio. Um ciclo de relógio é a frequência medida em Hertz que determina quantos impulsos serão realizados por segundo naquele computador.  

Exemplo, uma máquina de 100Mhz irá realizar 100 milhões de impulsos por segundo. Quanto maior esse número, menor será a quantidade de ciclos necessários para executar uma instrução.   A família de processadores x86 da Intel (286, 386, 486) nascida na década de 1970 é uma das mais reconhecidas usuárias da arquitetura CISC. E, durante anos, os computadores pessoais se restringiram a essa arquitetura até que a Apple mudou esse cenário.   “Podemos dizer que 90% do mercado têm suas demandas atendidas por máquinas com processador CISC. São usadas, normalmente, para rodar aplicações simples que exigem pouco processamento como um sistema de caixa de uma loja, por exemplo”, afirma o Diretor de Operações da LB2, Victor Machado.

 Devido à capacidade de processamento limitada, são logo substituídas pela arquitetura RISC, quando a necessidade de processamento atinge padrões elevados.

RISC ( Reduced Instruction Set Computer)

Aqui o nome mais uma vez diz muito sobre a arquitetura do processador. Ao contrário do CISC, o RISC executa instruções reduzidas. 

Ou seja, ele quebra a instrução em várias menores e mais simples e todas assumem um tamanho padrão.   Cada uma dessas instruções têm as características necessárias para que possa ser executada em apenas um ciclo de relógio. No exemplo que demos antes, a cada 100 milhões de impulsos, uma instrução seria concluída.

No caso do CISC, essa afirmação não seria verdadeira já que uma instrução poderia exigir 10, 20 ou vários outros ciclos para ser finalizada.   “Em nível enterprise, em que o processamento dos dados é muito alto, máquinas com arquitetura RISC como a Power da IBM e Sparc da Oracle são as mais indicadas. E aqui não estamos nos referindo necessariamente ao tamanho da empresa. Organizações de pequeno e médio porte podem ter operações que exijam capacidade de processamento muito alto e, por isso, recorrem ao RISC”, detalha Victor.  

O RISC também é amplamente utilizado em dispositivos móveis como celulares e tablets, os próprios notebooks e vídeo-games, pois são processadores menores, mais baratos e que tendem a consumir menos energia. Sem contar que atende à forte demanda por uma velocidade de processamento elevada nestes casos.  

 

CISC	RISC
Instruções completas que exigem vários ciclos de relógio para serem executadas	Instruções simples executadas em um ciclo de relógio
Instruções com formatos variáveis	Instruções com formatos fixos

 

Apesar de parecer menos vantajosa frente à arquitetura RISC, a CISC possui um conjunto maior de instruções que podem ser precessados, enquanto no RISC, o volume de instruções além de mais limitado, é mais simples.   Existem sim aplicações muito específicas para a arquitetura CISC e, por isso, a tendência é que ambas continuem coexistindo no mercado. Inclusive, há uma tendência de fusão dos dois tipos de processadores, permitindo que as instruções mais complexas sejam direcionadas para RISC e as mais simples e rápidas para CISC.

Para saber exatamente qual se encaixa melhor nas necessidades do seu negócio, conte com a ajuda dos especialistas da LB2.

Fonte:

https://www.lb2.com.br/blog/processadores-cisc-x-risc-qual-a-diferenca-entre-essas-duas-arquiteturas

Read More