Pular para o conteúdo

Uma aplicação bastante imediata que pode ser utiliza em soluções de sinalização visual, é um letreiro composto de matrizes de LEDs. Há displays com arranjo de 8 x 8 LEDs no mercado e, convenientemente, um circuito integrado capaz de efetuar o controle desses displays, o MAX7219 ou MAX7221 da Maxim.


Não há uma solução mecânica imediata para compor letreiros facilmente encontrada no comércio, aqueles que dispõem de, ou ao menos têm aceso a, uma impressora 3D, podem criar a mecânica necessária para abrigar os módulos pré-montados com os displays de matriz de LEDs e o MAX7219, assim a criatividade maker tem de entrar em ação na maioria das vezes.

Como muitas das publicações aqui do Blá do Chico são eminentemente teóricas ou didáticas, para variar uma publicação com caráter prático vem bem a calhar para quebrar esse formalismo todo.

Vamos ver primeiro o módulo de matriz de LEDs a ser usado...

Na parte inferior existe o conector de entrada de controle que conta com cinco pinos: VCC, GND, Din (Data Input); CS (Chip Select); e CLK (Clock), na parte superior o conector de saída de controle com os mesmo sinais, exceto o Dout (Data Out) ao invés do Din. O módulo tem como componente central o MAX7219 que pode ser conectado ao controlador por um barramento SPI (não 100% compatível, porém operativo). Os capacitores são para melhorar a condição de flutuação da alimentação devido ao chaveamento dos 64 LEDs da matriz (não montada na imagem). O resistor de 10kohm regula a intensidade de corrente fornecida para os diversos LEDs individualmente. Em suma é um módulo bastante simples e que pode ser ligado em “cascata” com outros módulos iguais (normalmente não mais que 8 deles).

Os módulos devem ser arranjados lado a lado para dar continuidade ao deslocamento do texto que for exibido, como ilustra a imagem a seguir.

Por comodidade usaremos apenas três módulos de matriz de LEDs em nossa montagem.

Para fixa-los de forma muito, muito barata foi utilizado um material bastante não convencional para essa finalidade, palitos de sorvete (como os usado em trabalhos manuais) que se compra aos centos por algo como R$ 5,00 em papelarias ou lojas de artesanato.

Mais a diante será mostrada a solução mecânica aplicada, mas antes vejamos a lista de materiais utilizados:

 1 Arduino UNO R3
 3 Módulos Matriz de LED 8x8 com MAX7219
 6 Parafusos M2,5 x 8
 6 Parafusos M2,5 x 16
18 Porcas M2,5
 3 Cabos multi-vias com cinco vias e conectores Dupont fêmea em
   todas as terminações
 4 Palitos de sorvete de 10,5 x 1 cm

Segue ilustração com todo o material acima relacionado a ser utilizado na montagem. No entanto, será necessário também ter disponível um cabo USB com conectores machos A e B em cada extremidade além de um microcomputador com a IDE do Arduino instalada para efetuar a programação do mesmo.

Vamos ao preparo da mecânica “criativa” para nossa montagem.

A planta mais abaixo mostra as dimensões de corte e furação dos palitos de sorvete que deve ser providenciada.

Será muito prático efetuar a furação toda de uma só vez arranjando os palitos em um sanduíche com os quatro palitos, seguros por grampos de carpinteiro (de dimensões adequadas ao material). São seis furos feitos com broca de três milímetros, de forma que a eventual imprecisão seja compensada pela dimensão a maior de 0,5 mm no diâmetro de cada conjunto de furos.

Após a furação dois dos palitos serão cortados em quatro partes como mostrado na planta e depois de dado o acabamento necessário, serão então montados dois suportes, cada um como o mostrado na ilustração a seguir.

Este arranjo foi planejado de tal forma que o palito segmentado sirva de espaçador para que os pontos de solda dos módulos, não toquem o palito base, para não causar torções neste.

Os segmento são colados ao palito base com cola de madeira ou cola instantânea (se utilizar esta última tome precauções para não colar parte de seu corpo ou roupa e muito cuidado com os olhos, o uso de óculo de proteção é fundamental) utilizando os furos como guia de posicionamento.

Na furação superior dos módulo os parafusos de 16 mm de comprimento dever ser fixados previamente inserindo os parafusos pelo lado dos componentes e com um porca em cada, como mostrado na sequência.

