loading

Hi. I made my ewer first program in C++ for Arduino a couple of month’s ago.
One of them commands: delay(), got me to trouble… untill I found out that the ”program” actually ”halts” during delay(), it won’t do anything else during that time???. Take a look at my site http://www.teksel.net and there the Bilgepump to see where I need them delays in the functions, (alarm delay, them blinking’s etc.)++ Then I thought about how to get rid of that annoying behavour of delay(). OK. I built a TIME-generator of my own. It’s actually a kind of a ”stop-watch”, not a real-time clock, (keep that in mind all the way). I’ll ”catch” the millis() that’s generated by the processor, ( guess it’s as a part of in the ”bootloader”?), You could as well ”catch” the micros(), but I don’t need that accuaricy in my schedule here now. Of course You can use the delay(), but I recommend to use it with short delays only. Ewen my time-generator has to be considered in the whole program timewise. It’s good with the generator when the timeframes are in seconds and up…. Actually you can build it up to allmost infinity of time. True! Just get familiar to it and build on to …weeks..months.. of delay. Just keep in mind: WHENEWER THE POWER IS CUT OFF the timers are reset , (you could take a backup ewery now and then to the flash memory), but thats another story.

The accuarity of my time-generator isn’t ”top-exact”. I tested it with a delay of 25 minutes, and the ”off” was less than 1second. You can easyly calibrate your generator. I’ll get to that sometimes later on. 1’st make your whole program to run, (consider them serialPrint’s() allso, because they allso ”halt” the program). When done, test your time-generator by putting there a ”looo..ng” delay and time it with a clock.

I have written many programs in Assambler, for another type of processor with it’s own architechture). In that assam. program I built up a time-generator of my own, and now I transcripted it to C++. In part 1. I’ll discribe the function in the assam. in some details. You can jump right on to part 2. if you don’t wanna know this assambler part, (actually you don’t need it).

