teorico 4

Prévia do material em texto

Paradigmas 
de Programação
Responsável pelo Conteúdo:
Prof. Me. Roberto Luiz Garcia Vichinsky 
Revisão Textual:
Revisão Textual: Prof.ª Esp. Kelciane da Rocha Campos
Comunicação de Dados
Comunicação de Dados
 
 
• Apresentar os conceitos fundamentais sobre comunicação de dados;
• Capacitar o estudante a desenvolver programas para o controle de dispositivos microcontrolados.
OBJETIVOS DE APRENDIZADO 
• Introdução;
• Comunicação de Dados - Conceitos Básicos;
• Comunicação Serial;
• Desenvolvimento de um Sistema de Comunicação.
UNIDADE Comunicação de Dados
Introdução
A área de estudo da comunicação de dados é bastante abrangente, adentrando 
principalmente os campos da computação e das telecomunicações. No entanto, o 
nosso estudo será direcionado à comunicação serial, dentro do qual abordaremos 
os aspectos teóricos desse tipo de comunicação e a implementação prática de um 
sistema de comunicação entre o computador e um dispositivo microcontrolado.
Nesse sentido, os conteúdos abordados neste material estão divididos em duas 
partes: [1] conceitos básicos da comunicação de dados e [2] desenvolvimento de um 
sistema de comunicação com o emprego da linguagem C dentro do paradigma da 
programação estruturada.
Comunicação de Dados – Conceitos Básicos
Comunicação de Dados é a disciplina que trata da transmissão e recepção de 
informações entre dois ou mais sistemas computacionais, abrangendo os aspectos 
físicos dos meios de comunicação e as características dos sinais transmitidos.
Um conceito importante dessa disciplina diz respeito aos canais de comunicação, 
que são os caminhos sobre os quais as informações podem trafegar. Esses caminhos 
podem ser linhas físicas constituídas por fios, o que chamamos de comunicação 
wired (com fio), ou linhas baseadas em fontes de energia radiante, como ondas de 
rádio, laser, entre outras, o que chamamos de comunicação wireless (sem fio).
Independentemente da constituição dos canais de comunicação, sejam eles base-
ados em linhas com fio ou sem fio, podemos ainda classificá-los conforme a maneira 
como a comunicação é realizada, podendo ser: Simplex, Half-Duplex e Full-Duplex.
Canal Simplex
Neste tipo de canal, as transmissões podem ser feitas apenas em um único sen-
tido, partindo de um dispositivo emissor para um ou mais dispositivos receptores. 
Como exemplos desse tipo de canal, podemos citar as emissoras de rádio ou de 
televisão, conforme ilustra a Figura 1.
Figura 1 – Exemplo de canal Simple
Fonte: Adaptado de Getty Images
8
9
Canal Half-Duplex
A transmissão pode ser feita nos dois sentidos, mas alternadamente, ou seja, 
quando um dos dispositivos está transmitindo, ele não pode receber dados e quando 
está recebendo, ele não pode transmitir, isto é, um dispositivo não pode transmitir e 
receber dados ao mesmo tempo. Como exemplo desse tipo de canal, podemos citar 
os rádios intercomunicadores do tipo walkie-talkie, conforme ilustra a Figura 2.
ou
Figura 2 – Exemplo de canal Half-Duplex
Fonte: Adaptado de Getty Images
Canal Full-Duplex
Em um canal Full-Duplex, as transmissões podem ser feitas nos dois sentidos 
simultaneamente, ou seja, um dispositivo pode transmitir e receber informações ao 
mesmo tempo. Como exemplo desse tipo de canal, citamos os serviços de telefonia, 
conforme ilustra a Figura 3.
e
Figura 3 – Exemplo de canal Full-Duplex
Fonte: Adaptado de Getty Images
Comunicação Serial
A comunicação bit-serial, chamada simplesmente de comunicação serial, é um 
tipo de comunicação onde os bits que compõem uma mensagem são transmitidos 
sequencialmente, ou seja, são enviados um de cada vez através de um canal de co-
municação. Chegando ao destino, esses bits são rearranjados para compor a men-
sagem original.
No final da década de 1960, a comunicação serial já era uma realidade, sendo 
utilizada principalmente para a comunicação entre computadores mainframes e ou-
tros dispositivos terminais, porém não existia ainda uma padronização em relação às 
suas características elétricas, mecânicas e funcionais, o que tornava impossível a co-
nexão entre equipamentos de fabricantes diferentes. Diante disso, a EIA (Eletronic 
Industries Association – Associação das Indústrias Eletrônicas) padronizou um 
9
UNIDADE Comunicação de Dados
 protocolo de comunicação serial binário denominado RS-232 (RS é uma abreviação 
de Recommended Standard - Padrão Recomendado), o qual determinava as carac-
terísticas elétricas (níveis de tensão, capacitância, etc.), as características mecânicas 
(tipos de conectores, dimensionamento, etc.) e as características funcionais dos ele-
mentos de um sistema de comunicação.
Em 1969, a EIA publicou a revisão RS-232C, que tinha o objetivo de adequar 
o padrão às características elétricas dos diversos equipamentos de comunicação 
remota. Com o advento dos microcomputadores, o padrão RS-232 foi adotado 
pelos fabricantes de computadores pessoais e até o final da década de 1990, era 
a forma padrão para a comunicação serial, principalmente entre PCs e modems 
(STRANGIO, 2015).
Atualmente, o protocolo de comunicação RS-232 vem sendo substituído pelo 
protocolo USB (Universal Serial Bus). Este último, por ser mais rápido e possuir 
conectores mais simples, vem atraindo a preferência dos fabricantes, pois a imple-
mentação de conectores USB é mais barata do que a implementação de conectores 
RS-232. Porém, o protocolo RS-232 continua sendo bastante utilizado em aplica-
ções industriais (balanças, instrumentação, controladores lógicos, etc.) e comerciais 
(impressoras fiscais, leitores de códigos de barra ou fita magnética, etc.). A Figura 4 
apresenta os conectores RS-232 (DB9) e USB.
Figura 4 – Conectores RS-232 e USB
Fonte: Divulgação
Em um computador, as portas USB também podem operar dentro do padrão 
RS-232. Para que isso ocorra, é preciso que um software de interfaceamento, que 
normalmente chamamos de “driver”, seja instalado no equipamento. O papel desse 
“driver” é mediar a comunicação entre o programa e o hardware, ajustando para o 
padrão RS-232 as mensagens trocadas.
Características do Sinal
Na comunicação serial, cada byte transmitido é acrescido de alguns bits de controle 
dentro de uma única unidade, que chamamos de pacote de dados. O primeiro bit 
 desse pacote é o start bit, que sinaliza o início da transmissão. Os próximos oito bits 