Será necessário retirar os displays de matriz de LEDs dos módulos para inserir os parafusos. Após haver inserido e fixado os parafusos de cada módulo, remonte o display de matriz de LEDs. É necessário observar o correto posicionamento do display, sob pena de não funcionamento caso o mesmo seja remontado em posição invertida.

Agora módulo a módulo, iniciando preferencialmente por uma extremidade de arranjo, colocamos os parafusos de 8 mm de comprimento, da face dos componentes do módulo para encaixar um dos suportes, lembrando que os segmentos de palitos espaçadores ficam voltado para a face de solda do módulo e após o suporte uma porca em cada parafuso fixando o módulo ao suporte.

Nesta altura não é necessário, nem recomendável dar aperto, apenas rosqueie manualmente o as porcas nos parafusos até encostarem no suporte.

A figura a seguir mostra como fica a montagem até esta etapa.

Repita estes passos para prender todos os módulos ao suporte inferior.

Agora encaixe o suporte superior nos módulos.

A seguir coloque as porcas nos seis parafusos e verifique que os módulos estão bem acomodados e encaixados e só então de o aperto final nas porcas.

O aperto apropriado é tal que após alcançado o encostamento firme das porcas nos suporte de 1/8 a ¼ de volta adicional é suficiente.

Opcionalmente, para garantir o travamento das porcas, uma pincelada de verniz, ou esmalte, na rosca dos parafusos junto às porcas é uma opção bastante funcional e efetiva.

Após a montagem mecânica, inicia-se a montagem elétrica, pelos cabos de interligação dos módulos, como ilustrado a seguir.

Por fim efetua-se a conexão do módulo da extremidade direita ao Arduino.

Usaremos para tanto o conetor ICSP, conectando o pino 3 do ICSP (Saída digital 13 do Arduino) ao pino CLK do módulo, o pino 2 do ICSP ao VCC do módulo, pino 4 do ICSP (Saída digital 11 do Arduino) ao pino DIN do módulo, e o pino 6 do ICSP ao GND do módulo. O pino CS do módulo deve ser conectado à saída digital 9 do Arduino.

Note que estas conexões são baseadas no código de programação que foi escrita para esta montagem e os pinos DIN, CLK e CS podem ser alterados desde que as mudanças devidas sejam providas no código do Sketch.

A seguir é uma boa ideia verificar o código do sketch e mesmo carrega-lo no IDE do Arduino para verificar se há erros de sintaxe no código.

/*********************************************************************/
/* MAX7219 LED dot matrix test sketch
 * Displays text via up to 8 daisy chained dot matrix LEDs
 *
 * Origin Author:  Marcelo Moraes - Sorocaba/SP-Brazil - July 9th, 2013
 *  http://www.instructables.com/id/16x8-LED-dot-matrix-with-MAX7219-module/
 *  https://code.google.com/p/arudino-maxmatrix-library/        
 *
 * Modified by:    Olaf Meier
 *  Changed some characters and included sketch into my master design
 *
 * Hardware connection:  13  =  CLK
 *                       11  =  Din
 *                       9   =  CS  
 *                       Vcc =  5V * Hardware connection   
 *                       Gnd =  0V * Hardware connection
 */
/*********************************************************************/
/*********************************************************************/
/*
  Declaration of global constants and initialization of variables.
  Add includes.
 */
/*********************************************************************/
/***  Software release and date  ***/
const char* author                =  "Olaf Meier";
const char* revision              =  "R.0.1";
const char* date                  =  "2012/09/28";

#if ARDUINO < 100
#include <WProgram.h>    // Add other libraries on demand as requested
#else
#include <Arduino.h>     // Needed when working with libraries
#endif

/*********************************************************************/
/*
  Declare constants and variables for the optional serial monitor for
  debugging.
 */
int debug=0; // Debug counter; if set = 1, will write values via serial
const unsigned int baudRate = 9600; // Baud rate for the serial monitor

/*
  Declare constants and variables for the dot matrix display.
  Include Libraries
 */
#include <MaxMatrix.h>
//#include <avr/pgmspace.h>

/*
  Hardware connection. Dasiy chain DOUT with DIN of the next module
 */
int data     =  11;           // (13) DIN pin of MAX7219 module
int load     =  9;            // (10) CS pin of MAX7219 module
int clock    =  13;           // (9) CLK pin of MAX7219 module

/***  Number of used MAX7219 dot matrix modules  ***/
int maxInUse =  3;

