Como obter mais de uma interface uart

Ok, eu tenho uma interface uart (TXD GPIO 14, RXD GPIO 15). Quero pelo menos mais uma interface uart.

Soluções possíveis:

• Batida de bits: use dois GPIOs sobressalentes não relacionados. Eu entendo que o tempo é um problema em um linux padrão. Seria confiável com taxa de transmissão muito baixa?

• Comutação: o RPI decide quando falar com qual dispositivo. Usando, por exemplo, CD4066BC .

• spi para 2 x ponte uart: não encontrou uma peça adequada (disponibilidade, preço, pacote dil)

• usb para uart: caro

Existem outras opções? Estou inclinado a mudar, se isso puder ser feito. O que você recomendaria?

Um UART USB, como o FTDI, não é muito caro. Todas as outras opções parecem que custarão mais em partes e tempo do que os US $ 13 que podem custar e não sejam confiáveis ​​ou lentas. Basta optar pela opção rápida e sem problemas, como:

http://www.dfrobot.com/index.php?route=product/product&product_id=147#.UOamLG-sh8E

Sparkfun vende um também. Na verdade, talvez você possa simplesmente retirar um de um dispositivo USB antigo ou comprá-lo em uma loja de lixo eletrônico que não sabe o que faz.

Eu errei com um adaptador SPI para UART para um projeto Arduino, não havia biblioteca existente, então escrevi a minha. No final, funcionou bem, mas se eu pudesse ter caído em uma parte de US $ 15, teria. De fato, dado o tempo que me custou, eu deveria ter conseguido um mega com 4 portas seriais.

Como alternativa, se você deseja muitas portas seriais, pode olhar para o serial RS485, que é semelhante ao 232 (embora não seja compatível), que suporta multiponto, ou seja, várias interfaces na mesma linha.

Se você decidir pular a adição de hardware extra e apenas seguir a rota dos bits, isso não é tão difícil quanto alguns imaginam.

Primeiro, seu segmento de comunicação deve ir em tempo real:

#include<sched.h>

struct sched_param param;               
param.sched_priority = sched_get_priority_max(SCHED_FIFO);
if( sched_setscheduler( 0, SCHED_FIFO, &param ) == -1 )
{
        perror("sched_setscheduler");
        return -1;
}

A partir de agora, seu encadeamento não será impedido por 950ms a cada segundo ^* , a menos que retorne o controle voluntariamente (por meio de sched_yield()ou usleep()) oportunamente, o que nunca o tornará impedido. Com CPU de 850 MHz, seu loop de vibração de bits fica ocioso a maior parte do tempo, mesmo em velocidades mais rápidas.

Agora, infelizmente, o requisito de retornar o controle de tempos em tempos significa que, enquanto seu thread estiver inativo, o que quer que sua "parte contrária" envie, estaria perdido para sempre. Mas, para esse propósito, você pode usar o controle de transmissão. Aloque um pouco mais da linha GPIO para CTS que você puxa para baixo antes de render e faz backup após restaurar o controle:

  bcm2835_gpio_write(CTS_PIN, LOW);
  usleep(10);
  bcm2835_gpio_write(CTS_PIN, HIGH);

ou (IMHO de preferência) use o controle de transmissão XON / XOFF - envie o caractere XOFF pelo RS232 antes de dormir, XON depois de retomar a operação. Os códigos ASCII padrão para estes são '\x13'para XOFF / "parar de enviar" e '\x11'para XON / "continuar enviando".

Obviamente, seu dispositivo remoto deve obedecer a eles. Caso contrário, alguns dados serão perdidos.

Encontrei o que você estava procurando: um escravo I2C / SPI da ponte UART / IrDA / GPIO.

Eles vêm na versão única e dupla (então 1 ou 2 UARTs extras). Eles (NXP) também (para o outro lado, se necessário) possuem mestre I2C / SPI para pontes UART / IrDA / GPIO.

Mais informações podem ser encontradas sobre esses chips aqui e na contraparte principal .

Maxim também tem chips que fazem exatamente a mesma coisa.

As pontes USB para UART são baratas e prontamente disponíveis, mas possuem características de tempo realmente ruins. Newark vende uma placa "Embedded Pi" que possui um processador STM32F ARM no qual você pode escrever código bare-metal. Esse chip tem três UARTs e acho que eles podem ir muito rápido; se você usasse um para se comunicar com o Raspberry Pi, deixaria dois disponíveis para outros fins. Isenção de responsabilidade: comprei uma dessas placas, mas até agora simplesmente usei o próprio Raspberry Pi para atender diretamente às necessidades de E / S.

