Renamed files to fit coding scheme

mipyiot/__init__.py

@@ -0,0 +1,4 @@
+from mipyiot.led import LED
+from mipyiot.doublereset import DoubleReset
+
+#print("AABIOT v0.1 imported")

mipyiot/doublereset.py

@@ -0,0 +1,28 @@
+from time import sleep
+import os
+
+
+def DoubleReset(Time=5, File="doublereset.txt"):
+    """Use this at the beginning of the file.
+    DoubleReset(Time=5,File="doublereset.txt")
+    Determines, if the board had two successive resets in the last <n> seconds.
+    This is done by writing a file in <File> and deleting it after <n> seconds.
+    If the file is already there, the reset was doubled."""
+    try:
+        a = open(File)
+        Check = a.read().strip()
+        a.close()
+        a = open(File, "w")
+        a.write(str(int(Check) + 1))
+        a.close()
+        sleep(Time)
+        os.remove(File)
+        return int(Check) + 1
+    except OSError:
+        pass
+    a = open(File, "w")
+    a.write("1")
+    a.close()
+    sleep(Time)
+    os.remove(File)
+    return False

mipyiot/led.py

@@ -0,0 +1,85 @@
+from machine import Pin
+from time import sleep
+
+
+class LED:
+    """Define a LED on a defined pin"""
+
+    def __init__(self, LEDPin=2):
+        self.LEDPin = Pin(LEDPin, Pin.OUT)
+        print("New LED defined on Pin %s" % LEDPin)
+
+    def Blink(self, number, timeon=0.2, timeoff=0.2):
+        """Blinks the LED (number) times, (timeon) and (timeoff) are self explanatory"""
+        for x in range(number):
+            self.LEDPin.off()
+            sleep(timeon)
+            self.LEDPin.on()
+            sleep(timeoff)
+
+    def Pulse(self, seconds, Speed=1):
+        """Helper function for Morse Code"""
+        self.LEDPin.off()
+        sleep(seconds)
+        self.LEDPin.on()
+        sleep(0.1 * Speed)
+
+    def Morse(self, text, Speed=1):
+        """Blinks (text) in morse code. Speed is around 60 cpm at 1 and proportional"""
+        Speed = 1 / Speed
+        Dot = 0.1 * Speed
+        Dash = 0.3 * Speed
+        SpaceInLetter = 0.1 * Speed
+        SpaceBetweenLetters = 0.3 * Speed
+        Space = 0.7 * Speed
+        alphabet = {
+            " ": " ",
+            "a": ".-",
+            "b": "-...",
+            "c": "-.-.",
+            "d": "-..",
+            "e": ".",
+            "f": "..-.",
+            "g": "--.",
+            "h": "....",
+            "i": "..",
+            "j": ".---",
+            "k": "-.-",
+            "l": ".-..",
+            "m": "--",
+            "n": "-.",
+            "o": "---",
+            "p": ".--.",
+            "q": "--.-",
+            "r": ".-.",
+            "s": "...",
+            "t": "-",
+            "u": "..-",
+            "v": "...-",
+            "w": ".--",
+            "x": "-..-",
+            "y": "-.--",
+            "z": "--..",
+            "1": ".----",
+            "2": "..---",
+            "3": "...--",
+            "4": "....-",
+            "5": ".....",
+            "6": "-....",
+            "7": "--...",
+            "8": "---..",
+            "9": "----.",
+            "0": "-----",
+            ".": ".-.-.-",
+        }
+
+        print("morsing %s" % text)
+        for c in text:
+            for m in alphabet[c.lower()]:
+                if m == ".":
+                    self.Pulse(Dot, Speed)
+                if m == "-":
+                    self.Pulse(Dash, Speed)
+                if m == " ":
+                    sleep(Space)
+            sleep(SpaceBetweenLetters)

mipyiot/wiegand.py

@@ -0,0 +1,79 @@
+"""
+weigand.py - read card IDs from a wiegand card reader
+
+(C) 2017 Paul Jimenez - released under LGPLv3+
+"""
+
+from machine import Pin, Timer
+import utime
+
+CARD_MASK = 0b11111111111111110  # 16 ones
+FACILITY_MASK = 0b1111111100000000000000000  # 8 ones
+
+# Max pulse interval: 2ms
+# pulse width: 50us
+
+
+class Wiegand:
+    def __init__(self, pin0, pin1, callback):
+        """
+        pin0 - the GPIO that goes high when a zero is sent by the reader
+        pin1 - the GPIO that goes high when a one is sent by the reader
+        callback - the function called (with two args: card ID and cardcount)
+                   when a card is detected.  Note that micropython interrupt
+                   implementation limitations apply to the callback!
+        """
+        self.pin0 = Pin(pin0, Pin.IN)
+        self.pin1 = Pin(pin1, Pin.IN)
+        self.callback = callback
+        self.last_card = None
+        self.next_card = 0
+        self._bits = 0
+        self.pin0.irq(trigger=Pin.IRQ_FALLING, handler=self._on_pin0)
+        self.pin1.irq(trigger=Pin.IRQ_FALLING, handler=self._on_pin1)
+        self.last_bit_read = None
+        self.timer = Timer(-1)
+        self.timer.init(period=50, mode=Timer.PERIODIC, callback=self._cardcheck)
+        self.cards_read = 0
+
+    def _on_pin0(self, newstate):
+        self._on_pin(0, newstate)
+
+    def _on_pin1(self, newstate):
+        self._on_pin(1, newstate)
+
+    def _on_pin(self, is_one, newstate):
+        now = utime.ticks_ms()
+        if self.last_bit_read is not None and now - self.last_bit_read < 2:
+            # too fast
+            return
+
+        self.last_bit_read = now
+        self.next_card <<= 1
+        if is_one:
+            self.next_card |= 1
+        self._bits += 1
+
+    def get_card(self):
+        if self.last_card is None:
+            return None
+        return (self.last_card & CARD_MASK) >> 1
+
+    def get_facility_code(self):
+        if self.last_card is None:
+            return None
+        # Specific to standard 26bit wiegand
+        return (self.last_card & FACILITY_MASK) >> 17
+
+    def _cardcheck(self, t):
+        if self.last_bit_read is None:
+            return
+        now = utime.ticks_ms()
+        if now - self.last_bit_read > 50:
+            # too slow - new start!
+            self.last_bit_read = None
+            self.last_card = self.next_card
+            self.next_card = 0
+            self._bits = 0
+            self.cards_read += 1
+            self.callback(self.get_card(), self.get_facility_code(), self.cards_read)