How to increase the serial port's data throughput

Question

I have an array of numbers that will be subtracted from the ADC readings of a 50 Hz sine wave. Using Serial.begin(57600);, I can only output 25 samples per sine wave cycle, or about 1,250 samples per second. my questions are:

1. how fast the increent of array number moves with y++ in my int sinus[]? because when i see on serial monitor with 52700 baudrate it can only show about 25 numbers per cycle (50Hz)
2. how to increase the speed the increment of y++ in my array?

int sinus[] = {
    70, 72, 83, 92, 108, 132, 157, 182, 207, 230, 243, 255, 255,
    255, 250, 238, 217, 193, 169, 143, 118, 98, 88, 77, 72, 80
};
int dataSensor;
int hasil[26];
int datasensor2;
int dataBaru;
int x;
int y;
int intPin = 2;
int output;
int output2;
int toggle;
int toggle2;
int z;

void setup() {
    TCCR1A = 0b00000010;
    TCCR1B = 0b00011100;
    TCCR0A = 0;  //disable millis, delay and mciros
    TCCR0B = 0;
    ICR1 = 3200;

    Serial.begin(57600);

    pinMode(A1, INPUT);
    pinMode(A0, INPUT);
    pinMode(A2, INPUT);
    pinMode(intPin, INPUT);
    pinMode(9, OUTPUT);
    pinMode(10, OUTPUT);

    attachInterrupt(0, genJeah, RISING);
}

void genJeah() {  //intrupsi rising
    y = 5;
}

void loop() {
    dataSensor = analogRead(A0);
    toggle     = digitalRead(A1);
    toggle2    = digitalRead(A2);
    dataBaru = map(dataSensor, 0, 1023, 0, 255);

    for (x = 0; x < 25; x++) {
        hasil[x] = sinus[x];
    }
    // for (x=0; x<100; x++){

    output = sinus[y] - dataBaru;
    Serial.println(output);
    y++;
    if (y > hasil[26]) {
        y = 0;
    }
}

Answer 1

If you are looking for throughput then stop sending the ASCII conversion of numbers and just send the numbers. In other words, use Serial.write() rather than Serial.print(): you can send ~25k integers per second with a 52k baudrate.

As you are actually remapping the ADC output to a single byte, that means you can easily achieve a 48k/s throughput with this simple change.

If you are also looking for low latency please consider the USB connection is actually packet based, not stream based, which means you will receive the data in chunks, no matter how frequently you write. You can speed it up a bit flushing the channel, at the cost of throughput.

Answer 2

how fast the increment of array number moves with y++ in my int sinus[]?

Incrementing an int is fast enough. Even on a slowish Uno, y++ will take less than one microsecond to execute, so you can do it a million times per second if you want...

when i see on serial monitor with 52700 baudrate it can only show about 25 numbers per cycle (50Hz)

Your loop() is doing more than y++, no it's no wonder it takes more time!

There are two slow functions there:

• analogRead() takes about 110 µs

• Serial.println() is initially fast, but once the output buffer is full, it runs at the speed of the serial port.

The limiting factor here is Serial.println(). You are printing 4.6 bytes on average per sample (2.6 printable characters, plus CR and LF). Each byte is worth 10 bits on the wire (one start bit, 8 data bits and one stop bit). That is 46 bits per sample at 57,600 bits per second. The ratio of these numbers gives the 1,250 samples per second you experienced.

how to increase the speed the increment of y++ in my array?

It's very hard to answer this question because you did not explain what you are actually trying to achieve. If I naively take the question at face value, the simplest option is to just repeat y++ several times per loop iteration:

y++;
y++;
y++;
y++;

This can obviously be optimized into

y += 4;

and the compiler may even be able to figure out this optimization by itself.

But maybe what you don't care so much about speeding up y++, and instead you want to process more data samples per second? If this is the case, then you can speed up the loop by speeding up the serial port:

Serial.begin(115200);

by printing only every other sample (or one sample every N):

static bool print_this_sample;
if (print_this_sample) {
    Serial.println(output);
}
print_this_sample = !print_this_sample;

by printing one sample every so often:

static uint32_t last_print_time;
if (millis() - last_print_time >= PRINT_PERIOD) {
    last_print_time += PRINT_PERIOD;
    Serial.println(output);
}

by printing the samples in binary (first make sure they fit in a byte):

Serial.write((byte) output);

Now, what I suspect, is that you actually want to get your processing synchronized with the 50 Hz mains. If this is the case, you will have to completely rethink your program, and reason about the timings: at what specific time do you want to take each sample? The Arduino timing functions (millis() and micros()) should help.

As you see, half of this answer is me making guesses about what you may want to achieve. This is a sign of a very badly written question. Normally it is your job to explain that in detail. Please, rewrite the question and provide all the necessary background to help us understand your project, and the difficulties you are facing.