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

 

Devido à dificuldade em decorar diversos endereços IP, sejam eles IPv4 ou IPv6, existe o DNS (Domain Name System ou em português Sistema de Nomes de Domínios), que é um protocolo para representar os endereços sob a forma de nomes humanamente legíveis e substancialmente mais fáceis de serem decorados.

Um pouco da história do DNS

Nos anos 1970 a ARPANet era uma rede com algumas centenas de hosts e o mapeamento dos nomes destes hosts com seu endereço era mantido em um arquivo, sugestivamente, chamado “hosts”. Este arquivo ainda é utilizado e você pode encontra-lo nos seguintes diretórios de sistemas Windows e Linux:

Windows: C:\Windows\System32\drivers\etc\hosts

Linux: /etc/hosts

Por se tratar de um arquivo texto simples sem formatação, é possível edita-lo com qualquer editor de textos.

O problema do arquivo hosts é que ele deve estar em todos os computadores de uma rede, e como a rede é algo que pode mudar, ou seja é dinâmica, onde máquinas são incluídas e excluídas com frequência, a manutenção do arquivo hosts torna-se trabalhosa.

Com o crescimento das redes, além de sua quantidade, tornava impossível manter o arquivo hosts atualizado e as informações sobre nomes e endereços acabavam se tornando inconsistentes. O arquivo hosts se tornara um grande problema para o crescimento e expansão das redes.

Então pesquisado e estudado um substituto para o arquivo hosts, em 1984 Paul Mockapetris, da Universidade do Sul da Califórnia, divulgou a primeira especificação do DNS nas RFCs (Request For Comments) 882 e 883.

Definição de DNS

O DNS trabalha com domínios, ou seja, cada empresa ou organização é responsável por manter seu próprio banco de dados com as informações sobre os hosts pertencentes ao seu domínio. Este banco deve ser de acesso livre. Assim, qualquer alteração na estrutura do domínio local é rapidamente replicada para outros.

Portanto, o DNS é um banco de dados localmente administrado, mas com dados distribuídos globalmente. Assim, não há mais a necessidade de um arquivo único com os nomes e endereços de todos os hosts do planeta, mas apenas os da sua empresa ou organização.

Arquitetura sistêmica do DNS

Há dois elementos fundamentais na arquitetura do DNS, são eles o nameserver e o resolver.

Nameservers

Nameserver é o programa responsável por armazenar, organizar e distribuir os nomes provenientes do banco de dados local para o resto do mundo. Ele é o responsável por informar o endereço IP ou nome de um host quando solicitado.

O nameserver desempenha o papel de servidor DNS.

Resolver

Resolver é o programa, que inicia a resolução de nomes na rede, ou seja, é ele que contata um nameserver e solicita o endereço IP ou um nome de host da rede.

O resolver tem a função de cliente DNS.

Figura 1: Arquitetura do sistema DNS

Fonte: autoria própria

Hierarquia de nomes

Os nomes de domínio seguem uma hierarquia chamada de namespace, que é o espaço de nomes do DNS.

Existe nesta hierarquia, portanto, um nome principal que chamamos de raiz, e todos os outros nomes devem estar abaixo dele. A representação do namespace se parece com uma árvore invertida, já que a sua raiz começa na parte superior e os galhos (domínios) na parte inferior. Observe a Figura 1: "Namespace representado graficamente",  a seguir:

Figura  2: Namespace representado graficamente

Fonte: autoria própria

Como pode ser observado na Figura 1, o servidor raiz, conhecido como root server, fica no topo da árvore e é representado por um ponto “.”. Os demais domínios vão sendo criados a partir da raiz. Cada domínio pode conter subdomínios, por exemplo, no domínio br temos o subdomínio com, gov, e outros mais. O domínio gov possui os subdomínios sp; rj, entre outros. O domínio sp possui os subdomínios avare; catanduva; e mais tantos outros.