Se você deseja muitos UARTs mais lentos, o STM32F na placa Embedded Pi provavelmente pode lidar com um número razoável, especialmente se você estiver disposto a escrever alguma linguagem de montagem de braço. Se houver dois grupos de 16 pinos de E / S disponíveis em uma única placa, pode ser possível ter 16 UARTs de software simultâneos, todos funcionando ao mesmo tempo a uma taxa de transmissão bastante decente (faça uma interrupção periódica em 3x ou 5x a taxa de transmissão que armazena Valores bloqueados de 16 bits da porta de recebimento para um buffer e emitem valores pré-computados de 16 bits de um buffer para a porta de transmissão; se você fizer isso, fornecerá o tempo médio de manutenção dos UARTs de software não é muito bom; não importará se houver uma ocorrência ocasional de pior caso (por exemplo, todas as dezesseis portas recebendo um byte simultaneamente).

Essa abordagem pode realmente funcionar notavelmente com eficiência para receber, já que o código de "caso comum" nem precisa procurar UARTs individuais. Suponha que você esteja amostrando dados em 5x e os últimos 47 bytes do buffer sejam duplicados imediatamente antes dele. Supondo que os dados sejam gravados no buffer em ordem crescente, é possível verificar se algum byte foi totalmente recebido em qualquer um dos 16 canais, basta dizer:

bytes_ready = (armed_flag & data[rxptr] & ~data[rxptr-47] & ~data[rxptr-46] & ~data[rxptr-45] & ~data[rx_ptr-44]);

Se bytes_readyfor zero, nenhum dado foi recebido. Caso contrário, se, por exemplo, o bit 2 de bytes_readyestiver definido, isso significa que um byte de dados recebido pode ser encontrado no bit 2 de dados [rx_ptr-40], dados [rx_ptr-35], dados [rx_ptr-30], etc. os dados, limpe o bit 2 do arm_flag e organize-o para que seja redefinido após cerca de 44 amostras.

Essa abordagem exigirá um pouco de trabalho nessas amostras em que um byte de dados é totalmente recebido (e potencialmente muito trabalho se todos os 16 canais tiverem um byte de dados chegarem de uma só vez), mas na maioria das amostras a quantidade de trabalho será muito alta. leve. Se alguém tivesse 64 pinos de E / S, seria possível lidar com até 32 UARTs usando essa abordagem sem adicionar nenhum trabalho extra ao caso "comum".

Um microcontrolador como um Picaxe pode receber dados seriais em um pino e enviar dados seriais em um determinado pino de maneira apropriada. Isso daria efetivamente mais saídas seriais se você estivesse preparado para informar ao Picaxe em qual pino a saída seria. Também poderia fazer o mesmo, mas ao contrário, para receber dados seriais de vários dispositivos e enviá-los ao Raspberry Pi. Outra opção pode ser fazer com que os dispositivos conectados exijam um qualificador . Isso significa que o dispositivo 1 precisaria receber os dados 'd1', por exemplo, antes de ouvir mais dados na linha serial. O dispositivo 2 pode ter 'd2' como qualificador. Isso significa que, para dizer 'olá' ao dispositivo 1, basta enviar 'd1hello' na linha UART.

Os picaxes são bastante baratos, você pode obtê-los em http://www.techsupplies.co.uk/ e eles vêm em vários tamanhos com diferentes números de pinos e assim por diante.

Se a comunicação com os vários dispositivos escravos UART não precisar ocorrer em paralelo, você poderá compartilhar a porta UART disponível entre eles. Você pode usar transistores para ativar apenas as conexões RxD / TxD com o dispositivo com o qual você deseja conversar atualmente. Esses transistores podem ser controlados por outros pinos do Raspberry Pi GPIO.

O Raspberry Pi 4 suporta até 4 interfaces UART agora que precisam ser ativadas por meio de uma sobreposição de árvore de dispositivos. Você pode descobrir como fazer isso e quais pinos são usados ​​aqui por enquanto:

https://www.raspberrypi.org/forums/viewtopic.php?t=244827

A fundação RPi ainda está preparando a documentação para isso.

Eu tive o mesmo problema. Preciso conectar-me a 2-4 módulos GSM e encontrei a solução de hardware: http://www.instructables.com/id/SPI-to-4-x-UART-Bridge-MULTIUART/

Esta solução é baseada em PIC24FJ64GA306. Você pode substituir o PIC pelo Atmel mcu, mas você deve criar um novo PCB :)

Estou usando o SC16IS752 IC, que é um conversor SPI para 2xUART. Funciona bem com o Raspbian Stretch.

É um pouco mais caro que o chip FTDI, mas existem dois uarts e não preciso usar a preciosa porta USB.

Dê uma olhada em https://www.kickstarter.com/projects/1915118535/uart-hat-for-raspberry-pi Espero que possa resolver seu problema