PIC: Nokia 3310

PIC: Display Nokia 3310

Estes displays são pequenos, apenas cerca de 1,5" de diâmetro. Possui uma resolução de 84x48 pixels, assim você pode usá-lo para gráficos, textos ou bitmaps. Necessitam de poucos pinos de I/O digitais e são de baixo consumo de energia também.

O display utiliza o chip controlador PCD8544 da Philips que foram utilizados no telefones celulares Nokia 3310 e Nokia 5110. Este chip é projetado para rodar apenas em 3.3V. Mas nos teste que faço utilizo 5V sem problema algum.

O código original era para arduino, onde vocês encontram aqui, mas adaptei para rodar nos microcontroladores PIC.

FUNÇÕES:

void Nokia_Init() - Inicializa o lcd;
 
void Nokia_Write(char dc, char dat) - Envia um dado ou comando para o lcd;
dc - define se o valor enviado é um comando ou um dado.
LCD_CMD - comando, LCD_DATA - dado;
dat - valor a ser enviado;

void Nokia_Fill(char val) - preenche o display com um valor;
val - valor, quando for 0x00, limpa a tela;

void Nokia_Set_Cursor(char x, char y) - define a posição do cursor no lcd;
x - posição horizontal (0 - 83);
y - página situada, posição vertical ( 0 - 5);

void Nokia_Chr(char character, char color) - Escreve um caracter no lcd;

void Nokia_Out(char *s, char color) - Escreve um texto no lcd;

void Nokia_Image(const char *bmp) - Desenha uma imagem.

void Nokia_putMedNumber(char x, char y, char number, char color) - Escreve um número de tamanho médio.
Obs.: x deve ser incrementado de 11 em 11.
y deve ser incrementado de 2 em 2.

void Nokia_putBigNumber(char x, char y, char number, char color) - Escreve um número de tamanho grande.

Obs.: x deve ser incrementado de 14 em 14.
y deve ser incrementado de 3 em 3.

BIBLIOTECA:

#define LCD_CMD      0
#define LCD_DATA     1

#define LCD_X     84
#define LCD_Y     48

#define BLACK 1
#define WHITE 0

#define Nokia_Inverse() Nokia_Write( LCD_CMD, 0x0D )
#define Nokia_Clear() Nokia_Fill( 0x00 )

extern sfr sbit Nokia_Clk;
extern sfr sbit Nokia_Data;
extern sfr sbit Nokia_DC;
extern sfr sbit Nokia_RST;
extern sfr sbit Nokia_SCE;
extern sfr sbit Nokia_Clk_Direction;
extern sfr sbit Nokia_Data_Direction;
extern sfr sbit Nokia_DC_Direction;
extern sfr sbit Nokia_RST_Direction;
extern sfr sbit Nokia_SCE_Direction;

const code char ASCII_TABLE[][5] =
{
 {0x00, 0x00, 0x00, 0x00, 0x00} // 20
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ¥
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x00, 0x07, 0x05, 0x07, 0x00} // 7e °
};

static void Nokia_SPI_Wr( char dat )
{
char i;
  for( i = 0; i < 8; i++ )
  {
     Nokia_Clk = 0;
     Nokia_Data = dat.B7;
     dat <<= 1;
     Nokia_Clk = 1;
     asm nop;
     asm nop;
  }
}

void Nokia_Write( char dc, char _data )
{
  Nokia_DC = dc.B0;
  Nokia_SCE = 0;
  Nokia_SPI_Wr( _data );
  Nokia_SCE = 1;
}

void Nokia_Init()
{
  Nokia_Clk_Direction = 0;
  Nokia_Data_Direction = 0;
  Nokia_SCE_Direction = 0;
  Nokia_RST_Direction = 0;
  Nokia_DC_Direction = 0;
  
  //Reset
  Nokia_RST = 0;
  Delay_us(1);
  Nokia_RST = 1;
  
  Nokia_Write( LCD_CMD, 0x21 );  // LCD Extended Commands.
  Nokia_Write( LCD_CMD, 0xBC );  // Set LCD Vop (Contrast).
  Nokia_Write( LCD_CMD, 0x04 );  // Set Temp coefficent. //0x04
  Nokia_Write( LCD_CMD, 0x14 );  // LCD bias mode 1:48. //0x13
  Nokia_Write( LCD_CMD, 0x0C );  // LCD in normal mode.
  Nokia_Write( LCD_CMD, 0x20 );
  Nokia_Write( LCD_CMD, 0x0C );
}