Cada domínio também pode ser chamado de zona, já que um domínio representa uma parte, uma zona, da estrutura como um todo. E cada domínio, ou zona, possui um nome que é a leitura de baixo para cima na estrutura de DNS. Por exemplo o nome do domínio avare é “avare.sp.gov.br.”. Dentro de uma zona podemos ter diversas zonas, conforme a Figura 2: "Representação gráfica de domínio" a seguir.

Obs.: Note-se que o nome do domínio termina por ponto, que representa o root server.

Figura  3: Representação gráfica de domínio

Fonte: autoria própria

Portanto, dentro de uma zona ou domínio teremos os hosts que compõe o domínio como o servidor web, que é costumeiramente chamado de www, ou um servidor de e-mail que pode ser chamado de mail, por exemplo.

Assim o servidor web da zona avare.sp.gov.br. tem o nome www.avare.sp.gov.br.. Este nome completo de domínio chamamos de FQDN (Fully Qualified Domain Name, ou Nome de Domínio Completamente Qualificado em português).

Top-Level Domains

Os nomes de domínio que estão logo abaixo do servidor raiz são chamados de TLDTop Level Domains, ou seja, domínios de nome superior. São os nomes que foram definidos pela IANA como uma forma de tentar organizar os nomes dos domínios de acordo com o segmento da empresa ou organização. Por exemplo, imaginava-se que abaixo do domínio .com haveriam somente empresas comerciais, ou de .edu as empresas relacionadas com a educação e assim por diante. Mas o que aconteceu não foi bem isso, o .com acabou se transformando num dos principais nomes de domínios e todos querem ter o seu nome atrelado a este domínio.

Country-Code Top-Level Domains

