Edição atual tal como às 17h15min de 21 de fevereiro de 2020

Projeto no Github Classroom

Um protocolo de comunicação está relacionado aos mecanismos necessários para a entrega de mensagens entre duas aplicações quaisquer. Considerando uma arquitetura de redes em camadas como TCP/IP, protocolos de comunicação correspondem às camadas de enlace até transporte. Questões como garantia de entrega, controle de sequência, tratamento de erros, sincronização, estabelecimento e término de sessão, multiplexação e delimitação de mensagens, entre possivelmente outras, fazem parte do projeto de tais protocolos. Para introduzir o projeto de um protocolo de comunicação, o primeiro projeto da disciplina envolve um protocolo para estabelecimento de enlace sem-fio ponto-a-ponto.

Considere o caso de uma nova interface de rede sem-fio composta por um transceiver RF capaz de transmitir a distâncias de até 1 km. No caso de distâncias como essa, a taxa de transmissão possível de ser obtida é de 2400 bps, porém distâncias menores possibilitam taxas maiores, até um máximo de 19200 bps. Esse transceiver pode ser usado como uma interface serial do tipo UART. Portanto, com ele podem-se criar enlaces de média distância e baixas taxas de transmissão.

O transceiver RF usado como UART proporciona uma camada física, cuja interface de acesso a serviço oferece operações de envio e recepção de bytes. Nenhuma facilidade para delimitação de mensagens, endereçamento, sincronização e tratamento de erros é fornecida. De fato, tais serviços devem ser implementados em um protocolo de enlace que use esse transceiver como camada física.

O projeto 1 envolve o desenvolvimento de um protocolo de comunicação usando esse transceiver RF, de forma a oferecer um serviço de comunicação com essas características.

Um primeiro experimento

O primeiro contato com o transceiver RF envolve escrever um programa que transmita a mensagem Hello world! de um computador a outro usando um enlace sem-fio. Para isso, deve-se:

Configurar dois transceivers RF
Conectá-los a dois computadores diferentes usando adaptadores USB
Escrever um programa que se comunique por meio dos transceivers.

A serial modelada como uma classe C++

Uma implementação da classe Serial

#ifndef SERIAL_H
#define	SERIAL_H

#include <termios.h>

class Serial {
public:
    Serial();
    Serial(const char * path, int rate);
    Serial(const Serial& orig);
    virtual ~Serial();
    int get() { return tty_fd;}
    bool cca();
    int write(const char * buffer, int len);
    int read(char * buffer, int len);
    int read(char * buffer, int len, bool block);    
    char read_byte();
private:
    int tty_fd;
};

#endif	/* SERIAL_H */

serial.h

#include <iostream>
#include "Serial.h"

using namespace std;

int main() {
  Serial rf("/dev/ttyUSB0", B9600);
  string msg = "um teste ...\r\n";
  char buffer[32];

  int n = rf.write(msg.c_str(), msg.size());

  cout << "Enviou " << n << " bytes" << endl;

  n = rf.read(buffer, 32);

  cout << "Recebeu " << n << " bytes: ";

  cout.write(buffer, n);

  cout << endl;
}

main.cpp: exemplo de uso da classe serial

Para compilar este exemplo, deve-se usar esta linha de comando:

g++ -std=c++11 -o p1 main.cpp Serial.cpp -I.

Emulador de link serial

O programa serialemu emula um link serial com determinada taxa de bits, BER e atraso de propagação. Para usá-lo deve-se fazer o seguinte:

Obtenha o código-fonte do serialemu
Descompacte o arquivo Serialemu.zip, e entre no subdiretório Serialemu.
Compile-o com este comando:
```
aluno@M2:~/Serialemu$ make
```
Copie o programa compilado para algum subdiretório mais conveniente ... por exemplo, /home/aluno, e depois mude para esse subdiretório:
```
aluno@M2:~/Serialemu$ cp -a dist/Debug/GNU-Linux/serialemu /home/aluno/
aluno@M2:~/Serialemu$ cd /home/aluno
aluno@M2:~/$
```

Execute-o de forma que ele apresente suas opções de execução:

aluno@M2:~$ ./serialemu -h
Uso: ./serialemu [-b BER][-a atraso][-f][-B taxa_bits] | -h

BER: taxa de erro de bit, que deve estar no intervalo  [0,1]
atraso: atraso de propagação, em milissegundos.
taxa_bits: taxa de bits em bits/segundo
-f: executa em primeiro plano (nao faz fork)

Execute-o então da forma desejada, selecionando a taxa de bits (default: ilimitada), BER (default: 0) e atraso de propagação (default: 0). O serialemu automaticamente vai para segundo plano (daemonize), liberando o terminal. Ex:
```
aluno@M2:~$ ./serialemu -B 9600
/dev/pts/17 /dev/pts/2
aluno@M2:~$
```
... e anote os dois caminhos informados pelo serialemu: eles são as duas portas seriais que correspondem às pontas do link serial emulado.
Execute seu protocolo usando essas portas seriais virtuais.

Mesma que se opte pelo uso do emulador de serial, deve-se notar que, ao final, o protocolo deve ser demonstrado na plataforma Linux com o transceiver RF. Assim, o uso do emulador de serial tem por finalidade somente facilitar o desenvolvimento dos mecanismos básicos do protocolo.

O transceiver RF APC 220

O transceiver RF a ser utilizado se chama APC 220. Alguns documentos podem ser úteis:

O transceiver NRF24L01

Comandos AT:

AT Commands
Baudrate : AT+BAUD=n where n =  1-6 (1:4800,2:9600,3:14400,4:19200,5:38400,6:115200) (default 9600Kbps)
NRF Rate : AT+RATE=n where n =  1-3 (1:250K, 2:1M, 3:2M ) (default 2Mbps)
Local Address : AT+RXA=0Xnn,0Xnn,0Xnn,0Xnn,0Xnn where nn are the local receiving address (default 0xff,0xff,0xff,0xff,0xff)
Target Address  : AT+TXA=0Xnn,0Xnn,0Xnn,0Xnn,0Xnn where nn are the target address
Operating Freq. : AT+FREQ=2.nnnG where nnn = 400 / 525 (default 2.400G)
Checksum mode : AT+CRC=n where n = 8 /16 (default : 16 bit)
System info : AT?

Início do protocolo de enlace

DICA: Ver capítulo 11 do livro "Comunicação de Dados e Redes de Computadores", de Behrouz Forouzan, ou capítulo 5 do livro "Redes de Computadores" de Andrew Tanenbaum.

O protocolo de enlace a ser desenvolvido se destina a links com baixa taxa de transmissão e suscetíveis a erros frequentes. As mensagens são curtas (<= 1024 bytes), e transmitidas de forma confiável. Antes de de fato especificar esse protocolo, pode ser útil primeiro tentar transmitir mensagens de forma unidirecional, sem qualquer controle de erros. Essa é a função mais básica do protocolo, pois implica delimitar mensagens enviadas e recebidas.

O enquadramento (framing) é uma função do protocolo de enlace responsável por delimitar quadros na interface com a camada física. Deve-se ter em mente que a camada física oferece um serviço de envio e recepção de sequências de bytes sem qualquer estrutura. Cabe à camada de enlace delimitar as unidades de dados de protocolo (PDU) dentro dessas sequências de bytes.

Existe mais de uma abordagem para delimitar quadros (ver mais no capítulo 11 de Data Communications and Computer Networks, de Behoruz Forouzan, e capítulo 5 de Redes de Computadores e a Internet, de James Kurose e Keith Ross):

Abordagem	Descrição	Exemplos
Quadros de tamanho fixo / duração definida	Quadros têm sempre mesmo comprimento ou duração	ATM, TDMA-based
Sentinela	padrão de bits/bytes delimita quadros	PPP, HDLC
Contador / duração	Cabeçalho contém duração ou comprimento do quadro	IEEE 802.11
Presença/ausência de portadora	Ausência de portadora delimita quadros	IEEE 802.11, IEEE 802.3

Implementação do enquadramento

A técnica de enquadramento escolhida é a do tipo sentinela. Mais especificamente, escolheu-se a versão dessa técnica implementada pelo protocolo PPP:

Usa-se a flag 7E (01111110) como delimitador de quadros
Usa-se um byte de escape 7D (01111101) para preenchimento de octeto
O transmissor deve fazer pelo menos o escape dos bytes 7E e 7D que aparecerem no conteúdo do quadro
- Cada byte que sofrer o escape deve ser modificado por meio de um XOR 20. Ex: se o byte a sofrer escape for 7E, ele deve ser modificado para 5E (7E XOR 20 = 5E).

Uma máquina de estados para o receptor é esta:

Versão alternativa da MEF

Além disso, uma possível implementação dessa função do protocolo poderia ser esta:

#ifndef FRAMING_H
#define FRAMING_H

#include <cstdint>
#include "Serial.h"

class Enquadramento {
 public:
  Enquadramento(Serial & dev, int bytes_min, int bytes_max);
  ~Enquadramento();
 
  // envia o quadro apontado por buffer
  // o tamanho do quadro é dado por bytes 
  void envia(char * buffer, int bytes);
 
  // espera e recebe um quadro, armazenando-o em buffer
  // retorna o tamanho do quadro recebido
  int recebe(char * buffer);
 
 private:
  int min_bytes, max_bytes; // tamanhos mínimo e máximo de quadro
  Serial & porta;  
  char buffer[4096]; // quadros no maximo de 4 kB (hardcoded)
 
  enum Estados {Ocioso, RX, ESC};
 
  // bytes recebidos pela MEF até o momento  
  int n_bytes; 
 
  // estado atual da MEF
  int estado;
 
  // aqui se implementa a máquina de estados de recepção
  // retorna true se reconheceu um quadro completo
  bool handle(char byte);
 
};

#endif

A implementação da máquina de estados

A declaração acima sugere implementar a MEF a partir do método handle da classe Enquadramento. Esse método deve ser executado para cada byte recebido, representando o tratamento de um evento pela MEF. Uma forma usual e direta de implementar uma MEF faz uso de uma estrutura do tipo switch-case. Essa abordagem se baseia em um modelo de programação estruturada. Basicamente ele depende de um algoritmo que executa um procedimento do sistema dependendo de seu estado atual e do evento. A seleção do procedimento se faz com uma estrutura switch-case. O exemplo abaixo mostra o esqueleto de uma MEF implementada usando essa técnica.

// o tratador de eventos de uma MEF hipotética
// A MEF aqui representada nada faz de útil ... 
bool Enquadramento::handle(char byte) {
  switch (estado) {
    case Ocioso: // estado Ocioso
      estado = RX; // muda para RX
      break;
    case RX: // estado RX
      estado = ESC; // muda para ESC
      break;
    case ESC: // estado ESC
      estado = Ocioso; // muda para Ocioso
      break;
  }
}

Atividade

Transmissor e receptor compilados

Implemente a MEF de recepção do enquadramento

Escreva um programa que transmita pela serial sequências de caracteres como estas:

~abcedf1234567~
~abcedf}^1234567~
~abcedf012}]9876~
~}]}^}]}]}]}^}^}^}]}]}]~

... e use seu programa de recepção para recebê-las pela serial e identificar os quadros recebidos. Use o serialemu para conectar as seriais desses dois programas. Você pode usar o seguinte programa para transmitir as sequências de bytes:

#!/usr/bin/python3

from serial import Serial
import sys

try:
  porta = sys.argv[1]
  quadro = sys.argv[2]
except:
  print('Uso: %s porta_serial quadro' % sys.argv[0])
  sys.exit(0)

try:
  p = Serial(porta)
except Exception as e:
  print(e)
  sys.exit(0)

pld = quadro.encode('ascii')

n = p.write(pld)
print('Enviou %d bytes: %s' % (n, quadro))

sys.exit(0)

Escreva o método envia da classe Enquadramento, e modifique o programa de teste de envio para usá-lo para transmitir sequências arbitrárias de bytes.
Teste a capacidade de recuperar o sincronismo da técnica de enquadramento escolhida. Para isso, modifique o programa de teste para que, propositalmente, transmita quadros com erro de delimitação.

Mudanças entre as edições de "PTC29008: Projeto 1: um protocolo de comunicação"