são aqueles que compõem o byte original, que chamamos de “bits de informação”. 
Em seguida, temos o bit de paridade, que será utilizado pelo equipamento receptor 
para verificar a consistência da mensagem e, por último, temos o stop bit, que sinaliza 
o final do pacote. A Figura 5 mostra a estrutura típica de um pacote de dados.
10
11
Figura 5 – Estrutura do pacote de dados
Fonte: Acervo do conteudista
Quando se inicia a comunicação, o primeiro bit transferido é o start bit, que man-
tém a linha de comunicação no intervalo de 1 período em nível baixo. Em seguida, 
são transferidos os bits de informação, um bit de paridade e, por último, o stop bit, 
que faz a linha retornar ao seu estado de repouso (nível lógico alto). É importante sa-
lientar que diferentemente de um sinal TTL (Transistor-Transistor Logic), um sinal no 
padrão RS-232 tem como nível lógico alto uma tensão que pode variar entre -18V
a -3V (negativos) e como nível lógico baixo uma tensão entre 3V a 18V (positivos). 
A Figura 6 apresenta uma comparação entre os sinais TTL e RS-232.
Figura 6 – Comparação dos sinais TTL e RS-232
Fonte: Acervo do conteudista
Bit de Paridade
O bit de paridade (parity) é um bit adicionado ao pacote de dados com o pro-
pósito de verificar a integridade dos dados transmitidos. Existem dois métodos que 
podem ser empregados: paridade-par (even-parity) e paridade-ímpar (odd-parity). 
Veja os exemplos a seguir.
• Paridade-par: se formos transmitir, por exemplo, o byte “01101101”, o qual 
possui 5 bits “1”, o bit de paridade deverá receber o valor “1”, para que, junta-
mente com o byte original, exista um número par de bits “1”. Caso o bytea ser 
transmitido já tenha um número par de “uns”, como, por exemplo, “01101100” 
(4 bits “1”), então o bit de paridade receberá o valor “0”, para que a paridade 
seja conservada. A Figura 7 ilustra esse processo;
11
UNIDADE Comunicação de Dados
Figura 7 - Exemplo de paridade “par”
Fonte: Acervo do conteudista
• Paridade-ímpar: é um processo semelhante à paridade-par, porém o bit de 
paridade deve ser ajustado para que o número de “uns” seja ímpar, conforme 
ilustra a Figura 8.
Figura 8 – Exemplo de paridade “ímpar”
Fonte: Acervo do conteudista
Taxa de Transmissão
A taxa de transmissão é a velocidade com que os dados são transmitidos por meio 
de um canal de comunicação. É conhecida também como “Baud Rate”, em home-
nagem ao inventor francês Émilie Baudot, um dos pioneiros das telecomunicações. 
Essa taxa determina a quantidade de transições elétricas por segundo, sendo que no 
padrão RS232 cada transição corresponde a um bit transmitido. Por exemplo, uma 
taxa de 9600 baud rate corresponde a uma transferência de 9600 bits por segundo, 
o que determina um período (intervalo entre uma e outra transição elétrica) de apro-
ximadamente 104µs (1/9600 s).
Padrão RS-232: https://bit.ly/2B65cyX
Desenvolvimento de um 
Sistema de Comunicação
Agora que conhecemos os conceitos básicos da comunicação de dados, vamos 
desenvolver um sistema em linguagem C para estabelecer comunicação entre o com-
putador e um dispositivo microcontrolado. O propósito desse desenvolvimento é 
colocar em prática os conceitos teóricos estudados e oferecer a você um modelo de 
software que poderá servir como base para o desenvolvimento de futuras aplicações 
que envolvam comunicação de dados.
O sistema aqui proposto deve enviar comandos para um dispositivo microcontrola-
do, que, por sua vez, deve enviar dados para o sistema (computador). O primeiro passo 
é definir esse dispositivo. Adotaremos uma plataforma de prototipagem Arduino UNO 
como base para a construção do dispositivo. Poderíamos utilizar para esse fim qual-
quer microcontrolador que disponha de circuito USART (Universal Asynchrounous 
12
13
Receiver/Transmiter – Receptor/Transmissor Universal Assíncrono), no entanto, por 
oferecer maior facilidade em relação à construção do firmware e possuir um ambiente 
de programação com suporte à linguagem C, adotaremos o Arduino.
Dispositivo Microcontrolado
O funcionamento do dispositivo proposto é bastante simples. Ele deverá receber 
os comandos enviados pelo computador e realizar ações sobre dois leds com base 
nesses comandos. Os leds são representações genéricas de quaisquer circuitos de 
acionamento, podendo ser relés, módulos de controle para motores, ou qualquer 
 outro circuito de atuação. Além dos leds, o dispositivo proposto terá dois botões 