/***  Initialize MAX7219 library  ***/
MaxMatrix m(data, load, clock, maxInUse);

byte buffer[100];

/***  Table according ASCII chart 32..127  ***/
/***  Initialize Sprite starting with number of rows from total.  ***/
PROGMEM const byte CH[] = {
3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ bkslh
2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
4, 8, B01111110, B01001000, B01001000, B00110000, B00000000, // b
4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
3, 8, B00001000, B01111100, B00001010, B00000000, B00000000, // f
4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
};

/***  Create the needed sentenses  ***/
char string110[]="Bla do Chico rolando mensagem em matriz de LEDs com o MAX7219       ";

/*********************************************************************/
void setup() {
  Serial.begin(baudRate);        // ...set up the serial output

  /***  Optional Debug routine via serial monitor  ***/
  if (debug) {  // To see some values for debugging in general...
    /***  Start class Serial with function/method begin(9600)  ***/
    /***  Instance variable .dot operator. method  ***/
    Serial.println("Debugging activated");
  }                                              // End of debug

  /***  Show software release  ***/
  Serial.println();
  Serial.print(author);
  Serial.print("\t");
  Serial.print(revision);                        
  Serial.print("\t");
  Serial.println(date); 
  Serial.println();

/*********************************************************************/
  m.init();                     // Initialize module
  m.setIntensity(2);            // Dot matix intensity 0-15

} // End of void setup()

/*********************************************************************/
void loop() {
/*
  Display the active sentence. printStringWithShift(string_, delay)
 */
  printStringWithShift(string110, 125);
} // End of void loop()


/*********************************************************************/
void printCharWithShift(char c, int shift_speed){
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CH + 7*c, 7);
  m.writeSprite(32, 0, buffer);
  m.setColumn(32 + buffer[0], 0);
  for (int i=0; i<buffer[0]+1; i++)
  {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
}


/*********************************************************************/
void printStringWithShift(char* s, int shift_speed){
  while (*s != 0){
    printCharWithShift(*s, shift_speed);
    s++;
  }
}

Código inserido e verificado, podemos conectar o Arduino à interface USB do computador e efetuar o upload do programa.

Após a carga e iniciação da execução do código teremos nosso letreiro operativo, como mostrado a seguir:

Para alterar a mensagem exibida basta editar o sketch, mais especificamente a linha:

char string110[]="...SUA MENSAGEM AQUI...";

Lembrando que o gerador de caracteres não dá suporte a caracteres acentuados e cedilha.

Daqui por diante o que pode ser dito é: BOA DIVERSÃO!

Introdução

Ao longo do tempo os equipamentos têm agregado mais e mais funções, a utilização de circuitos integrados é cada vez mais comum e intensa. A implantação de barramentos de comunicação paralelos está cada vez mais inviável pela complexidade e quantidade das conexões, de forma que a comunicação serial entre os dispositivos se torna uma necessidade bastante presente.

O estabelecimento de linhas de transmissão de dados mais simples em si justifica amplamente a seleção da modalidade serial se comparados os problemas inerentes de linhas de transmissão paralelas, com os inevitáveis problemas de intermodulação entre as muitas linhas de sinal.

As técnicas disponíveis de interligação serial entre dispositivos podem ser classificadas em duas grandes categorias, a comunicação assíncrona e a comunicação síncrona. Nestas três métodos tem ocupado posições de destaque:

  • Universal Asynchronous Receiver Transmitter – UART;
  • Serial Peripheral Interface – SPI; e
  • Inter Integrated Circuit – I2C

Há grande familiaridade com o comunicação serial assíncrona por meio do padrão UART (RS-232C). Mas há grandes vantagens na utilização de comunicação serial síncrona ao invés da assíncrona. Além disso, há grandes diferenças entre protocolos síncronos. Apesar de cada protocolo definir limites máximos de taxas de transferência, os diversos fabricantes têm liberdade em desenvolver dispositivos com velocidades próprias. Abaixo uma tabela consolida um comparativo simples entre padrões de dispositivos seriais.

Tabela 1: Comparativo de padrões seriais

Tecnologia Barramento de comunicação Taxa de transferência máxima Fluxo de dados
UART (RS-232) 2 115k2bps Half ou Full Duplex
SPI 3+n escravos 2Mpbs Full Duplex
I2C 2 a 127 dispositivos 400kpbs Half Duplex

 

