Social Icons

4.12) Display 7 Segmentos

No meio de um experimento com Display de 7 seguimentos e Arduino, achei melhor criar uma classe para tratar dos números exibidos no Display.


Deixo aqui a Classe e um exemplo de como usá-la.
Configuração de pinos (Digital) utilizada no exemplo:
7 Segments LED Display - Pin Configuration
Obs.: Está configuração pode ser modificada no momento em que é criada a instância da classe “Simple7Segments” (Simple7Segments display(2, 3, 4, 5, 6, 7, 8, 9);).


Simple7Segments.h (biblioteca)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
 * Simple seven segments LED display
 *
  */


#ifndef Simple7Segments_h
#define Simple7Segments_h


#include <inttypes.h>


class Simple7Segments
{
  private:
    uint8_t *_pins;
    uint8_t _count;
 
  public:
    Simple7Segments(uint8_t, uint8_t, uint8_t, uint8_t,
      uint8_t, uint8_t, uint8_t, uint8_t);
    void showNumber(char);
    void showAll();
    void clearAll();
};


#endif



Simple7Segments.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
/**
 * Simple seven segments LED display
 *
 */


#include "Simple7Segments.h"
#include "WProgram.h"


#include <inttypes.h>


#define QUANTITY_PINS 8


Simple7Segments::Simple7Segments(uint8_t a, uint8_t b, uint8_t c, uint8_t d,
  uint8_t e, uint8_t f, uint8_t g, uint8_t pd)
{
  // Alocate memory for Array _pins
  _pins = (uint8_t*)calloc(QUANTITY_PINS, 4);
 
  // Transfer parameters to array pins
  _pins[0] = a;
  _pins[1] = b;
  _pins[2] = c;
  _pins[3] = d;
  _pins[4] = e;
  _pins[5] = f;
  _pins[6] = g;
  _pins[7] = pd;
 
  // Set pin mode to all
  for (_count = 0; _count < QUANTITY_PINS; _count++)
  {
    pinMode(_pins[_count], OUTPUT);
  }
}


void Simple7Segments::showNumber(char letter)
{
  clearAll();
  switch (letter)
  {
    case '0':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[2], HIGH);
      digitalWrite(_pins[3], HIGH);
      digitalWrite(_pins[4], HIGH);
      digitalWrite(_pins[5], HIGH);
    break;
    case '1':
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[2], HIGH);
    break;
    case '2':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[6], HIGH);
      digitalWrite(_pins[4], HIGH);
      digitalWrite(_pins[3], HIGH);
    break;
    case '3':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[6], HIGH);
      digitalWrite(_pins[2], HIGH);
      digitalWrite(_pins[3], HIGH);
    break;
    case '4':
      digitalWrite(_pins[5], HIGH);
      digitalWrite(_pins[6], HIGH);
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[2], HIGH);
    break;
    case '5':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[5], HIGH);
      digitalWrite(_pins[6], HIGH);
      digitalWrite(_pins[2], HIGH);
      digitalWrite(_pins[3], HIGH);
    break;
    case '6':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[2], HIGH);
      digitalWrite(_pins[3], HIGH);
      digitalWrite(_pins[4], HIGH);
      digitalWrite(_pins[5], HIGH);
      digitalWrite(_pins[6], HIGH);
    break;
    case '7':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[2], HIGH);
    break;
    case '8':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[2], HIGH);
      digitalWrite(_pins[3], HIGH);
      digitalWrite(_pins[4], HIGH);
      digitalWrite(_pins[5], HIGH);
      digitalWrite(_pins[6], HIGH);
    break;
    case '9':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[2], HIGH);
      digitalWrite(_pins[5], HIGH);
      digitalWrite(_pins[6], HIGH);
    break;
  }
}


void Simple7Segments::clearAll()
{
  for (_count = 0; _count < QUANTITY_PINS; _count++)
  {
    digitalWrite(_pins[_count], LOW);
  }
}


void Simple7Segments::showAll()
{
  for (_count = 0; _count < QUANTITY_PINS; _count++)
  {
    digitalWrite(_pins[_count], HIGH);
  }
}


SevenSegmentsExample.pde
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/**
 * Simple seven segments LED display
 *
 *
 */


#include "Simple7Segments.h"


#define LED_FINISH 12
#define DELAY 500


unsigned int count = 0;


// Define variable display.
// The numbers are the pins of the display
Simple7Segments display(2, 3, 4, 5, 6, 7, 8, 9);


void setup()
{
  pinMode(LED_FINISH, OUTPUT);
}


void loop()
{
  char* buffer;
  itoa(count, buffer, 10);
  display.showNumber(buffer[0]);
  delay(DELAY);
  if (++count == 10)
  {
    count = 0;
    finish();
  }
}


