Simple test

Ensure your device works with this simple test.

examples/nonblocking_serialinput_simpletest.py
 1#!/usr/bin/env python3
 2# -*- coding: utf-8 -*-
 3
 4# SPDX-FileCopyrightText: 2017 Scott Shawcroft, written for Adafruit Industries
 5# SPDX-FileCopyrightText: Copyright (c) 2021 Stefan Krüger for s-light
 6#
 7# SPDX-License-Identifier: Unlicense
 8
 9"""Simple Minimal example of CircuitPython_nonblocking_serialinput library usage."""
10
11import time
12import board
13import digitalio
14import nonblocking_serialinput as nb_serialin
15
16##########################################
17# globals
18led = digitalio.DigitalInOut(board.LED)
19led.direction = digitalio.Direction.OUTPUT
20
21##########################################
22# menu
23
24my_input = nb_serialin.NonBlockingSerialInput()
25
26##########################################
27# main
28
29
30def main():
31    """Main."""
32    # wait for serial terminal to get ready..
33    time.sleep(1)
34    # we have to use the *drop-in* my_input.print() function.
35    # otherwise the rmote echo handling does not work.
36    my_input.print(42 * "*")
37    my_input.print("nonblocking_serialinput_simpletest.py")
38    my_input.print(42 * "*")
39
40    runtime_print_next = time.monotonic()
41    runtime_print_intervall = 1.0
42    running = True
43    while running:
44        # input handling
45        my_input.update()
46        input_string = my_input.input()
47        if input_string is not None:
48            # my_input.print("input_string: {}".format(repr(input_string)))
49            # we have at least a empty string.
50            if "exit" in input_string:
51                my_input.print("Stop Program running.")
52                running = False
53            elif input_string.startswith("hello"):
54                my_input.print("World :-)")
55            else:
56                # print a help message for the user..
57                my_input.print("type 'exit' to stop the program.")
58        # live sign
59        if runtime_print_next < time.monotonic():
60            runtime_print_next = time.monotonic() + runtime_print_intervall
61            my_input.print("runtime: {: > 7.2f}s".format(time.monotonic()))
62            led.value = not led.value
63
64
65##########################################
66if __name__ == "__main__":
67    main()
68
69##########################################

Advanced Usage

examples/nonblocking_serialinput_advanced.py
  1#!/usr/bin/env python3
  2# -*- coding: utf-8 -*-
  3
  4# SPDX-FileCopyrightText: Copyright (c) 2021 Stefan Krüger for s-light
  5#
  6# SPDX-License-Identifier: Unlicense
  7
  8"""Simple Minimal example of CircuitPython_nonblocking_serialinput library usage."""
  9
 10import time
 11import sys
 12import board
 13import digitalio
 14import nonblocking_serialinput as nb_serialin
 15
 16##########################################
 17# globals
 18led = digitalio.DigitalInOut(board.LED)
 19led.direction = digitalio.Direction.OUTPUT
 20
 21running = True
 22
 23runtime_print = True
 24runtime_print_next = time.monotonic()
 25runtime_print_intervall = 1.0
 26
 27##########################################
 28# menu
 29
 30
 31def userinput_print_help():
 32    """Print Help."""
 33    text = (
 34        "you can change some things:\n"
 35        "- 'tr': toggle print runtime ({runtime_print})\n"
 36        "- 'time set:???': set print runtime intervall ({runtime_print_intervall: > 7.2f}s)\n"
 37        "- 'exit'  stop program"
 38        "".format(
 39            runtime_print=runtime_print,
 40            runtime_print_intervall=runtime_print_intervall,
 41        )
 42    )
 43    my_input.print(text)
 44
 45
 46def userinput_handling(input_string):
 47    """Check Input."""
 48    # pylint: disable=global-statement
 49    global running
 50    global runtime_print
 51    global runtime_print_next
 52    global runtime_print_intervall
 53
 54    if input_string.startswith("tr"):
 55        runtime_print = not runtime_print
 56    elif "time set" in input_string:
 57        my_input.print("time set:")
 58        value = nb_serialin.parse_value(input_string, "time set")
 59        if nb_serialin.is_number(value):
 60            runtime_print_intervall = value
 61            runtime_print_next = time.monotonic() + runtime_print_intervall
 62    elif "exit" in input_string:
 63        my_input.print("Stop Program running.")
 64        running = False
 65
 66
 67my_input = nb_serialin.NonBlockingSerialInput(
 68    input_handling_fn=userinput_handling,
 69    print_help_fn=userinput_print_help,
 70)
 71
 72##########################################
 73# functions
 74
 75
 76def main_update():
 77    """Do all the things your main code want's to do...."""
 78    # pylint: disable=global-statement
 79    global runtime_print_next
 80
 81    if runtime_print:
 82        if runtime_print_next < time.monotonic():
 83            runtime_print_next = time.monotonic() + runtime_print_intervall
 84            my_input.print("{: > 7.2f}s".format(time.monotonic()))
 85            led.value = not led.value
 86
 87
 88##########################################
 89# main
 90
 91
 92def main():
 93    """Main."""
 94    # wait some time untill the computer / terminal is ready
 95    for _i in range(10):
 96        # my_input.print(".", end="")
 97        my_input.print(".")
 98        time.sleep(0.5 / 10)
 99    my_input.print("")