Há diversos exemplos no mercado mostrando que estes limites podem ser ultrapassados, por exemplo, memórias SPI que podem chegar a 66Mbps e I2C até 1Mbps.

A comunicação síncrona define o conceito de Master/Slave (Mestre - Escravo). Normalmente, o gerador do sinal de sincronismo é o Mestre da comunicação. Os dispositivos que utilizam o sinal de sincronismo são definidos como Escravos. A conexão mais comum desse tipo de comunicação é um Mestre e vários Escravos.

Agrupamento Mestre / Escravos
Figura 1: Mestre e Escravos

Comunicação SPI

A comunicação SPI tem algumas características basilares. Primeiro os sinais de comunicação têm sentido fixo e definido. Isso implica em sempre haver dois transistores definindo o estado de um pino (estágio de saída Push-Pull). Essa característica é um grande diferencial com outros padrões de comunicação serial como I2C e OneWire, que têm o mesmo barramento de dados para os sinais de entrada saída através do esquema de open-drain (Pull-Up).

Estágios de saída e máscara de sinal
Figura 2: Estágios de saída e forma de onda

Apesar de utilizar duas vias de comunicação ao invés de uma, é possível atingir velocidades maiores, pois há menor deformação do sinal como mostrado na Figura 2 acima.

Outra característica é que toda troca de dados ocorre sempre em ambas as direções. Ou seja, a cada bit enviado do Mestre para o Escravo corresponde um bit no caminho oposto, caracterizando uma comunicação sempre Full Duplex.

Os pinos básicos de comunicação entre dispositivos SPI e o esquema padrão de conexão para escravos independentes são como abaixo:

Tabela 2: Configuração de pinos da conexão SPI

Pino Nome Significado Nomes Alternativos
Mestre para Escravo MOSI Master Output Slave Input SDO, DOut, SO
Escravo para Mestre MISO Master Input Slave Output SDI, DIn, SI
Clock SCLK Serial Clock SCK, CLK
Seleção de Escravo SS Slave Select CS, nSS, nCS

 

Conexão de escravos independentes
Figura 3: Diagrama de conexão Mestre - Escravos (escravos independentes)

O sinal SS funciona selecionando escravos (um por vez). É um sinal ativo em nível lógico baixo, o que implica em lógica de seleção negativa no escravo. Porém muitos dispositivos utilizam este sinal como sincronismo de quadro (frame). Isto denota a importância de respeitar este sinal.

Alternativamente, é possível vincular os escravos efetuam uma conexão Daisy chain, ou encadeada, onde todos os escravos são simultaneamente selecionados e a saída de um escravo é conectada a entrada do próximo. A porta SPI de cada escravo é projetada para enviar durante o segundo grupo de pulsos de clock uma cópia exata de os dados que recebeu durante o primeiro grupo de pulsos de clock. A cadeia com um todo funciona tal qual um único shift-register. O encadeamento em margarida, geralmente, é feito para fornecer um bando de entradas ou saídas por meio de SPI. Cada escravo copia a entrada para a saída no próximo ciclo de clock até que a linha SS ativa baixa seja feita alta. Desta forma apenas uma única linha SS é requerida do mestre, ao invés de uma linha SS exclusiva para cada escravo.

Conexão de escravos encadeados
Figura: 4: Diagrama de conexão Mestre - Escravos (escravos encadeados)

Princípio de funcionamento

O princípio básico de um dispositivo SPI é o registrador de deslocamento (shift-register). Esse dispositivo faz a serialização de um dado paralelo de acordo com o clock. Da forma análoga é capaz de efetuar o oposto, recebendo uma cadeia seriada de bits e convertendo-a em um dado paralelo.

Fluxos internos e externos de um shift-register
Figura 5: Operação do shift-register

A interface não é apenas capacitada a fazer a conversão serial/paralelo, também conta com o gerador de clock (no elemento mestre) entre 10KHz e 100MHz, o controle para troca do frame e o slave-select. Constituindo assim um dispositivo de comunicação completo. Na Figura 6 abaixo podemos observar como é disposto

Disposição da SPI
Legenda 6: Arquitetura SPI

Sincronismo do Sinal de Relógio

