How to transmit data over serial without losing data from main program

Projects Programming
1

I was trying to investigate the issue posted here:

https://forum.arduino.cc/index.php?topic=683117.0

when I stumbled across a post somewhere else saying that printing to serial consumes 1ms of time per character you print so if you print anything to serial you're going to lose at least a couple of ms worth of whatever you were doing prior to that.

So, if I'm using input capture to measure frequency and it's calling the input capture interrupt on every falling edge, at a frequency of say 2kHz, I can't send that ICP value I'm saving each cycle to the PC because while I'm doing that I'll miss several subsequent events.

I could try to buffer the events in an array and send them all at once but that won't do anything but make a bigger delay occur less often so there will still be a big hole in my data transmission.

What is the correct means of employing input capture with the intent of measuring ICR and sending each ICR value to the PC over serial without losing any data?

I'm wondering if this is why my ICR values jump all over the place instead of being predictable like the wave I'm generating for detection.

2

I stumbled across a post somewhere else saying that printing to serial consumes 1ms of time per character you print so if you print anything to serial you're going to lose at least a couple of ms worth of whatever you were doing prior to that.

That's not true, printing to serial either takes very little time, or blocks waiting for buffer space to become
freed up by the serial interrupts that actually drive the hardware. The time can vary significantly.

So long as you don't print too many characters at once and overflow the buffer, or try to output characters
faster than the baudrate permits, it should be very processor-time efficient - there already is a buffer and its
being processed in the background for you by interrupts. All Serial.write() has to do is check there's room
in the buffer and stick the char in.

If you use some sort of software serial library however, then it will be very different.

3

Ok well that cancels that out I guess. In that case, could there be any other reason you can think of, why Input Capture acting on a clean square wave of decreasing pulse width would spit out random hanging number instead of the steadily decrimenting values I would expect? Does prescaler have something to do with how often the ICU can detect events?

4

Gahhhrrrlic:
Ok well that cancels that out I guess. In that case, could there be any other reason you can think of, why Input Capture acting on a clean square wave of decreasing pulse width would spit out random hanging number instead of the steadily decrimenting values I would expect? Does prescaler have something to do with how often the ICU can detect events?

Is sounds like you are using interrupts to capture the data, do you have the variables used in both the interrupt service routine and the main code declared as volative, and are you temporarily disabling interrupts while accessing the variable outside the interrupt service routine?

In regards to your comment about serial taking 1mS per character, that is the approximate time it take per character at 9600 baud, hopefully you are using a higher baud rate (1,000,000 baud or higher is possible over the USB interface).

5

I was using a higher baud but because I can't nail down the cause of the weirdness I didn't know whether it was due to the baud being wrong, the prescaler being wrong or some other coding error. Here is the code in question:

#include <CaptureTimer.h>

int ledPin = 13;
int count = 0;

unsigned int lastTickTime = 0;
volatile uint16_t currentTime;

volatile bool sendTime = false;
volatile bool printSignal = 0;

ISR(TIMER4_CAPT_vect)  // PULSE DETECTED!  (interrupt automatically triggered, not called by main program)
{
 currentTime = ICR4;
 TCNT4 = 0;
}

void setup()
{
 cli();

 Serial.begin(9600, SERIAL_8N1);   // Open the serial library @ 9600bps

 // Initialize Timer1
 TCNT4 = 0;
 TCCR4A = 0;
 TCCR4B = 0;

 TCCR4B |= (1 << ICNC4);     // Enable denoiser
 TCCR4B &= ~(1 << ICES4);    // Capture on falling edge

 // Prescaler 1024 (101)
 // Prescaler 256 (100)

   TCCR4B |= (1 << CS42);    // 1
   TCCR4B &= ~(1 << CS41);   // 0
   TCCR4B &= ~(1 << CS40);   // 0

 TCCR4C = 0;

 TIFR4 = (1<<ICF4); 
 TIMSK4 |= (1 << ICIE4);
 sei();
}

// Set up the timer for the simulated ticks
void setupSimulationTimer()
{

DDRL |= 1 << DDL3;                                  // Set D46 as an output pin
TCCR5A = 0;                                         // Clear TCCR A & B bits
TCCR5B = 0;
TCCR5A = (1 << COM5A1);                             // Non-inverting output
TCCR5B = (1 << WGM53) | (1 << CS50) | (1 << CS52);  // Phase & Freq correct PWM,
ICR5 = 10000;                                       // 8 RPM
OCR5A = 2500;                                       // 25% duty... arbitrary

}

int i = 0;

void loop()
{
 // SIMULATION CODE
   currentTime = ICR5;

 if(i > 1) {                                 
   ICR5-=1;
   OCR5A = ICR5 * 0.25;
   i=0;
   if(ICR5 < 36) {                               
     ICR5 = 10000;
     OCR5A = 2500;
   }
 }
 i++;

 // END SIMULATION CODE

}