táteis que, quando pressionados, farão com que o programa envie dados para o com-
putador. Esses botões também são representações genéricas de quaisquer circuitos 
ou elementos de entrada, como sensores, chaves, potenciômetros, etc.
O diagrama esquemático do dispositivo microcontrolado é apresentado na Figura 9.
Figura 9 – Diagrama esquemático do dispositivo microcontrolado
Fonte: Acervo do conteudista
Esse dispositivo pode ser construído diretamente sobre a plataforma Arduino 
UNO, como mostra a Figura 10.
Figura 10 – Montagem do dispositivo microcontrolado
Fonte: Acervo do conteudista
13
UNIDADE Comunicação de Dados
O programa (firmware) do dispositivo deve realizar os seguintes procedimentos.
a) Verificar se houve o recebimento de algum dado caractere que tenha sido 
enviado pelo computador através da porta serial;
b) Caso tenha ocorrido algum recebimento, realizar uma das ações a seguir, 
de acordo com o valor do dado:
 » se o dado recebido for “A”, o LED D1 deve ser aceso;
 » se o dado recebido for “B”, o LED D1 deve ser apagado;
 » se o dado recebido for “C”, o LED D2 deve ser aceso;
 » se o dado recebido for “D”, o LED D2 deve ser apagado.
c) Verificar se o botão B1 está pressionado. Caso afirmativo, enviar para o 
computador o caractere “1”;
d) Verificar se o botão B2 está pressionado. Caso afirmativo, enviar para o 
computador o caractere “2”;
e) Executar novamente os procedimentos a partir do item a.
Para construir o programa que realize esses procedimentos, devemos usar o ambiente de 
desenvolvimento do Arduino, que pode ser baixado diretamente do site oficial do “Projeto 
Arduino”, disponível em: https://bit.ly/2YyHh2Q
A Figura 11 mostra o aspecto do programa proposto após sua digitação no am-
biente de desenvolvimento.
Figura 11 – Aspecto do programa no ambiente Arduino
Fonte: Acervo do conteudista
14
15
A Tabela 1 a seguir apresenta as 23 linhas do programa devidamente comentadas.
Tabela 1 – Programa comentado
Ln Instruções Comentários
1 int bot1=2; Declara a variável bot1 como numérica inteira atribuindo-lhe valor 2.
2 int bot2=3; Declara a variável bot2 como numérica inteira atribuindo-lhe valor 3.
3 int led1=12; Declara a variável led1 como numérica inteira atribuindo-lhe valor 12.
4 int led2=13; Declara a variável led2 como numérica inteira atribuindo-lhe valor 13.
5 void setup() { Inicia a estrutura setup (estrutura reservada para as configurações).
6 pinMode(bot1,INPUT_PULLUP); Configura o pino 2 (bot1) como entrada (input), ativando o resistor in-terno de pull up.
7 pinMode(bot2,INPUT_PULLUP); Configura o pino 3 (bot2) como entrada (input), ativando o resistor in-terno de pull up.
8 pinMode(led1,OUTPUT); Configura o pino 12 (led1) como saída (output).
9 pinMode(led2,OUTPUT); Configura o pino 13 (led2) como saída (output).
10 Serial.begin(9600); Faz a abertura da porta serial definindo a taxa de transmissão de 9600 baud rate. 
11 } Finaliza a estrutura setup.
12 void loop() { Inicia a estrutura de repetição principal (loop).
13 if(Serial.available()) { Verifica se existe algum dado a ser recebido pela porta serial. 
14 char c=Serial.read(); Lê a porta serial e coloca o dado recebido na variável c.
15 if(c==’A’ || c==’a’) digitalWrite(led1,HIGH); Se a variável c for igual a “A” (maiúscula ou minúscula), acende o LED do pino led1 (HIGH).
16 if(c==’B’ || c==’b’) digitalWrite(led1,LOW); Se a variável c for igual a “B” (maiúscula ou minúscula), apaga o LED do pino led1 (LOW).
17 if(c==’C’ || c==’c’) digitalWrite(led2,HIGH); Se a variável c for igual a “C” (maiúscula ou minúscula), acende o LED do pino led2 (HIGH).
18 if(c==’D’ || c==’d’) digitalWrite(led2,LOW); Se a variável c for igual a “D” (maiúscula ou minúscula), apaga o LED do pino led2 (LOW).
19 } Finaliza a estrutura if.
20 if(digitalRead(bot1)==0) Serial.print(“1”); Se o botão acoplado no pino 2 (bot1) estiver pressionado, envia “1” para a porta serial. 
21 if(digitalRead(bot2)==0) Serial.print(“2”); Se o botão acoplado no pino 3 (bot2) estiver pressionado, envia “2” para a porta serial.
22 delay(200); Gera uma pausa de 200ms.
23 } Finaliza a estrutura loop (inicia um novo ciclo).
Comunicação serial: https://bit.ly/31cBXVP
Programa do Computador
Agora devemos construir o programa que rodará no lado do computador, sendo 
esse o equipamento que comandará a comunicação. O programa deverá realizar os 
seguintes procedimentos:
15
UNIDADE Comunicação de Dados
• solicitar pelo teclado o número da porta serial na qual está acoplado o dispositivo 
microcontrolado (Arduino);
• solicitar pelo teclado a taxa de transmissão (baud rate) que será utilizada 
 na comunicação;
