Um: Visão geral da porta serial
A operação do UART pode ser dividida nas seguintes partes: transmissão de dados, recepção de dados, geração de interrupção, configuração de taxa de baud, modo Loopback, modo infravermelho e modo de controle de fluxo rígido e suave. No Linux, todos os arquivos de dispositivo estão geralmente localizados em "/ dev". Os nomes dos dispositivos correspondentes à porta serial 1 e porta serial 2 são "/ dev / ttyS0" e "/ dev / ttyS1" por sua vez, e USB para serial dispositivos Os nomes são geralmente "/ dev / ttyUSB0" e "/ dev / ttyUSB1". Você pode verificar o arquivo em "/ dev" para confirmar. O método de operação do dispositivo no Linux é o mesmo que o método de operação do arquivo A porta serial pode ser lida e escrita usando as funções read () e write () simples. A única diferença é que outros parâmetros da porta serial precisam ser configurados separadamente.
Dois: configurações da porta serial
A configuração da porta serial é principalmente para definir o valor de cada membro da estrutura struct termios:
#include<termios.h>
struct termios
{
unsigned short c_iflag; /* 输入模式标志 */
unsigned short c_oflag; /* 输出模式标志 */
unsigned short c_cflag; /* 控制模式标志*/
unsigned short c_lflag; /* 本地模式标志 */
unsigned char c_line; /* 线路规程 */
unsigned char c_cc[NCC]; /* 控制特性 */
speed_t c_ispeed; /* 输入速度 */
speed_t c_ospeed; /* 输出速度 */
};termios é uma interface padrão definida na especificação POSIX, o que significa equipamento terminal (incluindo terminais virtuais, portas seriais, etc.). A porta é um dispositivo terminal, geralmente configurado e controlado por meio de uma interface de programação de terminal. Antes de explicar a programação relacionada à porta serial em detalhes, primeiro entenda o conhecimento relacionado ao terminal. O terminal tem 3 modos de funcionamento, nomeadamente modo canônico, modo não canônico e modo bruto.
Ao definir o sinalizador ICANNON no c_lflag da estrutura termios, você pode definir se o terminal funciona no modo canônico (definir o sinalizador ICANNON) ou no modo não canônico (limpar o sinalizador ICANNON). O padrão é o modo canônico. No modo canônico, todas as entradas são processadas em uma base de linha. Antes que o usuário insira um caractere de final de linha (retorno de carro, EOF, etc.), o sistema chama a função read () e não pode ler nenhum caractere inserido pelo usuário. Os caracteres de final de linha (retorno de carro, etc.) diferentes de EOF serão lidos no buffer pela função read () da mesma forma que os caracteres comuns. No modo padrão, a edição de linha é possível, e no máximo uma linha de dados pode ser lida chamando a função read (). Se o número de bytes de dados solicitados para serem lidos na função read () for menor que o número de bytes que podem ser lidos na linha atual, a função read () lerá apenas o número solicitado de bytes e os bytes restantes será usado na próxima vez. Ser lido novamente. No modo não padrão, todas as entradas são instantaneamente efetivas e o usuário não precisa inserir o caractere de final de linha separadamente e a edição de linha não é permitida. No modo não padrão, a configuração dos parâmetros MIN (c_cc [VMIN]) e TIME (c_cc [VTIME]) determina o método de chamada da função read (). A configuração pode ter 4 situações diferentes
MIN = 0 e TIME = 0: A função read () retorna imediatamente. Se houver dados legíveis, leia os dados e retorne o número de bytes lidos, caso contrário, a leitura falha e retorna 0.
MIN> 0 e TIME = 0: A função read () será bloqueada até que MIN bytes de dados possam ser lidos.
MIN = 0 e TIME> 0: Enquanto houver dados para ler ou TIME ter decorrido um décimo de segundo, a função read () retorna imediatamente e o valor de retorno é o número de bytes lidos. Se atingir o tempo limite e nenhum dado for lido, a função read () retornará 0.
MIN> 0 e TIME> 0: A função read () retorna apenas quando há MIN bytes para ler ou o intervalo de tempo entre dois caracteres de entrada excede TIME décimos de segundo. Como o sistema não inicia o cronômetro até que o primeiro caractere seja inserido, neste caso, a função read () retorna após a leitura de pelo menos um byte.
Estritamente falando, o modo original é um modo especial fora do padrão. No modo original, todos os dados de entrada são processados em bytes. Neste modo, o terminal não pode ser ecoado e todo o processamento de controle de entrada / saída do terminal específico não está disponível. O terminal pode ser configurado para o modo original chamando a função cfmakeraw (). A implementação específica é:
termios_p->c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP
| INLCR | IGNCR | ICRNL | IXON);
termios_p->c_oflag &= ~OPOST;
termios_p->c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
termios_p->c_cflag &= ~(CSIZE | PARENB);
termios_p->c_cflag |= CS8As configurações mais básicas na porta serial incluem a configuração da taxa de transmissão, bit de paridade e configuração do bit de parada. O mais importante nessa estrutura é c_cflag. Ao atribuir valores a ele, os usuários podem definir a taxa de transmissão, o tamanho dos caracteres, os bits de dados, os bits de parada, os bits de paridade e o controle de fluxo rígido e suave. Aqui, o membro c_cflag não pode ser inicializado diretamente, mas algumas das opções devem ser usadas por meio de operações "e" e "ou".
Nomes constantes com suporte por c_cflag:
Bit mask of CBAUD baud rate
B0 0 Baud rate (DTR abandonado)
……
B1800 1800 Baud rate
B2400 2400 Baud rate B4800 4800 Baud rate
B9600 9600 Baud rate
B19200 19200 Baud
rate
B38400 38400 Baud rate B57600 57600 Baud rate
B115200 115200 Baud rate
EXTA External clock rate
EXTB clock externo
CSIZE Máscara de bits de dados
CS5 5 bits de dados
CS6 6 bits de dados
CS7 7 bits de dados
CS8 8 bits de dados
CSTOPB 2 bits de parada (se não definido, 1 bit de parada)
CREAD receber habilitar
PARENB bit de paridade habilitar PARODD
usar paridade ímpar em vez de paridade par
HUPCL quando finalmente fechado Desligar (abandonar DTR)
Conexão local CLOCAL ( não altere o proprietário da porta)
Controle de fluxo de hardware CRTSCTS
O sinalizador de modo de entrada c_iflag é usado para controlar o processamento de entrada de caracteres na extremidade de recepção da porta.
Nomes constantes com suporte por c_iflag:
Verificação de paridade INPCK habilitar
IGNPAR Ignorar
erros de paridade.PARMRK máscara de erro de paridade
ISTRIP Cortar o 8º bit IXON Iniciar
controle de fluxo de software de saída
IXOFF Iniciar controle de fluxo de software de entrada
IXANY Inserir qualquer caractere para reiniciar a saída (o padrão é entrada A saída reinicia somente após o caractere inicial )
IGNBRK Ignorar a condição de terminação de entrada
BRKINT Quando a condição de terminação de entrada for detectada, envie um sinal SIGINT
INLCR para converter o NL recebido (alimentação de linha) em CR (retorno de carro)
IGNCR Ignore o CR recebido (retorno de carro) Fu)
e ambos ICRNL CR recebido (retorno de carro) para NL (nova linha)
o mapeamento de caracteres maiúsculos para minúsculos recebido
anel IUCLC quando a fila de entrada está cheia quando IMAXBEL
O sinalizador de modo de saída c_oflag é usado para processar os caracteres enviados pela porta de controle.
Nomes constantes com suporte por c_oflag:
OPOST ativa a função de processamento de saída. Se este sinalizador não for definido, outros sinalizadores
serão ignorados. O OLCUC irá converter caracteres maiúsculos na saída em caracteres minúsculos.
ONLCR irá converter o caractere de nova linha ('\ n') na saída em um carro return ('\ r')
ONOCR Se o número da coluna atual for 0, então nenhum retorno de carro é produzido.
OCRNL converte o retorno de carro ('\ r') na saída para uma alimentação de linha ('\ n') ONLRET não
produz o retorno de carro OFILL e envia o caractere de preenchimento para fornecer o atraso
OFDEL. Se este sinalizador estiver definido, significa que o caractere de preenchimento é o caracter DEL, caso contrário, é o caractere NUL.
NLDLY. Line feed delay mask
CRDLY Carriage return delay mask
TABDLY Máscara de atraso de
tabulação Máscara de atraso de retrocesso horizontal
VTDLY Máscara de atraso de retrocesso vertical
Máscara de atraso de alimentação de página FFLDY
c_lflag é usado para controlar o processamento de dados local e o modo de trabalho do terminal de controle.
Nomes constantes com suporte por c_lflag:
Se o ISIG receber um caractere de sinal (INTR, SAIR, etc.), ele gerará o sinal correspondente
ICANON. Habilite o modo normal
ECHO. Habilite a função de eco local.
ECHOE. Se ICANON estiver definido, a operação de retrocesso é permitida.
ECHOK. Se ICANON for definido, o caractere KILL excluirá a linha atual
ECHONL Se ICANON estiver definido, o avanço de linha pode ser
ecoado. ECHOCTL Se ECHO estiver definido, os caracteres de controle (tabulação, quebra de linha, etc.) serão exibidos como "^ X", onde o código ASCII de X é igual ao código ASCII para o caractere de controle correspondente Adicionar 0x40. Por exemplo: o caractere backspace (0x08) será exibido como "^ H" (o código ASCII de '
H ' é 0x48) ECHOPRT Se ICANON e IECHO forem definidos, os caracteres excluídos (backspace, etc.) e os caracteres excluídos serão exibido como
ECHOKE Se ICANON for definido, é permitido ecoar o caractere KILL
NOFLSH definido em ECHOE e ECHOPRT. Em circunstâncias normais, quando os caracteres de controle INTR, QUIT e SUSP são recebidos, as filas de entrada e saída serão apagadas. Se este sinalizador for definido, todas as filas não serão esvaziadas
TOSTOP Se um processo em segundo plano tentar gravar em seu terminal de controle, o sistema enviará um sinal SIGTTOU para o grupo de processos do processo em segundo plano. Este sinal geralmente termina a execução do processo
IEXTEN habilita a função de processamento de entrada
c_cc define características especiais de controle.
Nomes constantes com suporte por c_cc:
O caractere de controle de interrupção VINTR, a tecla correspondente é CTRL + C
VQUIT operador de saída, a tecla correspondente é CRTL + Z
VERASE operador delete, a tecla correspondente é Backspace (BS)
VKILL delete line character, a tecla correspondente é CTRL + U
VEOF file end character, O correspondente a tecla é CTRL + D
VEOL caractere de finalização de linha adicional, a chave correspondente é Carriage Return (CR)
VEOL2 O caractere de finalização da segunda linha, a chave correspondente é Line feed (LF)
VMIN especifica o número mínimo de caracteres para
ler VTIME especifica cada leitura Timeout entre personagens
1. Salve a configuração original da porta serial
Em primeiro lugar, por razões de segurança e conveniência de depurar o programa no futuro, você pode salvar primeiro a configuração da porta serial original.Aqui você pode usar a função tcgetattr (fd, & old_cfg). Esta função obtém os parâmetros de configuração do terminal apontados por fd e os salva na variável de estrutura termios old_cfg. Esta função também pode testar se a configuração está correta, se a porta serial está disponível, etc. Se a chamada for bem-sucedida, o valor de retorno da função é 0, se a chamada falhar, o valor de retorno da função é -1.
if (tcgetattr(fd, &old_cfg) != 0)
{
perror("tcgetattr");
return -1;
}2. Opções de ativação
CLOCAL e CREAD são usados respectivamente para conexão local e habilitação de aceitação, portanto, as duas opções devem ser ativadas primeiro por meio de máscara de bits.
newtio.c_cflag |= CLOCAL | CREAD;O terminal pode ser configurado para o modo original chamando a função cfmakeraw (). No exemplo a seguir, o modo original é usado para comunicação de dados seriais.
cfmakeraw(&new_cfg);3. Defina a taxa de transmissão
Existe uma função especial para definir a taxa de transmissão, e o usuário não pode operá-la diretamente através da máscara de bits. As funções principais para definir a taxa de transmissão são: cfsetispeed () e cfsetospeed (). Geralmente, os usuários precisam definir as taxas de transmissão de entrada e saída do terminal para serem as mesmas. Essas funções retornam 0 em caso de sucesso e 1 em caso de falha.
cfsetispeed(&new_cfg, B115200);
cfsetospeed(&new_cfg, B115200);4. Defina o tamanho dos caracteres
Ao contrário de definir a taxa de transmissão, não há função pronta para uso para definir o tamanho do caractere e uma máscara de bits é necessária. Geralmente, a máscara de bits no bit de dados é removida primeiro e, em seguida, definida novamente conforme necessário.
new_cfg.c_cflag &= ~CSIZE; /* 用数据位掩码清空数据位设置 */
new_cfg.c_cflag |= CS85. Defina o bit de paridade
Definir o bit de paridade requer dois membros em termios: c_cflag e c_iflag. Primeiro, ative o sinalizador de habilitação de paridade PARENB em c_cflag e se deve realizar a verificação uniforme e, ao mesmo tempo, ative a habilitação de verificação de paridade (INPCK) para dados de entrada em c_iflag.
使能奇校验：
new_cfg.c_cflag |= (PARODD | PARENB);
new_cfg.c_iflag |= INPCK;
使能偶校验：
new_cfg.c_cflag |= PARENB;
new_cfg.c_cflag &= ~PARODD; /* 清除偶校验标志，则配置为奇校验*/
new_cfg.c_iflag |= INPCK;6. Defina o bit de parada
A definição do bit de parada é realizada ativando CSTOPB em c_cflag. Se houver um bit de parada, CSTOPB é limpo e, se houver dois bits de parada, CSTOPB é ativado.
new_cfg.c_cflag &= ~CSTOPB; /* 将停止位设置为一个比特 */
new_cfg.c_cflag |= CSTOPB; /* 将停止位设置为两个比特 */7. Defina o mínimo de caracteres e aguarde o evento
Se não houver requisitos especiais para os caracteres recebidos e o tempo de espera, ele pode ser definido como 0 e a função read () retorna imediatamente em qualquer caso.
new_cfg.c_cc[VTIME] = 0;
new_cfg.c_cc[VMIN] = 0;8. Limpe o buffer da porta serial
Depois que a porta serial é reiniciada, o dispositivo serial atual precisa ser processado corretamente, então o tcdrain (), tcflow (), tcflush () e outras funções declaradas em <termios.h> podem ser chamadas para processar os dados do buffer serial atual dentro.
int tcdrain(int fd); /* 使程序阻塞，直到输出缓冲区的数据全部发送完毕*/
int tcflow(int fd, int action) ; /* 用于暂停或重新开始输出 */
int tcflush(int fd, int queue_selector); /* 用于清空输入/输出缓冲区*/ A função tcflush () para os dados que não foram transmitidos no buffer, ou os dados que foram recebidos, mas não foram lidos, seu método de processamento depende do valor de queue_selector e seus valores possíveis são os seguintes.
TCIFLUSH: apaga os dados recebidos, mas não lidos.
TCOFLUSH: apaga os dados de saída que não foram transmitidos com sucesso.
TCIOFLUSH: Inclui as duas primeiras funções, ou seja, limpar os dados de entrada e saída não processados.
Se o primeiro método for usado: tcflush (fd, TCIFLUSH);
9. Ative a configuração
Depois de concluir a configuração da porta serial, ative a configuração agora e faça com que a configuração tenha efeito. A função usada aqui é tcsetattr (), e seu protótipo de função é:
tcsetattr(int fd, int optional_actions, const struct termios *termios_p);Os valores possíveis do parâmetro optional_actions são os seguintes:
TCSANOW: a modificação da configuração tem efeito imediato.
TCSADRAIN: a modificação da configuração entrará em vigor após toda a saída gravada em fd ter sido transmitida.
TCSAFLUSH: Todas as entradas aceitas, mas não lidas, serão descartadas antes que a modificação tenha efeito.
Esta função retorna 0 se a chamada for bem-sucedida e 1 se falhar. O código é o seguinte:
if ((tcsetattr(fd, TCSANOW, &new_cfg)) != 0)
{
perror("tcsetattr");
return -1;
}Três: modelo de configuração
int set_com_config(int fd,int baud_rate, int data_bits, char parity, int stop_bits)
{
struct termios new_cfg,old_cfg;
int speed;
/*保存并测试现有串口参数设置，在这里如果串口号等出错，会有相关的出错信息*/
if (tcgetattr(fd, &old_cfg) != 0)
{
perror("tcgetattr");
return -1;
}
/* 设置字符大小*/
new_cfg = old_cfg;
cfmakeraw(&new_cfg); /* 配置为原始模式 */
new_cfg.c_cflag &= ~CSIZE;
/*设置波特率*/
switch (baud_rate)
{
case 2400:
{
speed = B2400;
}
break;
case 4800:
{
speed = B4800;
}
break;
case 9600:
{
speed = B9600;
}
break;
case 19200:
{
speed = B19200;
}
break;
case 38400:
{
speed = B38400;
}
break;
default:
case 115200:
{
speed = B115200;
}
break;
}
cfsetispeed(&new_cfg, speed);
cfsetospeed(&new_cfg, speed);
/*设置数据位*/
switch (data_bits)
{
case 7:
{
new_cfg.c_cflag |= CS7;
}
break;
default:
case 8:
{
new_cfg.c_cflag |= CS8;
}
break;
}
/*设置奇偶校验位*/
switch (parity)
{
default:
case 'n':
case 'N':
{
new_cfg.c_cflag &= ~PARENB;
new_cfg.c_iflag &= ~INPCK;
}
break;
case 'o':
case 'O':
{
new_cfg.c_cflag |= (PARODD | PARENB);
new_cfg.c_iflag |= INPCK;
}
break;
case 'e':
case 'E':
{
new_cfg.c_cflag |= PARENB;
new_cfg.c_cflag &= ~PARODD;
new_cfg.c_iflag |= INPCK;
}
break;
case 's': /*as no parity*/
case 'S':
{
new_cfg.c_cflag &= ~PARENB;
new_cfg.c_cflag &= ~CSTOPB;
}
break;
}
/*设置停止位*/
switch (stop_bits)
{
default:
case 1:
{
new_cfg.c_cflag &= ~CSTOPB;
}
break;
case 2:
{
new_cfg.c_cflag |= CSTOPB;
}
}
/*设置等待时间和最小接收字符*/
new_cfg.c_cc[VTIME] = 0;
new_cfg.c_cc[VMIN] = 1;
/*处理未接收字符*/
tcflush(fd, TCIFLUSH);
/*激活新配置*/
if ((tcsetattr(fd, TCSANOW, &new_cfg)) != 0)
{
perror("tcsetattr");
return -1;
}
return 0;
}Quatro: exemplo de porta serial
Depois de configurar as propriedades relevantes da porta serial, você pode abrir, ler e gravar na porta serial. As funções que ele usa são as mesmas que as funções de leitura e gravação de arquivos comuns, que são open (), write () e read (). A diferença entre eles é que a porta serial é um dispositivo terminal, portanto, haverá algumas diferenças ao selecionar os parâmetros específicos da função. Além disso, algumas funções adicionais serão usadas aqui para testar a conexão de dispositivos terminais.
1. Abra a porta serial
Abrir a porta serial é o mesmo que abrir arquivos comuns, usando a função open (), conforme mostrado abaixo:
fd = open( "/dev/ttyS0", O_RDWR|O_NOCTTY|O_NDELAY);Como você pode ver, além dos parâmetros comuns de leitura e gravação, existem dois parâmetros O_NOCTTY e O_NDELAY.
O flag O_NOCTTY é utilizado para informar ao sistema Linux que este parâmetro não tornará o arquivo aberto o terminal de controle deste processo. Se este sinalizador não for especificado, qualquer entrada (como o sinal de aborto do teclado, etc.) afetará o processo do usuário.
O flag O_NDELAY informa ao sistema Linux que este programa não se importa com o status da linha de sinal DCD (se a outra extremidade da porta está ativada ou parada). Se o usuário especificar este sinalizador, o processo permanecerá no estado de hibernação até que a linha de sinal DCD seja ativada.
Em seguida, o estado da porta serial pode ser restaurado para o estado bloqueado, que é usado para aguardar a leitura dos dados da porta serial. Ele pode ser implementado com a função fcntl (), conforme mostrado abaixo:
fcntl(fd, F_SETFL, 0);Em seguida, você pode testar se o descritor de arquivo aberto está conectado a um dispositivo terminal, para confirmar se a porta serial está aberta corretamente, a chamada de função retorna 0 se for bem-sucedida e -1 se falhar. Do seguinte modo:
isatty(STDIN_FILENO);/*打开串口函数*/
int open_port(int com_port)
{
int fd;
#if (COM_TYPE == GNR_COM) /* 使用普通串口 */
char *dev[] = {"/dev/ttyS0", "/dev/ttyS1", "/dev/ttyS2"};
#else /* 使用 USB 转串口 */
char *dev[] = {"/dev/ttyUSB0", "/dev/ttyUSB1", "/dev/ttyUSB2"};
#endif
if ((com_port < 0) || (com_port > MAX_COM_NUM))
{
return -1;
}
/* 打开串口 */
fd = open(dev[com_port - 1], O_RDWR|O_NOCTTY|O_NDELAY);
if (fd < 0)
{
perror("open serial port");
return(-1);
}
/*恢复串口为阻塞状态*/
if (fcntl(fd, F_SETFL, 0) < 0)
{
perror("fcntl F_SETFL\n");
}
/*测试是否为终端设备*/
if (isatty(STDIN_FILENO) == 0)
{
perror("standard input is not a terminal device");
}
return fd;
}2. Ler e escrever na porta serial
As operações de leitura e gravação da porta serial são as mesmas que ler e gravar arquivos comuns, basta usar as funções read () e write (), conforme mostrado abaixo:
write(fd, buff, strlen(buff));
read(fd, buff, BUFFER_SIZE);Os dois exemplos a seguir mostram dois procedimentos para leitura e gravação de porta serial, que usam as funções open_port () e set_com_config () descritas acima. O programa que grava a porta serial será executado no host e o programa que lê a porta serial será executado na placa de destino.
O procedimento para escrever a porta serial é o seguinte:
/* com_writer.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include "uart_api.h"
int main(void)
{
int fd;
char buff[BUFFER_SIZE];
if((fd = open_port(HOST_COM_PORT)) < 0) /* 打开串口 */
{
perror("open_port");
return 1;
}
if(set_com_config(fd, 115200, 8, 'N', 1) < 0) /* 配置串口 */
{
perror("set_com_config");
return 1;
}
do
{
printf("Input some words(enter 'quit' to exit):");
memset(buff, 0, BUFFER_SIZE);
if (fgets(buff, BUFFER_SIZE, stdin) == NULL)
{
perror("fgets");
break;
}
write(fd, buff, strlen(buff));
} while(strncmp(buff, "quit", 4));
close(fd);
return 0;
}O procedimento para ler a porta serial é o seguinte:
/* com_reader.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include "uart_api.h"
int main(void)
{
int fd;
char buff[BUFFER_SIZE];
if((fd = open_port(TARGET_COM_PORT)) < 0) /* 打开串口 */
{
perror("open_port");
return 1;
}
if(set_com_config(fd, 115200, 8, 'N', 1) < 0) /* 配置串口 */
{
perror("set_com_config");
return 1;
}
do
{
memset(buff, 0, BUFFER_SIZE);
if (read(fd, buff, BUFFER_SIZE) > 0)
{
printf("The received words are : %s", buff);
}
} while(strncmp(buff, "quit", 4));
close(fd);
return 0;
}Execute o programa para gravar a porta serial no computador host e execute o programa para ler a porta serial na placa de destino. Os resultados são mostrados abaixo.
/* 宿主机 ，写串口*/
$ ./com_writer
Input some words(enter 'quit' to exit):hello, Reader!
Input some words(enter 'quit' to exit):I'm Writer!
Input some words(enter 'quit' to exit):This is a serial port testing program.
Input some words(enter 'quit' to exit):quit
/* 目标板 ，读串口*/
$ ./com_reader
The received words are : hello, Reader!
The received words are : I'm Writer!
The received words are : This is a serial port testing program.
The received words are : quit