No idea what I'm committing here, but it goes on github

aabiot/DoubleReset.py

@@ -0,0 +1,26 @@
+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()
+        if Check == '1':
+            os.remove(File)
+            return True
+    except OSError:
+        pass
+    a=open(File,"w")
+    a.write("1")
+    a.close()
+    sleep(Time)
+    os.remove(File)
+    return False
+
+    

aabiot/LED.py

@@ -0,0 +1,49 @@
+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)
+

aabiot/__init__.py

@@ -0,0 +1,6 @@
+from aabiot.LED import LED
+from aabiot.DoubleReset import DoubleReset
+
+print("AABIOT v0.1 imported")
+
+

aabiot/wiegand.py

@@ -0,0 +1,73 @@
+"""
+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)