• dentro de uma estrutura de repetição, realizar as seguintes ações:
 » ler a porta serial e no caso de existir algum dado enviado pelo dispositivo 
 microcontrolado, exibir esse dado na tela;
 » ler o teclado do computador e no caso de alguma tecla ter sido pressionada, 
enviar o caractere correspondente para o dispositivo microcontrolado.
Antes de iniciarmos a construção do programa, são necessários alguns escla-
recimentos sobre os recursos da linguagem C relativos à comunicação de dados. 
O  ambiente de programaçãoque usaremos é o DEVC++ (outros ambientes ou 
compiladores podem exigir alguns ajustes no programa em função das bibliotecas 
específicas que utilizam). No caso do DEVC++, usaremos os recursos do sistema 
operacional para realizar as operações de comunicação. Esses recursos encon-
tram-se na biblioteca de cabeçalho “windows.h”, que disponibiliza funções para 
a abertura e fechamento da porta de comunicação, assim como funções para 
transmissão e recepção de dados, e da biblioteca “timer.h”, que contém funções 
para o gerenciamento dos temporizadores necessários para a definição da taxa de 
transmissão (baud rate) que usaremos na comunicação.
Para usarmos os recursos citados, devemos criar no nosso programa algumas 
funções (ou classes de objetos) específicas para cada uma das operações que serão 
realizadas sobre a porta de comunicação serial na qual se encontra conectado o 
dispositivo microcontrolado (Arduino). Portanto, devemos criar funções para as 
 seguintes operações:
• Configuração e abertura da porta de comunicação: esta função determinará 
o número da porta, a taxa de transmissão (baud rate), a paridade (par, ímpar 
ou nenhuma) e o tamanho do dado (quantidade de bits de informação), além 
de promover a abertura do canal de comunicação. A linha de instrução para a 
definição do protótipo desta função, que chamaremos de “serial_abre”, é apre-
sentada a seguir (observe que o qualificador da função é HANDLE, ou seja, ela 
retornará um objeto para manipulação da porta serial):
HANDLE serial_abre (int porta, const long int BaudRate, 
 const char parity, const char data);
• Limpeza da porta serial: esta função, que chamaremos de “serial_limpa”, 
 deverá promover a limpeza do buffer de dados da porta de comunicação serial. 
A linha de instrução a seguir define o protótipo da função:
void serial_limpa(const int porta);
• Transmissão de dados: esta função, que chamaremos de “serial_envia”, será 
responsável pelo envio de dados para o dispositivo microcontrolado através da 
16
17
porta de comunicação serial. Seu protótipo é apresentado a seguir. Observe que 
os parâmetros dessa função são: “porta” (número da porta serial) e “txtchar” 
(caractere que será transmitido);
void serial_envia(const int porta, const int txchar);
• Recebimento de dados: esta função, que chamaremos de “serial_recebe”, fará 
a leitura da porta serial e o recebimento do dado que foi enviado pelo dispositivo 
microcontrolado. Seu protótipo é apresentado a seguir. Observe que a função 
retornará um dado do tipo “char” (caractere recebido pela porta serial) e terá 
como único parâmetro a constante inteira “porta” (número da porta serial);
char serial_recebe(const int porta);
• Fechamento da porta de comunicação: esta função, que chamaremos de 
 “serial_fecha”, realizará o fechamento da comunicação serial em ocasião do 
encerramento do programa. Seu protótipo é apresentado a seguir. Observe 
que a função terá como único parâmetro a constante inteira “porta” (número 
da porta serial);
void serial_fecha(const int porta);
• Temporização: esta função, que chamaremos de “delay_ms”, gerará uma pausa, 
em unidades de milissegundos, necessária para o controle da taxa de transmissão 
(baud rate) do canal de comunicação serial. Seu protótipo é apresentado a seguir. 
Observe que o único parâmetro da função é “millis” (tempo em milissegundos).
void delay_ms(clock_t millis);
Dessa forma, o início do nosso programa deve ser composto pelas seguintes linhas:
#include <conio.h> 
#include <stdio.h>
#include <windows.h>
#include <time.h>
#include <locale.h>
#include <stdlib.h>
HANDLE serial_abre (int porta, const long int BaudRate, 
 const char parity, const char data);
void serial_limpa(const int porta);
void serial_fecha(const int porta);
char serial_recebe(const int porta);
void serial_envia(const int porta, const int txchar); 
void delay_ms(clock_t millis);
HANDLE hCom;
17
UNIDADE Comunicação de Dados
Observe que as diretivas de pré-processamento (#include) referenciam as bibliote-
cas necessárias para o programa, sendo elas:
• conio.h: fornece as funções para leitura do teclado (getch e kbhit);
• stdio.h: fornece as funções de entrada e saída de dados (scanf e printf);
• windows.h: fornece as funções para manipulação da porta serial;
• time.h: fornece as funções de temporização;
• locale.h: fornece a função de configuração regional (setlocale);
• stdlib.h: fornece as funções de sistema (system).
Note também que a última linha do trecho apresentado (HANDLE hCom;) cria um 
objeto do tipo HANDLE (manipulador) chamado de “hCom”, que será utilizado nas 
operações de manipulação da porta de comunicação serial.
Cabe salientar que neste trecho inicial do programa estamos apenas definindo os 
protótipos das funções. Os códigos correspondentes a elas ainda devem ser escritos 
em algum ponto do programa.
A seguir é apresentado o programa completo. Observe que os códigos das fun-
ções citadas foram escritos logo após a estrutura principal main.
Programa Completo em Linguagem C
#include <conio.h>
#include <stdio.h>
#include <windows.h>
#include <time.h>
#include <locale.h>
#include <stdlib.h>
HANDLE serial_abre (int porta, const long int BaudRate, 
 const char parity, const char data);
void serial_limpa(const int porta);
void serial_fecha(const int porta);
char serial_recebe(const int porta);
void serial_envia(const int porta, const int txchar); 
void delay_ms(clock_t millis);
HANDLE hCom;
int main() {
18
19
 clock_t timeout;
 unsigned char r,e,tecla;
 int porta,taxa;
 setlocale(LC_ALL,”Portuguese”);
 printf(“ MONITOR SERIAL \n\n”);
 printf(“ Número da porta serial: “);scanf(“%d”,&porta);
 printf(“ Taxa de transmissão...: “);scanf(“%d”,&taxa);
 if(!serial_abre(porta ,taxa, ‘8’, ‘N’)) { 
 getch(); system(“cls”); exit(1);
 }
 timeout = clock() + 60000;
 printf(“\n COMANDOS\n\n”);
 printf(“ [A].....Acende LED1 [B].....Apaga LED1\n”);
 printf(“ [C].....Acende LED2 [D].....Apaga LED2\n\n”);
 while(1) {
 r=serial_recebe(porta);
 if(r) printf(“ Recebido: %c\r”,r);
 if(kbhit()) {
 tecla=getch();
 if(tecla==’*’) {serial_fecha(porta);exit(0);}
 printf(“ Enviado : %c\r”,tecla);
 serial_limpa(porta); 
 serial_envia(porta,tecla);
 serial_limpa(porta); 
 }
 }
}
/*********************************************************
 Manipulador para inicialização da porta serial (abertura)
**********************************************************/
19
UNIDADE Comunicação de Dados
HANDLE serial_abre (int porta, const long int BaudRate, 
 const char parity, const char data) {
 BOOL bPortReady;
 DCB dcb;
 COMMTIMEOUTS CommTimeouts;
 char ComPortName[5];
 if (porta<10) {
 ComPortName[0]=’C’;ComPortName[1]=’O’;
 ComPortName[2]=’M’;ComPortName[3]=’0’+ porta;
 } else {
 if (porta<20) {
 ComPortName[0]=’C’;ComPortName[1]=’O’;
 ComPortName[2]=’M’;ComPortName[3]=’1’;
 ComPortName[4]=’0’+ porta-10;
 } else {
 if (porta<30) {
 ComPortName[0]=’C’;ComPortName[1]=’O’;
 ComPortName[2]=’M’;ComPortName[3]=’2’;
 ComPortName[4]=’0’+ porta-20;
 } 
 }
 }
 printf(“ Abrindo porta %s\n”,ComPortName);
 hCom = CreateFile(ComPortName, GENERIC_READ | GENERIC_WRITE,
 0, NULL,OPEN_EXISTING,0,NULL); 
 if ((int)hCom <= 0) {printf(“Falha”);return 0;}
 bPortReady = SetupComm(hCom, 128, 128); 
 if (!bPortReady ) {printf(“Falha”);return 0;}
 bPortReady = GetCommState(hCom, &dcb);
 if (!bPortReady ) {printf(“Falha”);return 0;} 
20
21
 dcb.BaudRate = BaudRate;
 if( data == ‘7’) dcb.ByteSize = 7; 
 else dcb.ByteSize = 8; 
 if( parity == ‘E’) dcb.Parity = EVENPARITY; 
 if( parity == ‘O’) dcb.Parity = ODDPARITY;else dcb.Parity = NOPARITY; 
 dcb.StopBits = ONESTOPBIT; 
 dcb.fAbortOnError = TRUE; 
 dcb.fOutX = FALSE; 
 dcb.fInX = FALSE; 
 dcb.fOutxCtsFlow = FALSE; 
 dcb.fRtsControl = FALSE; 
 dcb.fOutxDsrFlow = FALSE; 
 dcb.fDtrControl = DTR_CONTROL_DISABLE; 
 bPortReady = SetCommState(hCom, &dcb); 
 if (!bPortReady ) {printf(“Falha”);return 0;} 
 bPortReady = GetCommTimeouts (hCom, &CommTimeouts);
 CommTimeouts.ReadIntervalTimeout = 5 ;
 CommTimeouts.ReadTotalTimeoutConstant = 5 ;
 CommTimeouts.ReadTotalTimeoutMultiplier = 1 ;
 CommTimeouts.WriteTotalTimeoutConstant = 5 ;
 CommTimeouts.WriteTotalTimeoutMultiplier = 1 ;
 bPortReady = SetCommTimeouts (hCom, &CommTimeouts);
 if (!bPortReady ) {printf(“Falha”);return 0;}
 printf(“ COM%d conectada.\n”, porta);
 return (hCom); 
}
/*******************************************
 Funções para manipulação da porta serial
********************************************/
21
UNIDADE Comunicação de Dados
void serial_fecha(const int porta){CloseHandle(hCom);}
char serial_recebe(const int porta){
 char rxchar;
 BOOL bReadRC;
 static DWORD iBytesRead;
 bReadRC = ReadFile(hCom, &rxchar, 1, &iBytesRead, NULL);
 if (iBytesRead) {
 return rxchar; 
 } else {
 return 0; 
 }
}
void serial_limpa(const int porta) {
 while(serial_recebe(porta)!=0);
}
void serial_envia(const int porta, const int txchar) {
 BOOL bWriteRC;
 static DWORD iBytesWritten;
 bWriteRC = WriteFile(hCom, &txchar, 1, &iBytesWritten,NULL);
 return;
}
void delay_ms(clock_t millis) {
 clock_t endtime;
 endtime = millis + clock();
 while( endtime > clock() ) {;}
}
Use o ambiente DEVC++ para implementar o programa e verificar a sua funcionalidade. 
Para eliminar o trabalho da digitação desse programa, que por sinal contém instruções 
complexas que poderão ser facilmente digitadas com erro. Este link fará o download do 
arquivo compactado “monitorserial_zip”, que contém, além do programa apresentado, o 
programa que deve ser instalado na plataforma Arduino: https://bit.ly/2By83Rg
22
23
Para verificar o funcionamento do programa, siga os procedimentos descritos 
a seguir.
1. Conecte a plataforma Arduino no computador e execute o software
 Arduino. Abra o programa “arduino_prog.ino” (que está presente no 
 arquivo compactado “monitorserial.zip”) e grave-o na plataforma através 
do comando “Carregar”, conforme mostra a Figura 12.
Figura 12 – Gravação do programa na plataforma Arduino
Fonte: Acervo do conteudista
2. Abra o ambiente DEVC++ e carregue o programa “monitor_serial.c” 
(que está presente no arquivo compactado “monitorserial.zip”). Grave 
esse programa como “c source fi le”, ou seja, na janela de gravação (Save 
File) escolha o tipo “C Source Files (*.c)”, conforme mostra a Figura 13.
Figura 13 – Gravação do programa no ambiente DEVC++
Fonte: Acervo do conteudista
23
UNIDADE Comunicação de Dados
3. Ainda no ambiente DEVC++, execute o programa por meio do comando 
Execute/Compile&Run. Será apresentada a tela de execução onde você 
deverá informar o número da porta serial, na qual está conectada a plataforma 
Arduino, e a taxa de transmissão (baud rate) que será usada na comunicação. 
Caso você não saiba o número da porta serial, basta abrir o software Arduino 
e entrar no menu “Ferramentas/Porta”. A porta serial é identificada com o 
prefixo “COM” seguido pelo seu número, que é justamente o qual devemos 
informar. A taxa de transmissão deve ser 9600, conforme foi definido no 
programa do Arduino. Na Figura 14, é apresentada a tela de execução, onde 
estamos considerando a porta COM6 com taxa de transmissão de 9600.
Figura 14 – Tela de execução (entrada de dados)
Fonte: Acervo do conteudista
4. Após receber o número da porta e a taxa de transmissão, o programa 
fará a abertura do canal de comunicação e exibirá na tela a mensagem 
 “Conectada”. A partir desse momento, o programa ficará aguardando os 
comandos do usuário e os dados enviados pelo dispositivo microcontrolado 
por meio da tela apresentada na Figura 15.
Figura 15 – Tela de execução após abertura da porta serial
Fonte: Acervo do conteudista
Terminados esses procedimentos, você poderá constatar o funcionamento desse 
sistema básico de comunicação, que, apesar de simples, mostra todos os recursos 
necessários para a construção de sistemas mais complexos que envolvam comuni-
cação de dados. 
24
25
Material Complementar
Indicações para saber mais sobre os assuntos abordados nesta Unidade:
 Livros
Estrutura de dados e algoritmos em C
DROZDEK, A. Estrutura de dados e algoritmos em C. São Paulo: Cengage 
Learning, 2016. 
Treinamento em Linguagem C
MIZRAHI, V. V. Treinamento em Linguagem C. 2ª ed. São Paulo: Pearson, 2008. 
 Leitura
Serial
ARDUINO. Comunicação serial – Documentação de referência.
https://bit.ly/31cBXVP
Canais de Comunicação e Modos de Transmissão de Dados
BOSON TREINAMENTOS EM TECNOLOGIA. Canais de comunicação e 
modos de transmissão de dados. 
https://bit.ly/3fTOXUl
25
UNIDADE Comunicação de Dados
Referências
PRESSMAN, R. S. Engenharia de software: uma abordagem profissional. 8ª ed. 
Porto Alegre: AMGH, 2016. (e-book)
SEBESTA, R. W. Conceitos de linguagens de programação. 11ª ed. Porto Alegre: 
Bookman, 2018.
STRANGIO, C. E. The RS232 Standard. CAMI Research Inc., 2015. Disponível 
em: <https://www.camiresearch.com/Data_Com_Basics/RS232_standard.html>. 
Acesso em: 22/04/2020. 
26