serialusb | A cheap USB proxy for input devices | Change Data Capture library

I found where the problem come from. I just need to replace lcd.println(msg); by lcd.print(msg);

I suspect from the Sparkfun board notes (https://www.sparkfun.com/products/14812) that the problem is that the Redboard Turbo is a 32-bit processor, with a 32-bit int instead of a 16-bit int. On such a processor, all 16 bit values stored in an int are positive.

To test my theory, run the following Sketch on your Redboard Turbo:

You can't return stack allocated memory from a function. Once the function call ends that data will be reclaimed when the stack pointer is updated. You need to either dynamically allocate the memory on the heap like so ...

The problem is that the first println theoretically has to show 1791234567, because I'm just multiplying 179.1234567 x 10000000 but it shows 1791234560. Why is this 0 appearing? Where is the 7?

This is probably due to precision limits of float. Try double instead.

The second problem is that payload[0] should be 6A hex, but my println shows 106.

You can provide a format for println(), like this:

Template types must be solved at compiler time. Instantiate your class with template class HalUART; instead of USARTClass (once class USARTClass : public UARTClass;). And, also, in the Serial_ case, for instance, use if constexpr (c++17 only) with std::is_same:

When you call led_battery() from the interrupt handler, you're doing waaaaay too much work there.

The interrupt can interrupt anything that doesn't have interrupts locked out.

Suppose your code is outputting something using Serial and the timer interrupt happens. Now your code was running code somewhere inside Serial, and you call Serial again... while the software and hardware can be in inconsistent states.

This is the case with every subroutine and hardware access you do from an interrupt handler. The only way to protect against this is to disable interrupts whenever your code might be accessing hardware or might have modifying data structures.

Unfortunately, disabling interrupts is error-prone - if you forget to do it, you'll have mysterious crashes. If you forget to reenable them, you're in big trouble - your network, timers and Serial will all stop working. It also adds a lot of overhead to your code. And it degrades your overall system performance - it will delay or cause you to miss network and timer events. You may drop characters from the serial port. And you can be certain that none of the code in the Arduino Core is doing this for you.

So, long story short, locking out interrupts so that you can do a lot in an interrupt handler is just not practical.

You also want to minimize the time you spend in the interrupt handler, as this preempts network stack, timer, serial and other hardware processing and may block other

You pointed out the way we deal with this in your original post: set a flag (make sure it's volatile) in the interrupt handler and handle it in a task. Unless you really, really know what you're doing and how all the software works in your system, this is the only practical way to handle this. If you try to do the amount of work and call the things you're calling from an interrupt handler, your program will malfunction and crash.

You can get integer value from a hex digit (where hex digit is any character from this set: 0123456789abcdefABCDEF):

Very common logic problem.

Change ok = true to return true and move return false to the outside of the loop.