Com o passar do tempo a Internet se expandiu e ultrapassou as fronteiras dos países e foram criados os TLDs para todos os países do mundo. É por isso que no Brasil todos os domínios terminam com br. Estes TLDs são conhecidos como ccTLDs (Country-Code Top-Level Domains), ou seja, domínios de nível superior com códigos de países. Estas duas letras que formam o domínio ccTLD foram retirados da norma ISO 3166-1 (ISO 3166-1:2013 - Codes for the representation of names of countries and their subdivisions, leia mais em https://www.iso.org/iso-3166-country-codes.html).

Abaixo destes domínios cada país criou os seus subdomínios, e por uma questão de costume criaram uma estrutura parecida com a definida pela IANA inicialmente, utilizando o .com, .org, .edu, .mil, etc.

No Brasil quem coordena o registro de nomes é o registro.br, portanto, se precisar registrar um nome de domínio no Brasil você deverá recorrer a este organismo (https://registro.br/).

Registro de domínio

Como dito, no Brasil o registro de domínios é operado pelo registro.br, que está ligado do CGI – Comitê Gestor da Internet o qual estabelece as diretrizes estratégicas para uso e desenvolvimento da Internet no Brasil.

Para efetuar o registro de um domínio no Brasil há alguns requisitos a serem cumpridos:

  1. não poderá ser escolhido nome que:
    • desrespeite a legislação em vigor;
    • induza terceiros a erro;
    • viole direitos de terceiros;
    • represente conceitos predefinidos na rede Internet;
    • represente palavras de baixo calão ou abusivas;
    • simbolize siglas de Estados e ou Ministérios.
  2. ter no mínimo 2 (dois) e no máximo 26 (vinte e seis) caracteres;
  3. ser uma combinação de letras e números [a-z;0-9], hífen [-] e os seguintes caracteres acentuados [à, á, â, ã, é, ê, í, ó, ô, õ, ú, ü, ç];
  4. não ser constituído somente de números e não iniciar ou terminar por hífen;
  5. requerente deverá obrigatoriamente:
    • Fornecer os dados válidos do titular do domínio, solicitados nos campos de preenchimento obrigatório do NIC.br. São esses dados:
      1. Pessoas Jurídicas:
        • nome empresarial;
        • número do CNPJ;
        • endereços físico e eletrônico;
        • nome do responsável;
        • número de telefone.
      2. Pessoas Físicas:
        • nome completo;
        • número do CPF;
        • endereços físico e eletrônico;
        • número de telefone.
      3. Informar, no prazo máximo de 14 (quatorze) dias, a contar da data e horário da emissão do ticket para registro de domínio, no mínimo 2 (dois) servidores DNS configurados e respondendo pelo domínio a ser registrado;
      4. Cadastrar e informar:
        • o contato da entidade, o qual deverá ser representado por pessoa diretamente vinculada à atividade de gestão da entidade, e será responsável pela manutenção e atualização dos dados da entidade, pelo registro de novos domínios e pela modificação dos demais contatos do domínio;
        • o contato administrativo, responsável pela administração geral do nome de domínio, o que inclui eventuais modificações e atualizações do contato técnico e de cobrança. Recomenda-se que este seja uma pessoa diretamente vinculada ao quadro administrativo da entidade;
        • o contato técnico, responsável pela manutenção e alteração dos dados técnicos dos servidores DNS. Recomenda-se que este seja representado pelo provedor, caso possua um, ou por pessoa responsável pela área técnica da entidade;
        • o contato de cobrança, responsável pelo fornecimento e atualização do endereço eletrônico para envio dos boletos para pagamentos e cobranças. Recomenda-se que este seja uma pessoa diretamente vinculada ao quadro funcional da entidade;
  6. Pagamento do boleto referente ao período vindouro de manutenção do registro.

Visite o sítio https://dicasdehospedagem.com/ranking-melhores-empresas-de-hospedagem-de-sites-brasil/ para uma ajuda na escolha de onde vai hospedar um sítio.

REFERÊNCIAS

CGI.br. Resolução CGI.br/RES/2008/008/P. Disponível em <https://www.cgi.br/resolucoes/documento/2008/008>, acesso em 28/ago/2018

FOROUZAN, Behrouz A.; e MOSHARRAF, Firouz. Redes de computadores: Uma abordagem top-down. Porto Alegre: bookman, 2013

KOLB, Juliana Jenny. Modelo OSI (Open Systems Interconnection) - Compartilhando. Disponível em <http://jkolb.com.br/modelo-osi-open-systems-interconnection/>, acesso em 28/ago./2018

Wikipédia. Modelo OSI. Disponível em <https://pt.wikipedia.org/wiki/Modelo_OSI>, acesso em 28/ago./2018

1

Redes são um conjunto de máquinas eletrônicas com processadores capazes de trocar informações e partilhar recursos, interligados por um subsistema de comunicação.

Topologia ou Arquitetura de Redes

A topologia de rede é o canal no qual o meio de rede está conectado aos computadores e outros componentes de uma rede. Essencialmente, é a estrutura topológica da rede, e pode ser descrito física ou logicamente. Há várias formas nas quais se podem organizar a interligação entre cada um dos nós (computadores) da rede.

Existem duas categorias básicas de topologias de rede:

  • Topologia física
  • Topologia lógica

Topologia física

A topologia física é a verdadeira aparência da rede, enquanto que a topologia lógica descreve o fluxo dos dados através da rede. A topologia física representa como as redes estão conectadas (layout físico) e o meio de conexão dos dispositivos de redes (nós ou nodos). A forma com que os cabos são conectados, e que genericamente chamamos de topologia da rede (física), influencia em diversos pontos considerados críticos, como a flexibilidade, velocidade e segurança.

  • Ponto a ponto
  • Anel
  • Barramento
  • Estrela
  • Malha
  • Árvore
  • Híbrida
  • Daisy Chain
  • Linear
  • Anel

Atualmente as topologias físicas mais comuns em redes locais são Estrela e Ponto-a-Ponto.

Topologia Lógica

A topologia lógica refere-se à maneira como os sinais agem sobre os meios de rede, ou a maneira como os dados são transmitidos através da rede a partir de um dispositivo para o outro sem ter em conta a interligação física dos dispositivos.

Topologias lógicas são frequentemente associadas ao Media Access Control (ou em português Controle de Acesso ao Meio), métodos e protocolos.

Topologias lógicas podem ser reconfiguradas dinamicamente por tipos especiais de equipamentos como roteadores e switches.

Os tipos de topologia de rede lógica mais comuns são o Broadcast, em que o nó envia seus dados a todos os outros espalhados na rede (Ethernet) e a passagem Token, que controla o envio de dados pela rede (Token Ring).

Ethernet

Ethernet é uma arquitetura de interconexão para redes locais - Rede de Área Local (LAN) - baseada no envio de pacotes. Ela define cabeamento e sinais elétricos para a camada física, em formato de pacotes e protocolos para a subcamada de controle de acesso ao meio (Media Access Control - MAC) do modelo OSI. A Ethernet foi padronizada pelo IEEE como 802.3. A partir dos anos 90, ela vem sendo a tecnologia de LAN mais amplamente utilizada e tem tomado grande parte do espaço de outros padrões de rede como Token Ring, FDDI e ARCNET.

Protocolos TCP e IP

TCP/IP não é propriamente um protocolo, mas um conjunto deles ou uma pilha de protocolos como usualmente se chama. Observe que o próprio nome já se refere a dois protocolos diferentes: TCP (Transmission Control Protocol) e IP (Internet Protocol).

Protocolo TCP

O TCP (acrônimo que significa "Protocolo de Controle de Transmissão") é um dos protocolos sobre os quais assenta a Internet. Ele é complementado pelo Protocolo da Internet (IP), sendo normalmente chamado de TCP/IP. A versatilidade e robustez do TCP tornou-o adequado a redes globais, já que este verifica se os dados são enviados de forma correta, na sequência apropriada e sem erros, pela rede.

O TCP é um protocolo do nível da camada de transporte (camada 4) do Modelo OSI e é sobre o qual que se assentam a maioria das aplicações cibernéticas, como o SSH, FTP, HTTP — portanto, a World Wide Web. O Protocolo de Controle de Transmissão provê confiabilidade, entrega na sequência correta e verificação de erros dos pacotes de dados, entre os diferentes nós da rede, para a camada de aplicação.

Aplicações que não requerem um serviço de confiabilidade de entrega de pacotes podem se utilizar de protocolos mais simples como o User Datagram Protocol (UDP), que provê um serviço que enfatiza a redução de latência da conexão.

Protocolo IP

Protocolo de Internet (em inglês: Internet Protocol, com o acrônimo IP) é usado como o protocolo de comunicação entre todas as máquinas em rede para encaminhamento dos dados. Tanto no Modelo TCP/IP, quanto no Modelo OSI, o importante IP (Protocolo de Internet) situa-se no nível da camada intitulada camada de rede (camada 3).

O IP é o elemento comum encontrado na Internet pública dos dias de hoje. É descrito no RFC 791 da IETF, que foi pela primeira vez publicado em setembro de 1981. Este documento descreve o protocolo da camada de rede mais popular e em uso. Esta versão do protocolo é designada de versão 4, ou IPv4. O IPv6 tem endereçamento de origem e destino de 128 bits, oferecendo mais endereçamentos que os 32 bits do IPv4.

Endereços no IPv4

Endereços IP servem para individualizar equipamentos e permitir que uns localizem os outros na rede.

IPv6 é uma atualização do IPv4 e a diferença entre eles é a quantidade de bits usado no endereçamento, portanto, na capacidade de número de endereços.

O IPv4, desde 1981, é um número de 32bits, formatado em 4 grupos de oito bits cada, chamados de octetos. É escrito em notação decimal pontuada. A capacidade de endereçamento do IPv4 é de no máximo 4.294.967.296 endereços, no entanto há exclusões.

Cada interface pode ter um endereço IP único.

O Internet Protocol faz parte da parte lógica da rede e contém a classe da rede, que pode ser classes: A; B; C; D; ou E.

Classe A B C D E
  Unicast Unicast Unicast Multicast Experimental
Hosts 16.777.216 65.536 256
Redes 256 65.536 16.777.216
IP inicial 0.0.0.0 128.0.0.0 192.0.0.0 224.0.0.0 240.0.0.0
IP Final 127.255.255.255 191.255.255.255 223.255.255.255 239.255.255.255 247.255.255.255

Obs.: A máscara de subrede pode alterar a classe da rede

IP públicos e privados

Endereços IP privados são empregados em redes locais domésticas e empresariais, endereços IP públicos são empregados para acesso à Internet.

Faixas de endereços para redes privadas:

Classe A B C
IP inicial 10.0.0.0 172.16.0.0 192.168.0.0
IP final 10.255.255.255 172.31.255.255 192.168.255.255
Hosts 16.777.216 65.536 65.536

Obs.: A classe B conta com mais uma faixa de endereços privada que é 169.254.x.x (Windows)

Endereços públicos devem ser únicos, portanto, não pode haver mais de um de cada deles, em âmbito mundial.

A distribuição de endereços públicos é regrada e controlada por um organismo não governamental internacional denominado IANA[1]Internet Assigned Numbers Authority (Autoridade de Números Atribuídos na Internet), que entrega as faixas de endereços IP aos RIR – Regional Internet Registry, ou em português Registros Regionais de Internet, que por sua vez distribuem aos ISPs – Internet Service Providers (Provedores de Serviço de Internet).

No Brasil o NIC.br (Núcleo de Informação e Coordenação do Ponto BR) administra a faixa de endereços IP recebida da LACNIC – Latin America and Caribbean Net Information Centre, o RIR da região.

Endereços IPv6

O IPv6 é a evolução do IPv4, no entanto algumas diferenças são observadas.

Os endereços IPv6 são formados por 8 hexadecatetos cada um deles com 16 bits, num total de 2**128 possibilidades de endereços (ou 3,4028237E38), escrito em notação hexadecimal de quatro dígitos por grupo, com os grupos sendo separados por dois pontos (:).

Deixa de existir a máscara de subrede e os quatro primeiros hexadecatetos representam a rede, com os outros quatro representando o host (2**64 = 18.446.744.073.709.551.616 possibilidades tanto para rede, quanto para host), além do que só existem endereços públicos.

Um endereço típico poderia ser então, por exemplo: 0A50:CAFE:0000:0000:0000:0032:0ECD:0001, onde a rede é 0A50:CAFE:0000:0000 e o host é 0000:0032:0ECD:0001.

Em verdade, um número complicado de ser ‘usado’, então por simplicidade existe a notação alternativa para tornar mais fácil o uso do número IPv6, no exemplo seria A50:CAFE::32:ECD:1, bem mais simples.

Como transformar um número, ou endereço, IPv6 de notação completa em notação simplificada? Primeiro eliminar zeros a esquerda, ou seja, 0A50 passa a A50. A seguir sequências de hexadecatetos totalmente zero podem ser simplificadas para duplo dois pontos assim: 0000:0000:0000 resultando em ::, no entanto isso só pode ser feito uma única vez em um mesmo endereço IPv6, conforme nos exemplos a seguir.

0000:0000:0000:0000:0000:0000:0000:0001 = ::1
0A50:0000:0000:0000:0032:0000:0000:0045 = A50::32:0:0:45 ou A50:0:0:0:32::45 (nunca A50::32::45)

REFERÊNCIAS

FOROUZAN, Behrouz A.; e MOSHARRAF, Firouz. Redes de computadores: Uma abordagem top-down. Porto Alegre: bookman, 2013Wikipédia. Modelo OSI.

Wikipédia. Modelo OSI. Disponível em <https://pt.wikipedia.org/wiki/Modelo_OSI>, acesso em 28/ago./2018

-- Protocolo de Internet. Disponível em <https://pt.wikipedia.org/wiki/Protocolo_de_Internet>, acesso em 28/ago./2018

-- Transmission Control Protocol. Disponível em <https://pt.wikipedia.org/wiki/Transmission_Control_Protocol>, acesso em 28/ago./2018


[1] IANA – Internet Assigned Numbers Authority, é hierarquicamente superior a: ARIN – American Registry for Internet Numbers; LACNIC – Latin American and Caribbean Network Information Centre; RIPE - Reseaux IP Europeens Network Coordination Centre; AFRINIC – African Network Information Centre; APNIC - Asia-Pacific Network Information Centre.