Comment fonctionne la série TTL?

J'ai essayé de trouver une bonne description du "standard" série TTL sans trop de chance. Je comprends que les lignes de transmission série (TX) et de réception (RX) sont inactives (à VCC) et qu'elles tombent à la masse lorsqu'un bit est transmis. En tant que tels, ils sont inversés par rapport à la norme, où "1" est élevé et "0" est faible.

Ce que je ne comprends pas, c'est qui est responsable de maintenir la ligne haute et comment un zéro est transmis. L'expéditeur pousse-t-il la ligne vers le haut et le bas? Ou le récepteur maintient-il la ligne haute avec l'expéditeur en tirant la ligne basse (collecteur ouvert)?

Avec la série TTL, il existe deux lignes de données unidirectionnelles. Chacun est entraîné par l'expéditeur, à la fois haut et bas. Un bit 0 est représenté par 0V et 1 bit par VCC.

La broche du récepteur doit être réglée sur une entrée.

Ainsi, pour qu'un microcontrôleur envoie un octet (8-N-1 sans contrôle de flux), il pourrait faire quelque chose comme ceci:

#define BAUDRATE 9600
#define DELAY (SYS_CLK/BAUDRATE)

#define UART_BITBANG_OFF     UART_BITBANG_PORT |= _BV(UART_BITBANG_PIN)
#define UART_BITBANG_ON      UART_BITBANG_PORT &= ~ _BV(UART_BITBANG_PIN)

#define UART_BITBANG_BIT(bit) {if (bit) UART_BITBANG_ON; else UART_BITBANG_OFF; _delay_us(DELAY);}

void uart_bitbang_init(void)
{
    UART_BITBANG_DDR &= ~ _BV(UART_BITBANG_PIN);        // TX output
}

void uart_bitbang_putc(uint8_t c)
{
    UART_BITBANG_BIT(1)
    UART_BITBANG_BIT((c & 0x1) == 0);
    UART_BITBANG_BIT((c & 0x2) == 0);
    UART_BITBANG_BIT((c & 0x4) == 0);
    UART_BITBANG_BIT((c & 0x8) == 0);
    UART_BITBANG_BIT((c & 0x10) == 0);
    UART_BITBANG_BIT((c & 0x20) == 0);
    UART_BITBANG_BIT((c & 0x40) == 0);
    UART_BITBANG_BIT((c & 0x80) == 0);
    UART_BITBANG_BIT(0);
}

(Ce code lit un peu en arrière car il était à l'origine destiné à la série TTL inversée)

Bien sûr, la plupart des MCU ont des UART matériels qui font tout cela pour vous.

Voici ce que vous verriez sur une portée:

https://www.pololu.com/docs/0J25/4.a

Voici une excellente vidéo de ladyada expliquant la série: http://www.adafruit.com/blog/2010/09/15/usb-serial-and-you-video-an-adafruit-after-school-special/

Vous ne dites pas autant de mots, mais le "ralenti" suggère que vous voulez dire un UART. Les UART sont un point à point connecté à des émetteurs-récepteurs de ligne, comme le MAX232 omniprésent mais daté (il existe de bien meilleures solutions de nos jours). La ligne entre le microcontrôleur et l'émetteur-récepteur sera également courte; s'il y a une distance à combler, ce sera entre les émetteurs-récepteurs.
La sortie du contrôleur est un push-pull.

Le P-MOSFET fournira le niveau élevé, le N-MOSFET le niveau bas. L'un d'eux doit être actif, sinon le niveau de ligne flotterait et ne serait pas défini (ou défini par une charge dans l'émetteur-récepteur). Les deux sont capables de générer / absorber du courant et de tirer la ligne vers les rails, de sorte que la forme du signal sera presque idéale.
Ce qui serait différent s'il s'agissait vraiment de TTL, comme dans votre question (le microcontrôleur est HCMOS). Les sorties TTL sont très asymétriques: elles ne peuvent fournir que peu de courant, généralement 0,4 mA. Le courant de descente est OK, à 8mA. Le faible courant de source peut être un problème si la ligne a une capacité élevée et une vitesse élevée. Le faible courant d'attaque signifie que la capacité ne se chargera que relativement lentement et que les fronts montants seront lents, ce qui à grande vitesse peut provoquer une grave distorsion du signal. TTL n'est jamais utilisé pour cela.

Votre question pourrait également faire référence à une ligne multipoint , où plusieurs appareils peuvent parler. Dans ce cas, vous ne pouvez pas utiliser la sortie push-pull: si un appareil conduisait la ligne haut tandis qu'un autre la conduisait bas, nous aurions un court-circuit. Les lignes multipoints utilisent presque toujours des résistances de rappel pour maintenir la ligne inactive à un niveau élevé. Ensuite, seul un niveau bas nécessite de conduire la ligne, et au lieu de la sortie push-pull, nous aurons un drain ouvert, avec juste le N-MOSFET. La ligne est désormais également pilotée de manière asymétrique: la résistance de pull-up ne peut fournir que peu de courant, tandis que le FET de pull-down peut entraîner la ligne rapidement à la masse. Les lignes multipoints à grande vitesse imposent donc une limite aux résistances de pull-up. Un exemple est I2C.