Como funciona a série TTL?

Eu tenho tentado encontrar uma boa descrição do "padrão" serial TTL sem muita sorte. Entendo que as linhas de transmissão serial (TX) e de recepção (RX) ficam ociosas (no VCC) e caem no chão quando um bit é transmitido. Como tal, eles são invertidos da norma, onde um "1" é alto e "0" é baixo.

O que não entendo é quem é responsável por manter a linha alta e como um zero é transmitido. O remetente conduz a linha para alta e baixa? Ou o receptor mantém a linha alta com o remetente puxando a linha para baixo (coletor aberto)?

Com o TTL serial, existem duas linhas de dados unidirecionais. Cada um é conduzido pelo remetente, alto e baixo. Um bit 0 é representado por 0V a 1 bit pelo VCC.

O pino do receptor deve ser definido como uma entrada.

Portanto, para um microcontrolador enviar um byte (8-N-1 sem controle de fluxo), ele poderia fazer algo assim:

#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);
}

(Este código lê um pouco para trás, pois foi originalmente criado para serial TTL invertida)

Obviamente, a maioria dos MCUs possui UARTs de hardware que fazem tudo isso para você.

Aqui está o que você veria em um escopo:

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

Aqui está um ótimo vídeo de ladyada explicando a série: http://www.adafruit.com/blog/2010/09/15/usb-serial-and-you-video-an-adafruit-after-school-special/

Você não diz em tantas palavras, mas o "ponto morto" sugere que você quer dizer um UART. O UART é um ponto a ponto conectado aos transceptores de linha, como o onipresente mas datado MAX232 (existem soluções muito melhores hoje em dia). A linha entre microcontrolador e transceptor também será curta; se houver distância a ser superada, será entre os transceptores.
A saída do controlador é um push-pull.

O P-MOSFET fornecerá o nível alto, o N-MOSFET o nível baixo. Um deles deve estar ativo ou o nível da linha flutuaria e seria indefinido (ou definido por uma carga no transceptor). Ambos são capazes de obter / absorver alguma corrente e puxam a linha para os trilhos, de modo que o formato do sinal será quase ideal.
O que seria diferente se fosse realmente TTL, como na sua pergunta (o microcontrolador é o HCMOS). As saídas TTL são altamente assimétricas: elas podem fornecer apenas pouca corrente, normalmente 0,4 mA. Corrente de afundamento está OK, a 8mA. A baixa corrente da fonte pode ser um problema se a linha tiver uma alta capacitância e for de alta velocidade. A baixa corrente do inversor significa que a capacitância carregará apenas de forma relativamente lenta e as bordas ascendentes serão lentas, o que em alta velocidade pode causar séria distorção do sinal. TTL nunca é usado para isso.

Sua pergunta também pode se referir a uma linha multiponto , onde vários dispositivos podem conversar. Nesse caso, você não pode usar a saída push-pull: se um dispositivo elevasse a linha alta enquanto outro a reduzisse, haveria um curto-circuito. As linhas multiponto quase sempre usam resistores pull-up para manter a linha ociosa alta. Então, apenas um nível baixo exige a condução da linha e, em vez da saída push-pull, teremos um dreno aberto, apenas com o N-MOSFET. A linha agora também é acionada de forma assimétrica: o resistor pull-up pode fornecer apenas pouca corrente, enquanto o FET pull-down pode conduzir a linha rapidamente ao solo. As linhas multiponto de alta velocidade, portanto, limitam os resistores de pull-up. Um exemplo é o I2C.