void Nokia_Set_Cursor( char x, char y )
{
   Nokia_Write( LCD_CMD, 0x40 | y );    //  linha  ( 0 - 5)
   Nokia_Write( LCD_CMD, 0x80 | x );    //  coluna (0 - 83)
}

void Nokia_Chr( char Caracter, char Color )
{
char i, chr;

  for (i = 0; i < 5; i++)
  {   
     chr = ASCII_TABLE[Caracter - 0x20][i];
     if(Color == 0)
     {
       chr = ~(chr);
     }
     Nokia_Write( LCD_DATA, chr );
  }
}

void Nokia_Custom_Char( char *map )
{
char i;

  for (i = 0; i < 5; i++)
  {   
      Nokia_Write( LCD_DATA, *map++ );
  }
}

void Nokia_Fill( char Buffer )
{
unsigned index;
  Nokia_Set_Cursor( 0, 0 );

  for(index = 0; index < 504; index++)
  {
     Nokia_Write( LCD_DATA, Buffer );
  }
}

void Nokia_Out( char row, char col, char *String, char Color )
{
  Nokia_Set_Cursor( col, row );
  
  while(*String)
  {
     Nokia_Chr( *String++, Color );
  }
}

void Nokia_Out_CP( char *String, char Color )
{
  while(*String)
  {
     Nokia_Chr( *String++, Color );
  }
}

void Nokia_Image( const char *Bmp )
{
unsigned i;
    Nokia_Set_Cursor( 0, 0 );

    for (i = 0; i < 504; i++)
    {
      Nokia_Write( LCD_DATA, Bmp[i] );
    }
}

void Nokia_Write_Big_Number( char x, char y, char n, char Color )
{
 char i, chr;
    for(i=0; i < 42; i++)
    {
     if(i % 14 == 0)
     {
       Nokia_Set_Cursor( x, y++ );
     }
  
     chr = BigNumbers[n][i];
  
     if(Color == 0)
     {
       chr = ~chr;
     }
  
     Nokia_Write( LCD_DATA, chr );
    }
}

void Nokia_Write_Med_Number( char x, char y, char n, char Color )
{
  char i, chr;
    for(i=0; i < 24; i++)
    {
      if(i % 12 == 0)
      {
        Nokia_Set_Cursor( x, y++ );
      }
  
      chr = MediumNumbers[n][i];
  
      if(Color == 0)
      {
        chr = ~chr;
      }
       
      Nokia_Write( LCD_DATA, chr );
    }
}

EXEMPLO

#include "bitmap.h"

//copie e cole o código da biblioteca aqui!!
//Ou arquivo externo:
#include "NOKIA3310.C"

sbit Nokia_Clk at RD7_Bit;
sbit Nokia_Data at RD6_Bit;
sbit Nokia_DC at RD5_Bit;
sbit Nokia_RST at RD4_Bit;
sbit Nokia_SCE at RD3_Bit;
sbit Nokia_Clk_Direction at TRISD7_Bit;
sbit Nokia_Data_Direction at TRISD6_Bit;
sbit Nokia_DC_Direction at TRISD5_Bit;
sbit Nokia_RST_Direction at TRISD4_Bit;
sbit Nokia_SCE_Direction at TRISD3_Bit;

void main()
{
   Nokia_Init();
   Nokia_Fill( 0x00 );
   Nokia_Set_Cursor( 0, 3 ); //linha 3, coluna 0
   Nokia_Out_CP( "Microcontrolandos", 0); //cor inversa
   Delay_ms( 3000 );
   Nokia_Image( Logo );
   Delay_ms( 3000 );
   Nokia_Inverse();
}

(30/10/13) - Adicionado fonte para números de tamanho Médio e Grande.

Converter Imagem

Para converter uma imagem para ser mostrada neste display, o compilador MikroC dispõe de uma ferramenta para isso. Selecione o menu TOOLS >> GLCD BITMAP EDITOR >> Nokia 3310.

DOWNLOAD
Biblioteca Completa: NOKIA3310.C
Nokia LCDs para o Proteus: NokiaLCD.zip