Step 1: The Assambler Part (you Actually Don't Need This), It's a Reference Only

Here are the some parts for the in assam. written program, Them ”labels” and comments are mostly in Finnish, but don’t mind them, I’ll explane. The processor generates an dynamic interrupt in it’s software, (depending on the prescalers/ - counters set by you in the program). That is: where ewer you are running in your program there will be a dynamic timer IRQ .
The processor jumps to the timer interrupt routine executing that and then return and continue from where it stopped. In the setup I load the basic times for 10mS; 100mS etc. I didnt have a need of 1mS or less in this application

;*************************************************************** ;

THE MAIN PROGRAM ;

***************************************************************

ldi time10,0ah ; Here I load variables for the timer

ldi time100,0ah

ldi time1s,07h

ldi time10s,06h

ldi time1m,0ah

ldi aputime,06h

ldi pa_aika,pa ;Switch debounce-time . . .

Here’s the timer interrup itself

;=============================================================== ;

TIMER interrupt ;

===============================================================

tim_int ld save_a,a ;Save the present acku value

call aika ;CALL THE TIMER SUBROUTINE!!!!!

ldi wdr,11111110b ;Reload the prescaler

ldi tcr,pre_tcr ;Preset the register

res 7,tscr ;Zero the TMZ bit, new count

ld a,save_a ;restore accu value

reti ;return from interrupt

Here’s a part of the time-generator subroutine that is called from the timer iterrupt

;=============================================================== ;

TIMER subroutine ;

===============================================================

aika dec time10 ;YOU COME HERE EWERY 1mS

jrz sata ;Check if time10 counted to zero

jp timeend ;Not yet, jump to end

sata ldi time10,0ah ;10ms reached

dec tahti1_a ;Some routines to do in the time window

jrnz sata_a ;within the 10mS, like here I use

ld a,tahti1 ;a FLIP-FLOP function with a

com a ;200mS frequence

ld tahti1,a ;Flop

ldi tahti1_a,ta1 ;200ms

sata_a dec tahti2_a ;Another FLIP-FLOP in the window

jrnz sata_b ; but this time a 500mS

ld a,tahti2 ;Flip

com a ;

ld tahti2,a ;Flop

ldi tahti2_a,ta2 ;500ms ;

sekunti ldi time100,0ah ;1second reached reload the 100mS

dec time1s

jrz sek_a

jp timeend . .

sek10 ldi time1s,06h ;10seconds reached reload the 1second

dec time10s ;Note 1second is loaded with 6, because

jrz sek10_a ;in 1minute there are 6 of 10seconds

jp timeend sek10_a

nop ;

yksimin ldi time10s,06h ;1minute reached reload the 10seconds

timeend ret

You can load within your program where ewer a variable with some value and do the decrementing of it to zero, (or to some pre-defined value), within the time-generator routine. To decrement is much more powerful to do instead of increment.. because it’s easyer to check if a count is zero than to do a comperasion to a given value.

Step 2: The Hack of Delay() in C++

Making a TIME-Generator in C++ for ex. Arduino. (I have to explane some same things again here that was in part 1. because some people jumps ower the part 1.).
Again: this generator acts like a ”count down” clock. It seems to act wery ”odd” because it actually ”counts UP”. I’ll come to that later on. Don’t copy from my example ”right off” because I wrote the program in Finnish and then translated these parts shown here, so there may be errors? I just wanna show the ”princibles” of the concept. The basic idea is that I ”grab” the millisecond generated by the processor, at ewery ”loop around” thus giving it a name ”nyky_time” = actual time.

Here are the variables

//------------ VARIABLES (will change)---------------------

unsigned long vanha_milli; // old_time in timegen.

unsigned long nyky_milli; // actual_time = millis()

unsigned long aika_1ms = 1; // time for 1ms

unsigned long tahti_1 = 0; // Count of 1ms

unsigned long tahti_10= 0 ; // Count of 10ms

unsigned long tahti_100= 0 ;// Count of 100ms

int tahti_1s = 0; // Count of 1second

int tahti_10s = 0 ; // Count of 10seconds

int tahti_1m ; // Count of 1minute

int tahti_10m ; // Count of 10minutes

Note: because the millis() is a unsigned long, so must the actual_time, old_time and time_1ms allso to be. In the mainprogram I call the timegenerator in ewery loop. There I ”Grab” the millis() to be nyky_milli and use it in the generator

//=============================================================

void loop() {

nyky_milli = millis(); // Grab the actual time to nyky_milli

// Call subroutines

timeout_tila(); // call timeout

reset_painike(); // call reset

aikagen(); // call the timegenerator

}

//======================== END of LOOP ===========================

Here is an example of using the timer. I want the reset_painike, (it’s a switch), to be read with a conciderition of a debounce time. Here I use a debounce time of 100mS, (reset_tahti), At first I complement the input (nyky_reset, LOW to HIGH and vice vers). Because I use in the setup them switch inputs to be with ”pull-up”, and therefore an active input is LOW, howewer it’s more logical to work with logical HIGH when active.

//================================================================

void reset_painike() { // Debounce

nyky_reset = digitalRead(sw_reset); //Read the switch

nyky_reset =! nyky_reset ; // Because active is = 0, so invert it

if ((nyky_reset == HIGH ) && (reset_tahti <=1))

{reset_apu1 = HIGH ;

} else { reset_apu1 = LOW ;}

if (nyky_reset == LOW) // If NOT active then

reset_tahti = 100 ; // RELOAD THE DEBOUNCE TIME

//================================================================

Here is the actual TIME-GENERATOR

//================================================================

void aikagen() { // The base count is 1ms

if (nyky_milli - vanha_milli > (aika_1ms /100)) //New time – Old Time

{ ++tahti_1 ; } // Increment until 1ms is reached

// Count 10ms

vanha_milli = nyky_milli; // The old_time becomes the new_time

if (tahti_1 >= 10 ) // Reached 1ms?

{ tahti_1 = 0 ;

++tahti_10 ; }

// HERE I RUN A DEBOUNCE CHECK OF A SWITCH (NYKY_RESET) //

if (reset_tahti >= 1) //Note: it will still decrement when 1

--reset_tahti; //Note: the reset_tahti is decremented

// Count 100ms

if (tahti_10 >= 10) // Reached 10ms?

{ (tahti_10 = 0);

++tahti_100 ;

//HERE WE DO THE TASKS WE WANT TO DELAY IN 100mS WINDOW

//I HAVE THIS ”TIMEOUT” FUNCTION IN MY PROGRAM, AND HERE I

//”TRY” TO COUNT IT DOWN TO ZERO, AND IF IT REACHES ZERO,

//I NOTICE THAT IN THE ”TIMEOUT” ROUTINE.

//THE VARIABLE timeout_1 WILL BE RELOADED WITH A VALUE

//(WHAT SO EWER IT IS)AGAIN and AGAIN IN THE TIMEOUT ROUTINE

//UNTIL THE PROGRAM SAYS TO ”START” THE COUNT DOWN

if (timeout_1 >= 1) // Test: value setted: 25,5sek.

-- timeout_1 ;} // Measured time: 25,6sek.

//Note: the timeout_1 is decremented

// Count 1sek

if (tahti_100 >= 10) // Reached 100ms?

{ (tahti_100 = 0);

++tahti_1s ;} // Count 10sek

// if (tahti_1s >= 10)

// Reached 1sek?

// { (tahti_1s = 0);

// ++tahti_10s; }

// Count 1min

if (tahti_1s >= 60) // Reached 10sek?

{ (tahti_1s = 0);

++tahti_1m;}

// Count 10min

if (tahti_1m >= 10) // Reached 1minute?

{ (tahti_1m = 0);

++tahti_10m ;}

} // Return //============================================================

The subroutine TIMEOUT

//================================================================

void timeout_tila() {

// timeout_1 "is loaded" again when MANU is NOT "active"

if (timeout_1 >= 1 ) //Has the "Count down" in timegen. //reached zero?

{digitalWrite (led_time, LOW);No

} else { time_alarm = HIGH ; // Hälytys

bitSet ((alarm_rek),0); // Alarm 0= TIME,blinkroutine

digitalWrite (led_time, HIGH); }

}

//================================================================

I’ll attach the complete scetch Bilge_X.ino , but notice that it’s in FINNISH, hope it gives you some ideas anyway.

About This Instructable

302views

8favorites

Bio: Gee.. Me 65+ years. My first contact with them locic's was about in them mid-70's. There was allso something called &quot;DTL-logic, and ewen ... More »
More by KISELIN:Hack the delay() function in Arduino OPTO-MOSFET Driver A Simple Control of FWD/REW of a DC-motor 
Add instructable to: