Hello all and thanks for reading my question
I have this code t.every(5000, doSomething);
doSomething is actually a function in the code, the 5000 is a value from memory.
My problem is that the Arduino dumps out a pulse generated in doSomething every 5 seconds as predicted for a while. However, after some period of time, within 24 hours it changes from the 5 seconds to a minute.
does anyone have any experience with a problem like that?
Post. Your. Code.
Use code tags.
rr1024:
My problem is that the Arduino dumps out a pulse generated in doSomething every 5 seconds as predicted for a while. However, after some period of time, within 24 hours it changes from the 5 seconds to a minute.does anyone have any experience with a problem like that?
Looks like "a problem like that" is as old as the invention of programmable microcontrollers/microprocessors.
Timer t;
int tickEvent;
unsigned int FR_INTERVAL;
unsigned int P_WIDTH;
unsigned long seconds;
unsigned int minutes, hours, days, secs_left, mins_left;
void setup()
{
digitalWrite(OP_SHDN_L, OP_OFF);
pinMode(Debug_IO11, OUTPUT); //Debug IO13 pin 18
digitalWrite(Debug_IO11, LOW); //Debug IO13 pin 18
pinMode(Strobe_Out, OUTPUT);
digitalWrite(Strobe_Out, LOW);
analogReference(INTERNAL);
analogRead(BATT_PIN[0]);
LoadSettings();
Serial.begin(19200);
attachInterrupt(1, PulseMode, RISING );
state = mIDLE; //mIDLE
interrupts();
[b]tickEvent = t.every(FR_INTERVAL, doFreeRun);[/b]
}
/*
* loop()
* Desc - ?
* exeTime ~38uSec
* return - void
*/
void loop() {
char keypress;
int idx;
//digitalWrite(Debug_IO11, LOW); //Debug IO13 pin 18
//Serial.print("state in ");
//Serial.println(state);
//jumper not installed
if (digitalRead(FREE_RUN)){
if (state == FREERUN){
state = mIDLE;
digitalWrite(OP_SHDN_L, OP_OFF);
//Serial.println("enter state mIDLE"); //Debug
}
}else{
if ((state == mIDLE) & !SERCONTROL){
state = FREERUN;
digitalWrite(OP_SHDN_L, OP_ON);
//Serial.println("state mIDLE Entering FREERUN"); //Debug
}
}
//if the cal jumper is in place, draw the menu
if (!digitalRead(CAL_MODE)){
if (state != CALMENU){
state = initCALMENU; //cal mode
//Serial.println("state initCALMENU"); //Debug
}else{
state != CALMENU;
//Serial.println("state CALMENU"); //Debug
}
}
if (Serial.available() > 0){
keypress = ckSerialIn( Serial.read() ); //Serial.read(); //rev 1.5
//if (keypress == 'F'){
// SERCONTROL = true;
// }
if (!SERCONTROL){
//Serial.println(state); //Debug rev 1.5
//Serial.println(SERCONTROL); //Debug rev 1.5
//Serial.println(keypress); //Debug rev 1.5
Serial.println("Timer Stopped");
Serial.println("cmd R, S or I");
}
SERCONTROL = true;
t.stop(tickEvent);
state = mIDLE;
digitalWrite(OP_SHDN_L, OP_OFF);
//keypress = Serial.read(); //rev 1.5 moved to serial available() above
switch(keypress){
case ('R'): //resume rev 1.3
Serial.println("Freerun Started");
[b] tickEvent = t.every(FR_INTERVAL, doFreeRun); [/b]
state = FREERUN;
digitalWrite(OP_SHDN_L, OP_ON);
SERCONTROL = false;
pinMode(Background, ENABLE); //Pre //rev 1.4
digitalWrite(Background, HIGH); //rev 1.4
break;
case ('S'): //reset arduino stats rev 1.3
Serial.println("Reset Stats");
//reset usedCapacity to 0.0
for (idx = 0;idx < 8; idx++){
battery[idx].usedCapacity = 0.0;
}
cycles = 0;
break; //rev 1.2 added missing break
case ('I'): // get cal and status info rev 1.3
doPrintCalib();
break;
}
}
switch (state){
case (initCALMENU): //Hardware selected Jumper
delay(200);
LoadSettings();
clearAndHome();
drawCalMenu(0);
state = CALMENU;
digitalWrite(OP_SHDN_L, OP_OFF);
break;
case CALMENU:
serviceCalMenu();
break;
case mIDLE:
break;
case PULSE: // pin input trigger
doFreeRun();
delay(10); //100ms debounce/holdoff
state = mIDLE; //wait for the next trigger
break;
case FREERUN: //timer trigger
t.update();
break;
}
//digitalWrite(Debug_IO11, LOW); //Debug IO13 pin 18
}
/*
* doFreeRun()
* Desc - ?
* exeTime ~624mSec W/ doStatusDraw();
* return - void
*/
void doFreeRun()
{
String stringOne;
String stringTwo;
String stringThree;
unsigned long time;
int idx;
float voltage;
float ESR;
//digitalWrite(Debug_IO11, HIGH); //Debug IO13 pin 18
//char keypress;
//Pulse the external strobe pin to trigger the external DAQ module
pinMode(Strobe_Out, ENABLE); //Pre //rev 1.4
digitalWrite(Strobe_Out, HIGH); //rev 1.4
delay(500);
digitalWrite(Strobe_Out, LOW); //rev 1.4
delay(10);
cycles++;
readbatteries(); //Get the background voltages
for (idx = 0; idx < 8; idx++){ //copy the background voltages
battery[idx].backVolt=((float)batteryADC[idx]/1023.0*2.54)/10.0;
}
pinMode(Background, DISABLE); //rev 1.4
digitalWrite(Background, LOW); //disable internal pullup //rev 1.4
pinMode(spare, ENABLE); //pulse on spare //rev 1.4
digitalWrite(spare, HIGH); //rev 1.4
time = millis();
//delay(P_WIDTH-10); //1 second load minus the ADC time
while(millis()<(time+P_WIDTH-15)); //wait for pulse
readbatteries(); //Get the loaded values routine takes 11.2ms to complete
while(millis()<(time+P_WIDTH)); //wait for pulse
pinMode(spare, DISABLE); //rev 1.4
digitalWrite(spare, LOW); //disable internal pullup //rev 1.4
pinMode(Background, ENABLE); //Pre //rev 1.4
digitalWrite(Background, HIGH); //rev 1.4
if (mBlink == 1){
digitalWrite(LED,HIGH);
}else{
digitalWrite(LED,LOW);
}
mBlink = !mBlink;
[b]seconds = FR_INTERVAL/1000L; //units of seconds[/b]
for (idx = 0; idx < 8; idx++){ //compute the load voltages and ESR
battery[idx].loadVolt=((float)batteryADC[idx]/1023.0*2.54)/10.0;
voltage = battery[idx].backVolt - battery[idx].loadVolt; //voltage difference
battery[idx].ESR = voltage/((channel_Cal[idx].pulseCurrent - channel_Cal[idx].backCurrent)/1000000.0);
[b]battery[idx].usedCapacity += (channel_Cal[idx].backCurrent/1000.0) * ( (float)(FR_INTERVAL - P_WIDTH) / 3600000.0) ; //sum of background current (in mAHr)
battery[idx].usedCapacity += (channel_Cal[idx].pulseCurrent/1000.0) * ((float)P_WIDTH / 3600000.0); // sum of pulse current (in mAHr)[/b]
}
//digitalWrite(Debug_IO11, HIGH); //Debug IO13 pin 18
doStatusDraw(); //Output battery data to terminal
//digitalWrite(Debug_IO11, LOW); //Debug IO13 pin 18
}
I imagine the compiler doesn't like the [b] [/b] in the middle of the code.
OMG, really...lol I thought it would bold the important parts for you but I guess this forum doesn't do that...
I did mention the Arduino was running which means the bolds could not have been there since it wouldn't compile ...lol
So how would I go about preventing buffer overflow, although I guess this is more of a memory overflow or something.
So how would I go about preventing buffer overflow
Don't write beyond the end of the buffer you have allocated. That's hardly a difficult concept to grasp.
Sorry but I'm new to embedded programming, I don't see anywhere that I have written anything beyond any buffer...lol
How do I control the buffer or how do I know it's bounds or evey where it is in my code?
rr1024:
Sorry but I'm new to embedded programming, I don't see anywhere that I have written anything beyond any buffer...lolHow do I control the buffer or how do I know it's bounds or evey where it is in my code?
analogRead(BATT_PIN[0]);
Where did THAT array come from?
Why would you read a book blindfolded? If you don't care what the value is, why bother?
SERCONTROL = false;
By convention, all capital letter names are reserved for constants. Constants NEVER appear on the left of an equal sign, except when getting an initial value.
battery[idx].usedCapacity = 0.0;
Where did THAT array come from?
delay(500);
digitalWrite(Strobe_Out, LOW); //rev 1.4
delay(10);
In an interrupt service routine? There isn't a hope in hell of THAT working.
Posting code that won't even compile, and then claiming that it works "for a while" wastes everyone's time.