100    my_input.print(42 * "*")
101    my_input.print("nonblocking_serialinput_advanced.py")
102    my_input.print("Python Version: " + sys.version)
103    my_input.print("board: " + board.board_id)
104    my_input.print(42 * "*")
105    my_input.print("run")
106
107    # pylint: disable=global-statement
108    global running
109    running = True
110    while running:
111        try:
112            my_input.update()
113        except KeyboardInterrupt as e:
114            print("KeyboardInterrupt - Stop Program.", e)
115            running = False
116        else:
117            main_update()
118
119
120##########################################
121if __name__ == "__main__":
122    main()
123
124##########################################

Advanced Usage with class based approach

examples/nonblocking_serialinput_advanced_class.py
  1#!/usr/bin/env python3
  2# -*- coding: utf-8 -*-
  3
  4# SPDX-FileCopyrightText: Copyright (c) 2021 Stefan Krüger for s-light
  5#
  6# SPDX-License-Identifier: Unlicense
  7
  8"""Simple Minimal example of CircuitPython_nonblocking_serialinput library usage."""
  9
 10import time
 11import sys
 12import board
 13import digitalio
 14import nonblocking_serialinput as nb_serialin
 15
 16##########################################
 17# globals
 18
 19
 20class MyProjectMainClass:
 21    """This is just the Container Class for my Project."""
 22
 23    def __init__(self):
 24        super()
 25        self.my_input = nb_serialin.NonBlockingSerialInput(
 26            input_handling_fn=self.userinput_event_handling,
 27            print_help_fn=self.userinput_print_help,
 28        )
 29        self.running = False
 30
 31        self.led = digitalio.DigitalInOut(board.LED)
 32        self.led.direction = digitalio.Direction.OUTPUT
 33
 34        self.runtime_print = True
 35        self.runtime_print_next = time.monotonic()
 36        self.runtime_print_intervall = 1.0
 37
 38    ##########################################
 39    # menu
 40
 41    def userinput_print_help(self):
 42        """Print Help."""
 43        text = (
 44            "you can change some things:\n"
 45            "- 'tr': toggle print runtime ({runtime_print})\n"
 46            "- 'time set:???': set print runtime intervall ({runtime_print_intervall: > 7.2f}s)\n"
 47            "- 'exit'  stop program"
 48            "".format(
 49                runtime_print=self.runtime_print,
 50                runtime_print_intervall=self.runtime_print_intervall,
 51            )
 52        )
 53        self.my_input.print(text)
 54
 55    def userinput_event_handling(self, input_string):
 56        """Handle user input."""
 57        if "tr" in input_string:
 58            self.runtime_print = not self.runtime_print
 59        if "time set" in input_string:
 60            self.my_input.print("time set:")
 61            value = nb_serialin.parse_value(input_string, "time set")
 62            if nb_serialin.is_number(value):
 63                self.runtime_print_intervall = value
 64                self.runtime_print_next = (
 65                    time.monotonic() + self.runtime_print_intervall
 66                )
 67        if "exit" in input_string:
 68            self.my_input.print("Stop Program running.")
 69            self.running = False
 70
 71    ##########################################
 72    # main things
 73
 74    def runtime_update(self):
 75        """If enabled: print runtime & toggle LED."""
 76        if self.runtime_print:
 77            if self.runtime_print_next < time.monotonic():
 78                self.runtime_print_next = (
 79                    time.monotonic() + self.runtime_print_intervall
 80                )
 81                self.my_input.print("{: > 7.2f}s".format(time.monotonic()))
 82                self.led.value = not self.led.value
 83
 84    def update(self):
 85        """Update."""
 86        self.my_input.update()
 87        self.runtime_update()
 88
 89    def run(self):
 90        """Run."""
 91        self.running = True
 92        while self.running:
 93            try:
 94                self.update()
 95            except KeyboardInterrupt as e:
 96                self.my_input.print("KeyboardInterrupt - Stop Program.", e)
 97                self.running = False
 98
 99
100##########################################
101# main
102
103
104def main():
105    """Main."""
106    # wait some time untill the computer / terminal is ready
107    for _i in range(10):
108        print(".", end="")
109        time.sleep(0.5 / 10)
110    print("")
111    print(42 * "*")
112    print("nonblocking_serialinput_advanced_class.py")
113    print("Python Version: " + sys.version)
114    print("board: " + board.board_id)
115    print(42 * "*")
116
117    myproject = MyProjectMainClass()
118    myproject.my_input.print("run")
119    myproject.run()
120
121
122##########################################
123if __name__ == "__main__":
124    main()
125
126##########################################