void finish()
{
  digitalWrite(LED_FINISH, HIGH);
  delay(50);
  digitalWrite(LED_FINISH, LOW);
  delay(50);
  digitalWrite(LED_FINISH, HIGH);
  delay(50);
  digitalWrite(LED_FINISH, LOW);
}

Análise:

Linha 17) Cria uma instância da classe Simple7Segments passando no construtor os pinos correspondentes as posições no display.

Linha 27) Converte o valor da variável contadora (count) para char* (“String”).

Linha 28) Chama o método showNumber da instância display passando o número a exibir.

Linha 37) Método chamado quando uma contagem de 0 à 9 chega ao fim (pisca o LED).
Faça o download do código fonte completo aqui.
geek Responsável : 0 Comentários
Sobre: , , , , , , , , ,

4.11) Controlando Led RGB com Arduino e Processing



Vamos a um exemplo de uso da Arduino onde controlo um Led RGB de quatro terminais através da porta serial.
Para enviar as cores através da serial usaremos processing.
Para combinar as cores de um Led RGB é necessário variar a tensão em cada terminal, e para isso a Arduino conta com 6 pinos PWM (Pulse Width Modulation, Modulação por largura de pulso), somente 3 são necessários, pois o quarto terminal deve ser conectado a GND (terra).

No exemplo conectamos os pinos da seguinte forma:
  • Terminal Vermelho no pino 9 (utilizando resistência de 150 Ohm)
  • Terminal Azul no pino 10        (utilizando resistência de 90 Ohm)
  • Terminal Verde no pino 11     (utilizando resistência de 90 Ohm)
  • Terminal terra no pino GND
Obs.: Como não tinha em mãos os resistores liguei os terminais diretamente aos pinos da arduino, mas é importante ressaltar que isso pode danificar o seu led e com certeza reduzir o seu tempo de vida útil.

RGB Led - Arduino + Processing from Bruno Soares on Vimeo.


Espesificação do Led usado:
  • Diâmetro: 5mm.
  • Bulbo: transparente.
  • Intensidade Luminosa: 8000 mcd.
  • Tensão: vermelho = 1.9 ~ 2.4v; verde e azul = 3.2 ~ 3.6v.
  • Corrente: 20mA.
  • Ângulo: 20 ~ 25º.
  • 5mm rgb led color especification
Vamos ao código utilizado na arduino:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
/**
 * Controller LED RGB
 */

#define START_COLOR_CHAR '^'
#define END_COLOR_CHAR '$'
#define COLOR_SIZE 8
#define PIN_RED 9
#define PIN_GREEN 11
#define PIN_BLUE 10

char serialMessage[COLOR_SIZE];
unsigned int readChar;
unsigned int count;
unsigned long color;
unsigned int r;
unsigned int g;
unsigned int b;
boolean readingSerial;

void setup() {
  Serial.begin(9600);
  readingSerial = false;
}

void loop() {

  if (Serial.available() > 0 && !readingSerial) {
    if (Serial.read() == START_COLOR_CHAR) {
      serialReadColor();
    }
  }
}

void serialReadColor() {
  readingSerial = true;
  count = 0;
 
  iniReading:
  if (Serial.available() > 0) {
    readChar = Serial.read();
    if (readChar == END_COLOR_CHAR || count == COLOR_SIZE) {
      goto endReading;
    } else {
      serialMessage[count++] = readChar;
      goto iniReading;
    }
  }
  goto iniReading;
 
  endReading:
  readingSerial = false;
  serialMessage[count] = '\0';
 
  setColor(serialMessage);
}

void setColor(char* value)
{
  // Convert Char* to Long
  color = atol(value);
 
  // Extract RGB
  r = color >> 16 & 0xFF;
  g = color >>  8 & 0xFF;
  b = color >>  0 & 0xFF;
 
  // Send values to analog pins
  analogWrite(PIN_RED, r);
  analogWrite(PIN_GREEN, g);
  analogWrite(PIN_BLUE, b);
}


Linha 25) Iniciamos a conexão com a porta serial na velocidade 9600.
Linha 30) Verifica se existe mensagem na porta serial.
Linha 32) Chama o método serialReadColor para iniciar a leitura da serial.
Linha 57) Envia o texto lido entre os caracteres ^ e $ para o método setColor.
Linha 63) Converte o valor obtido para Long.
Linha 66 à 68) Extrai a quantidade de Red, Green e Blue da cor.
Linha 71 à 73) Envia a tensão para os pinos correspondêntes a cada cor.


Conclusão: A Arduino está programada para receber a cor em formato numérico entre dois caracteres que identificam o inicio e o fim da cor (^ para o inicio e $ para o fim). Sendo assim se enviarmos ^16711680$ o LED ficaria vermelho, pois o número 16711680 é o correspondente á 0xFF0000 (hexadecimal).

Agora o código do Processing:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/**
 * Controller LED RGB
 */

import processing.serial.*;

Serial port;

void setup() {
  size(100, 150);
  noStroke();
 
  // Background
  colorMode(HSB, 100);
  for (int i = 0; i < 100; i++) {
    for (int j = 0; j < 100; j++) {
      stroke(i, j, 100);
      point(i, j);
    }
  }
 
  // Select port
  println(Serial.list());
  port = new Serial(this, Serial.list()[1], 9600);
}

void draw() {
  // Only to enable the method mouseDragged
}

void mouseClicked() {
  processColor();
}

void mouseDragged() {
  processColor();
}

void processColor() {
  color c = get(mouseX, mouseY);
  noStroke();
  fill(c);
  rect(0, 100, 100, 50);
  sendColorToSerial(c);
}

void sendColorToSerial(color colour) {
  // Get HEX
  String hexColor = hex(colour, 6);
 
  // Convert HEC to Number
  long numColor = unhex(hexColor);
 
  // Send color number to serial port
  port.write("^" + numColor + "$");
}

A responsabilidade do Processing é se comunicar com a Arduino via porta serial e enviar as cores, pois com o processing podemos criar um aplicativo onde fica facíl selecionar a cor desejada.
Na linha 50 (método sendColorToSerial), o processing processa o objeto Color, obtendo o seu Hexa, transformando em um número do tipo long, concatenando esse número com os caracteres ^ e $, e finalmente enviando este dado formatado para a porta serial para a Arduino fazer o que está a sua responsabilidade.

Futuramente irei fazer um post somente sobre Processing e suas aplicações específicas e gerais...


geek Responsável : 0 Comentários
Sobre: , , , , , , , ,

4.10) Hello World com LCD + Arduino

LiquidCrystal - "Hello World!"

Tutorial Famoso Hello World compativel com Hitachi HD44780 driver.
output of the sketch on a 2x16 LCD
 
Esse LCD tem uma interface paralela, ou seja, você pode fazer diversos tipos de comandos/telas/caracteres... tudo pelo microcontrolador.

Hardware Necessário:

  • Arduino
  • Tela LCD (compativel com Hitachi HD44780 driver)
  • Potenciômetro 10k
  • ProtoBoard
  • Fios de Conexão

Circuito:

  • Pino LCD RS   digital 12
  • Pino LCD no pino digital 11
  • Pino LCD D4 no pino digital 5
  • Pino LCD D5 no pino digital 4
  • Pino LCD D6 no pinodigital 3
  • Pino LCD D7 no pino digital 2
Adicione o pot de 10K no +5V e GND, com a saída para o LCD no pino VO (pino3).
Como na Imagem Abaixo:


 
image developed using Fritzing. For more circuit examples, see the Fritzing project page
 

Antes de Codear aí....

Preste atenção que você terá de incluir #include <LiquidCrystal.h>
 pois é a bibioteca do LCD, definir os pinos de saida e entrada de dados ... aí sim joga sua Mensagem pra ele...
posteriormente vou colocar uns esquemas legais de ficar indo e voltando, piscar...menus com interatividade...
Se você ja Viu os outros tutoriais ja deve saber... de uma olhada em pisca LED, nos Projetos Simples, você coloca comando delay(1000) manda   lcd.print(" ") ou seja nada, depois seu texto denovo... com a VOID LOOP dai ele vai piscar seu texto de 1 em 1 segundo...

Código:

/*
  LiquidCrystal Library - Hello World
 

 Library originally added 18 Apr 2008
 by David A. Mellis
 library modified 5 Jul 2009
 by Limor Fried (http://www.ladyada.net)
 example added 9 Jul 2009
 by Tom Igoe
 modified 22 Nov 2010
 by Tom Igoe

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/LiquidCrystal
 */

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("hello, world!");
}

void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  // print the number of seconds since reset:
  lcd.print(millis()/1000);
}

Esse talvez pisca, como ainda não tenho arduino não testei , mas pelo meu pouco conhecimento acho que funciona, sei que compilou e não deu erros,  pelo menos testar eu sei que não daria problema nenhum então testem e me avisem...

/*
  LiquidCrystal Library - Hello World
 
Author: Marcelo Boeira

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/LiquidCrystal
 */

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
}

void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  // print the number of seconds since reset:
  lcd.print(millis()/1000);
  // Print a message to the LCD.
  lcd.print("hello, world!");
  delay(1000);
  // Print empty message
  lcd.print("           ");
  delay(1000);
}




Conteúdo do Site Arduino.cc
Veja Mais em: http://arduino.cc/en/Tutorial/LiquidCrystal
Traduzido bem Por Cima...
Desculpem os erros, ta mais no sentido da tradução...
geek Responsável : 0 Comentários
Sobre: , , , , , , , , , ,

LCD Gráfico do NOKIA 3310 Direto Pela Serial

Eu encontrei este circuito muito simples e interessante. É realmente fácil controlar o LCD gráfico do Nokia 3310 usando um cabo simples e algum software no PC.A porta paralela do computador se conecta ao LCD através do seguinte circuito:


The image “http://www2.eletronica.org/hack-s-dicas/richdocument.2006-12-09.0677997135/lpt_to_nokia3310.png” cannot be displayed, because it contains errors.

















o display gráfico precisa de uma tensão na fonte de 3.3V, enquanto a porta paralela fornece aproximadamente 4.5 - 5V. É por isso que os diodos em série são usados, para reduzir a tensão pela fórmula: 4.5V - 0.7V - 0.7V = 3.1V.
Qualquer dúvida clique aqui e va para parte de diodos para revisar...


A pinagem do LCD Nokia 3310 é a seguinte:


The image “http://www2.eletronica.org/hack-s-dicas/richdocument.2006-12-09.0677997135/lcd_pins.jpg” cannot be displayed, because it contains errors.

A display gráfico utiliza o controlador PCD8544. A especificação deste pode ser baixada aqui: PCD8544.pdf  
 
Como você observou, os pinos de dados da porta paralela são usados para a transferência de dados e alimentação do LCD.



The image “http://www2.eletronica.org/hack-s-dicas/richdocument.2006-12-09.0677997135/port_data_pins.jpg” cannot be displayed, because it contains errors.

Quando o hardware estiver pronto, é hora de imprimir algumas imagens no LCD. Para isto baixe programa de controle (o fonte em pascal também está incluído).  O software é escrito para controlar diretamente os pinos no DOS ou Windows 98.
Se você está usando Windows 2000 ou XP você precisa ler isso.

Eu copiei uma das soluções aqui: baixe o programa PortTalk, descompacte e separe em alguma pasta. Então copie allowio.exe para o diretório onde está o programa que você quer rodar. Então crie um atalho para o seu programa compilado, por exemplo, LCD.exe. Então abra as propriedades do atalho e na linha alvo faça as seguintes alterações:

Ao invés de

D:/project/LCD.exe
troque para

D:/project/allowio.exe D:/project/LCD.exe /a
Lembre-se que você precisa ter privilégios de administrador no computador. É um truque feio mais funciona.


Tudo funcionando, execute o programa e desenhe com o botão esquerdo. O botão direito apaga:

The image “http://www2.eletronica.org/hack-s-dicas/richdocument.2006-12-09.0677997135/lcd_in_progress.jpg” cannot be displayed, because it contains errors.



Boa sorte !


Posteriormente (mais precisamente quando chegar meu LCD Nokia e meu Arduino) vou mostrar mais tutoriais com LCD Nokia 3310 e LCD Sheilds também...
geek Responsável : 0 Comentários
Sobre: , , , , , ,

Liberando Porta Paralela ou Serial



As versões XP, NT e 2000 dos sistemas operacionais da Microsoft implementam uma política de segurança que impede o usuário de trabalhar diretamente com a porta paralela. Neste breve texto, mostraremos como liberar o acesso para que nossos projetos eletrônicos funcionem devidamente.

Seria interessante se você pretende seguir alguns dos tutoriais aqui dispostos ...


A solução para esta situação dar-se através de peças de software. Bibliotecas diferentes devem ser utilizadas na hora de implementar as rotinas para que não haja problemas de segurança.
No entanto, vários softwares já estão prontos e não possuem versões desenhadas especificamente para suprir estas necessidades. É aí que entra um outro programa, o UserPort, desenvolvido por Tomas Franzon. A documentação completa do UserPort, em PDF e inglês, pode ser vista aqui.
Para facilitar, aqui estão os passos rápidos para que os seus programas voltem a funcionar:



  • Pegue o arquivo UserPort.zip clicando aqui.

  • Descompacte o arquivo em um diretório (pasta) escolhido por você.

  • Copie o arquivo UserPort.sys para o diretório c:/windows/system32/drivers (ou c:/winnt/system32/drivers para o Windows NT).

  • Execute o programa UserPort.exe.

  • Mude os endereços para 0x378-0x37A, clicando em "ADD". 

  • Remova os outros endereços com o botão "Remove". 

  •  Clique em "Start". 



  • Com estes passos, o seu sistema operacional estará "desbloqueado" para acesso direto a porta paralela. O procedimento só é necessário uma única vez. Caso deseje voltar a condição anterior, basta iniciar novamente o programa e clicar em "STOP".

    • geek Responsável : 0 Comentários
    Sobre: , , , , ,
    Assinar: Postagens (Atom)