micropython_neotimer

KO | EN

gitlite — search

#containers #cli #ui #machine-learning #chatbot #monitoring #javascript #redis #php #video

micropython_neotimer

(★ 14)

Neotimer implementation for Micropython

File Explorer

ZIP Download

- example_1.py
- example_debounce.py
- example_hold.py
- example_repetitions.py
- example_waiting.py
- example_waiting_2.py
.gitattributes
neotimer.py
README.md

# Use via CDN

jsDelivr

jsDelivr serves any public GitHub repository as a CDN with zero setup. Pick a version and a file to get a ready-to-paste link and snippet.

Version

File

Link

Example

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

Library footprint: approx 3kB

This library implements a non-blocking delay function
to use in your program. Originally developed by me 
for Arduino and Parallax Propeller 2.

## Why use Neotimer?

In the microcontroller world, delays are used extensively to control different aspects of timing control. 
This is usually implemented using functions such as time.sleep(). But when you call `time.sleep()` ,
the processor stops everything it is doing until this delay is completed.
That is called a blocking delay, because it blocks the processor until it finishes.
 
There are many situations where this is undesirable and you need to implement a workaround.

This library provides a way to use time delays without
blocking the processor, so it can do other things while the timer ends up.
This is called a non-blocking delay timer.
 
Neotimer provides a set of basic functionalities to implement different ways of timing in a program.
You can use the timer in the following ways:
 
### A) Start-Stop-Restart Timer -

You can start, stop and restart the timer. Once started it will count towards the initialization
time. You can check if it finished counting by calling `finished()`.

* `start()`   will start the timer.

* `stop()`   will stop the timer.
It will also return the elapsed milliseconds since it was started.

* `finished()`   will return True if the timer reached the initialization time.

* `restart()` will restart the timer.

```python
myTimer = Neotimer(200) #<-------- Initializes a 200ms timer

if collision_detected:
    myTimer.start()     #<--------- Starts timer
    led.on()
    
if myTimer.finished():
    led.off()  #<--------- Called after 200ms
```

### B) Periodic trigger (`repeat_execution()`)

The timer can be used to periodically trigger the execution of a block of code. The following example will toggle pin 25 every 500ms

```python
led_pin = Pin(25,Pin.OUT)
myTimer = Neotimer(500)   #<---------------- Initializes a 500ms timer

while True:
    if(myTimer.repeat_execution()):
        led_pin.toggle()  #<---------------- Called every 500ms
```

### C) Periodic trigger with count (`repeat_execution(count)`)

You can also trigger the execution of some code a specific amount of times. The following example will toggle pin 56 every 500ms, only 3 times. 
After 3 times, the timer will not repeat the code until a reset is issued. To reset the repetitions use `reset_repetitions()`.

```python
led_pin = Pin(25,Pin.OUT)
button = Pin(2, Pin.IN)

myTimer = Neotimer(500)   #<---------------- Initializes a 500ms timer
            
while True:
    if(myTimer.repeat_execution(3)): #<--- Only repeat 3 times
        led_pin.toggle()  #<---------------- Called every 500ms
    if(button.value()):
        myTimer.reset_repetitions() #<--- Reset repetitions
```

### D) Debouncer for signals

You can debounce a signal using debouce_signal.
The debouncing period will be duration.

In this example, the button pin value signal will
be debounced for 250 milliseconds:
```python
button = Pin(2, Pin.IN)
presses = 0
myTimer = Neotimer(250) #<--------------- Initializes a 250ms timer

while True:
    if myTimer.debounce_signal(button.value()): #<----- button pressed signal debounced for 250ms
        presses += 1
        print(presses)
```

### E) Hold signal

Neotimer can be used to detect a signal hold. For example holding down a button for 3 seconds:

```python
BUTTON_A = Pin(20,Pin.IN)
led = Pin(25,Pin.OUT)

myTimer = Neotimer(3000) #<---- 3 seconds hold time

while True:
    if myTimer.hold_signal(BUTTON_A.value()):
        led.on()
    else:
        led.off()
```

### F) Waiting

The following example will turn on the led for 1000ms each time the button is pressed

```python
from machine import Pin
from neotimer import *

button = Pin(2, Pin.IN)
led = Pin(25,Pin.OUT)
led.off()

# Two timers, one for debouncing the button signal
# and the other for generating a pulse using waiting()
debouncer = Neotimer(200)
pulse = Neotimer(1000)
 
while True:
    if debouncer.debounce_signal(button.value()):
        pulse.start()
        
    if pulse.waiting():  #<---- Led on during pulse time
        led.on()
    else:
        led.off()
```

Author: Jose Rullan

Date: January 24, 2022

micropython_neotimer

Owner Repos

File Explorer

# Use via CDN

Was this content helpful?

Recent Feedback

micropython_neotimer

Owner Repos

File Explorer

# Use via CDN

Was this content helpful?

Recent Feedback

Download README