Com a sincronização em mente, a função d Mestre não termina simplesmente com a geração de pulsos de clock em certa frequência. Na verdade, Mestre e Escravo devem operar num protocolo de sincronização em particular, ou os dados serão perdidos. A comunicação SPI é flexível permitindo a configuração de polaridade e de fase do clock. Aqui entram os conceitos de polaridade (CPOL) e de fase CPHA do clock.

CPOL – Polaridade do clock (Clock POLarity) determina o valor base do clock, isto é, o seu valor quando o barramento está ocioso.

  • Com CPOL = 0, o valor base do relógio é zero, ou seja, SCLK é “baixo” quando a comunicação está ociosa;
  • Com CPOL = 1, o valor base do relógio é um, ou seja, SCLK é “alto” quando a comunicação está ociosa.

CPHA – Fase de clock (Clock PHAse) determina em qual transição do clock os dados serão amostrados (capturados).

  • Com CPHA = 0, os dados são amostrados na borda de subida do clock;
  • Com CPHA = 1, os dados são amostrados na borda de descida do clock.

Dessa forma os modos possíveis são quatro mostrados na Tabela 3 a seguir:

Tabela 3: Modos de operação do clock

Modo CPOL CPHA Borda de troca Transição Nível em IDLE
0 0 0 Subida Meio do bit 1
1 0 1 Descida Começo do bit 0
2 1 0 Descida Meio do bit 0
3 1 1 Subida Começo do bit 1

Outra característica fundamental na comunicação é a definição da posição do bit mais significativo (MSB). Através de DORD é possível definir que o bit mais significativo será o primeiro (DORD=0), ou o último (DORD=1) bit transacionado. É possível observar todas essas características através dos dois diagramas de tempo a seguir:

Diagrama de tempos da operação SPI com fase tipo 0
Figura 7: Formato de Transferência com CPHA em 0

Fonte: <http://maxembedded.com/2013/11/serial-peripheral-interface-spi-basics/>

Diagrama de tempos da operação SPI com fase tipo 1
Figura 8: Formato de Transferência com CPHA em 1

Fonte: <http://maxembedded.com/2013/11/serial-peripheral-interface-spi-basics/>

Prós e Contras

Vantagens

  • Comunicação full duplex na versão padrão do protocolo;
  • Os acionadores push-pull fornecem boa integridade de sinal e alta velocidade, em oposição ao dreno aberto;
  • Maior rendimento do que I2C ou SMBus. Não se limita a qualquer velocidade máxima de clock, permitindo potencialmente alta velocidade;
  • Flexibilidade total do protocolo para os bits transferidos;
    • Não se limita a palavras de 8 bits;
    • Escolha arbitrária de tamanho, conteúdo e finalidade da mensagem;
  • Interface de hardware extremamente simples;
    • Requisitos de energia típicos mais baixos do que no I2C ou SMBus devido a menor quantidade de circuitos (incluindo resistores pull up);
    • Sem arbitragem ou modos de falha associados - ao contrário do barramento CAN
    • Escravos usam o relógio do mestre e não precisam de osciladores de precisão
    • Escravos não precisam de um endereço único - ao contrário do I2C, GPIB ou SCSI;
    • Transceptores não são necessários - ao contrário do barramento CAN;
  • Usa apenas quatro pinos de circuitos integrados e conecta layouts com menos fios ou conectores. Muito menos que interfaces paralelas;
  • Apenas um sinal de barramento exclusivo por dispositivo (chip select) todos os outros são compartilhados;
  • Os sinais são unidirecionais, permitindo fácil isolamento galvânico;
  • Implementação simples de software.

Desvantagens

  • Requer mais pinos de circuitos integrados do que I2C, mesmo na variante de três fios;
  • Nenhum endereçamento in-band; sinais de seleção extras ao barramento são necessários para barramentos compartilhados;
  • Nenhum controle de fluxo por hardware pelo escravo (mas o mestre pode atrasar a próxima borda do relógio para diminuir a taxa de transferência);
  • Nenhum reconhecimento de escravo por hardware (o mestre pode estar transmitindo para lugar nenhum e não sabe);
  • Normalmente suporta apenas um dispositivo mestre (depende da implementação de hardware do dispositivo);
  • Nenhum protocolo de verificação de erros é definido;
  • Sem um padrão formal, validar a conformidade não é possível;
  • Lida somente com distâncias curtas em comparação com RS-232, RS-485 ou CAN-bus; (Sua distância pode ser estendida com o uso de transceptores como o RS-422.)
  • Opto-isoladores no caminho do sinal limitam a velocidade do clock para a transferência do MISO devido aos atrasos adicionados entre o clock e os dados;
  • Muitas variações existentes, dificultando a localização de ferramentas de desenvolvimento, como adaptadores de host que suportem essas variações;
  • O SPI não suporta hot swapping (adição dinâmica de nós);
  • As interrupções devem ser implementadas com sinais extras ao barramento ou falsificadas usando-se de pollings periódicos de maneira similar ao USB 1.1 e 2.0;
  • Algumas variantes, como o SPI duplo, quad SPI e os barramentos seriais de três fios, são half duplex.

Mais sobre e assuntos correlatos

  • Arquivos Comunicação SPI. Disponível em <https://www.embarcados.com.br/serie/comunicacao-spi/> acessado em 15/jul./2019
  • Comunicação SPI – Parte 1. Disponível em <https://www.embarcados.com.br/spi-parte-1/> acessado em 15/jul./2019
  • Comunicação SPI – Parte 2. Disponível em <https://www.embarcados.com.br/comunicacao-spi-parte-2/> acessado em 15/jul./2019
  • Serial Peripheral Interface – SPI Basics. Disponível em <http://maxembedded.com/2013/11/serial-peripheral-interface-spi-basics/> acessado em 15/jul./2019
  • Wikipédia. Serial Peripheral Interface. Disponível em <https://en.wikipedia.org/wiki/Serial_Peripheral_Interface> acessado em 15/jul./2019
  • Comunicação SPI – Parte 3 – Microcontrolador AT89S8253 + EEPROM 25LC256. Disponível em <https://www.embarcados.com.br/comunicacao-spi-parte-3-at89s8253/> acessado em 15/jul./2019
  • Mundo Projetado. Comunicação Serial Assíncrona. Disponível em <http://mundoprojetado.com.br/comunicacao-serial-assincrona/> acessado em 15/jul./2019
  • Mundo Projetado. SPI. Disponível em <http://mundoprojetado.com.br/spi/> acessado em 15/jul./2019
  • Mundo Projetado. I²C. Disponível em <http://mundoprojetado.com.br/i2c/> acessado em 15/jul./2019
  • Mundo Projetado. RS-485. Disponível em <http://mundoprojetado.com.br/rs-485/> acessado em 15/jul./2019
  • Mundo Projetado. Modbus RTU – O que é e como funciona. Disponível em <http://mundoprojetado.com.br/modbus-rtu-o-que-e-e-como-funciona/> acessado em 15/jul./2019
  • Mundo Projetado. Implementando Modbus RTU no Arduino. Disponível em <http://mundoprojetado.com.br/implementando-modbus-rtu-no-arduino/> acessado em 15/jul./2019
  • Hélio Sousa Mendonça. Disponível em <https://paginas.fe.up.pt/~hsm/docencia/comp/uart/> acessado em 15/jul./2019
  • Hélio Sousa Mendonça. SPI e I2C. Disponível em <https://paginas.fe.up.pt/~hsm/docencia/comp/spi-e-i2c/> acessado em 15/jul./2019
  • MC68HC11A8 Techinical Data – Serial Peripheral Interface. Disponível em <http://ee.hawaii.edu/~tep/EE491E/Notes/HC11A8/HC11A8_SPI.pdf> acessado em 15/jul./2019
  • Texas Instruments. KeyStone Architecture Serial Peripheral Interface. Disponível em <http://www.ti.com/lit/ug/sprugp2a/sprugp2a.pdf> acessado em 15/jul./2019

Referências

Embarcados. Arquivos Comunicação SPI. Disponível em <https://www.embarcados.com.br/serie/comunicacao-spi/> acessado em 15/jul./2019



Embarcados. Comunicação SPI – Parte 1. Disponível em <https://www.embarcados.com.br/spi-parte-1/> acessado em 15/jul./2019



Embarcados. Comunicação SPI – Parte 2. Disponível em <https://www.embarcados.com.br/comunicacao-spi-parte-2/> acessado em 15/jul./2019



maxEmbedded. Serial Peripheral Interface – SPI Basics. Disponível em <http://maxembedded.com/2013/11/serial-peripheral-interface-spi-basics/> acessado em 15/jul./2019



Wikipédia. Serial Peripheral Interface. Disponível em <https://en.wikipedia.org/wiki/Serial_Peripheral_Interface> acessado em 15/jul./2019