AVR Freaks

Personally I almost always do Rx-interrupts, Tx-Polled. I suppose the advantage of Tx-interrupt is that it is "fire and forget". You just fill your buffer to send, trigger it and then get on with other things so it does really depend on whether you think that "stop while I transit" is acceptable or do you need transmit as a "background task".

As for what I meant by main() a "clear main". I pushed some C++ code the other day ( https://github.com/wrightflyer/s... ). The main() looks like:

#include "encoder.h"
#include "uart.h"
#include "timer0.h"
#include "button.h"
#include "dualjoystick.h"

void timerUpdate(void);

Encoder enc1(&PORTC, 0, 1);
Encoder enc2(&PORTC, 6, 7);
Encoder enc3(&PORTD, 0, 1);
Encoder enc4(&PORTD, 2, 3);
Encoder enc5(&PORTD, 4, 5);
Encoder enc6(&PORTD, 6, 7);
Encoder enc7(&PORTB, 0, 1);
Encoder enc8(&PORTB, 2, 3);
Button but1(&PORTC, 2, Button::NO_PULL_UP);
Button but2(&PORTC, 3, Button::NO_PULL_UP);
Button but3(&PORTC, 4, Button::NO_PULL_UP);
Button but4(&PORTC, 5, Button::NO_PULL_UP);
Button but5(&PORTA, 4, Button::NO_PULL_UP);
Button but6(&PORTA, 5, Button::NO_PULL_UP);
Button but7(&PORTA, 6, Button::NO_PULL_UP);
Button but8(&PORTA, 7, Button::NO_PULL_UP);
Uart uart(9600);
Timer0 tim(Timer0::TIM0_CTC, 100);
DualJoystick joy(0, 1, 64);

int main(void) {
    int32_t prev1 = 0, prev2 = 0, pos;
    uint16_t prevX = 0, prevY = 0;

    uart.connectStdio();
    printf("Hello World\r\n");
    tim.start(64);
    tim.attachInterrupt(Timer0::TIM0_COMP_ISR, timerUpdate);
    while(1) {
        pos = enc1.read();
        if (pos != prev1) {
            printf("Pos1 = %ld\r\n", pos);
            prev1 = pos;
        }
        pos = enc2.read();
        if (pos != prev2) {
            printf("Pos2 = %ld\r\n", pos);
            prev2 = pos;
        }
        if (but1.read() == 0) {
            printf("Reset1");
            enc1.readAndReset();
        }
        if (but2.read() == 0) {
            printf("Reset2");
            enc2.readAndReset();
        }
        DualJoystick::reading_t reading;
        reading = joy.read();
        if (abs(reading.x - prevX) > 4 || abs(reading.y - prevY) > 4) {
            printf("Joy X=%d, Y=%d\r\n", reading.x, reading.y);
            prevX = reading.x;
            prevY = reading.y;
        }
    }
}

void timerUpdate(void) {
    enc1.intUpdate();
    enc2.intUpdate();
    enc3.intUpdate();
    enc4.intUpdate();
    enc5.intUpdate();
    enc6.intUpdate();
    enc7.intUpdate();
    enc8.intUpdate();
    but1.update();
    but2.update();
    but3.update();
    but4.update();
    but5.update();
    but6.update();
    but7.update();
    but8.update();
}

I like to believe that the overall structure of what that (unfinished!) code is doing is clear from this. All the "detail" is hidden in the C++ classes that are being constructed and accessed.

Also when I developed this I was able to test each of those things (Uart, timer, Encoder, Buttons, DualJoystick) in isolation before I started to tie things together.

BTW regarding your original question 2. You usually do it with TXC. In your Transmit_bufferful() routine you simply enable the TXC interrupt and put the first character to send into UDR to start the process. Each time the transmission of one byte completes it triggers the TXC ISR which then checks to see if there are more to send in the buffer. If there are it just loads the next character which restarts the entire process but when you get the interrupt and there's no more to send you then just clear TXCIE so it goes "quiet" again until you have new stuff to send later on.

and many more to be found on the Product Page:

https://www.avrfreaks.net/commen...

https://www.avrfreaks.net/commen...

https://xod.io/