Publication

raspberry_pi/amsswcomm.py

@@ -0,0 +1,303 @@
+#!/usr/bin/python
+
+import os,sys,math
+import numpy as np
+
+#whatever arduino GPIO library 
+import RPi.GPIO as GPIO
+import time
+
+
+
+
+## dummy functions for now - work through the logic while you still have it in your head!
+def set_pinmode(pinnumber, mode):
+
+    #set GPIO mode to BOARD
+    if(mode==1):
+        GPIO.setup(pinnumber, GPIO.OUT)    
+    elif(mode==0):
+        GPIO.setup(pinnumber, GPIO.IN)
+        
+    return
+
+def read_pin(pinnumber):
+    ret = 0
+    val = GPIO.input(pinnumber)
+    ret = int(val)
+
+    return ret
+
+def write_pin(pinnumber, val):
+    #print("dummy: sending {} on {}".format(pinnumber, val))
+
+    if(val==1):
+        GPIO.output(pinnumber,GPIO.HIGH)
+    else:
+        GPIO.output(pinnumber,GPIO.LOW)
+
+    return
+
+
+#3-wire software-defined terminal class
+#mirrors the logic of the arduino class, for talking with 
+#arduino-nano controlled perhipheral devices
+class amsswcomm():
+
+    def __init__(self):
+
+
+
+        return
+    
+    def comminit(self, _ms, _clkpin, _sendpin, _recvpin, _divisor = 1):
+
+        self.ms = int(_ms)
+        self.clkpin = int(_clkpin)
+        self.sendpin = int(_sendpin)
+        self.recvpin = int(_recvpin)
+        self.divisor = _divisor
+
+
+        self.sendmessage = np.uint8([])
+        self.recvmessage = np.uint8([])
+        
+        self.clearrecvqueue()
+        self.clearsendqueue()
+
+        self.clockstate = 0
+        self.lastclockstate = 0
+        self.clockticks = 0
+
+        if(self.ms==1):
+            #master, most often the case for the raspberry pi
+            set_pinmode(self.clkpin,1)
+            set_pinmode(self.recvpin,0)
+            set_pinmode(self.sendpin,1)
+
+        elif(self.ms==0):
+            #servant
+            set_pinmode(self.clkpin,0)
+            set_pinmode(self.recvpin,0)
+            set_pinmode(self.sendpin,1)
+
+        else:
+            pass
+
+
+
+        return
+
+    def update_step(self):
+
+        if(self.ms==1):
+            #master, most often the case for the raspberry pi
+            if(self.clockticks<self.divisor):
+                self.clockticks = self.clockticks+1
+            else:
+                self.clockticks = 0
+
+                self.lastclockstate = self.clockstate
+                self.clockstate = int(not self.lastclockstate)
+                
+                write_pin(self.clkpin,self.clockstate)
+
+                if(self.clockstate==1 and self.lastclockstate==0):
+                    self.update_send()
+                if(self.clockstate==0 and self.lastclockstate==1):
+                    self.update_recv()
+    
+        elif(self.ms==0):
+
+            self.lastclockstate = self.clockstate
+            self.clockstate = read_pin(self.clkpin)
+
+            if(self.clockstate==1 and self.lastclockstate==0):
+                self.update_send()
+            if(self.clockstate==0 and self.lastclockstate==1):
+                self.update_recv()
+
+        else:
+            pass
+
+        return
+    
+    def clearrecvqueue(self):
+
+        self.recvmessage_byte = np.uint16(0)
+        self.recvbytepointer = 0
+        self.recvbitpointer = 0
+        self.recvstate = 0
+        self.recvmessage = np.uint8([])
+
+        return
+    
+    def clearsendqueue(self):
+
+        self.sendmessage_byte = np.uint16(0)
+        self.sendbytepointer = 0
+        self.sendbitpointer = 0
+        self.sendstate = 0
+        self.sendmessage = np.uint8([])
+
+        return
+
+    def update_send(self):
+
+        if(self.sendstate==0):
+            #do nothing, no message in queue
+            write_pin(self.sendpin,0)
+        elif(self.sendstate==1):
+            self.sendmessage_byte = 0b0000001111111111
+            bit = (self.sendmessage_byte & 1<<(9-self.sendbitpointer)) >> (9-self.sendbitpointer)
+            
+            write_pin(self.sendpin,bit)
+
+            self.sendbitpointer = self.sendbitpointer+1
+            if(self.sendbitpointer>=10):
+                self.sendbitpointer = 0
+                self.sendbytepointer = 0
+                self.sendstate = 2
+
+        elif(self.sendstate==2):
+            #send message byte
+            if(len(self.sendmessage)>=0):
+                self.sendmessage_byte = 0b0000001100000000 + self.sendmessage[self.sendbytepointer]
+                bit = (self.sendmessage_byte & 1<<(9-self.sendbitpointer)) >> (9-self.sendbitpointer)
+                write_pin(self.sendpin,bit)
+
+                self.sendbitpointer = self.sendbitpointer + 1
+                if(self.sendbitpointer>=10):
+                    self.sendbitpointer = 0
+                    self.sendbytepointer = self.sendbytepointer + 1
+                if(self.sendbytepointer>=len(self.sendmessage)):
+                    self.sendbitpointer = 0
+                    self.sendbytepointer = 0
+                    self.sendstate = 3
+            else:
+                #size 0 message
+                self.sendbitpointer = 0
+                self.sendbytepointer = 0
+                self.sendstate = 3
+            
+        elif(self.sendstate==3):
+            #send ending byte
+            self.sendmessage_byte = 0
+            bit = (self.sendmessage_byte & 1<<(9-self.sendbitpointer)) >> (9-self.sendbitpointer)
+            write_pin(self.sendpin,bit)
+
+            self.sendbitpointer = self.sendbitpointer+1
+            if(self.sendbitpointer>=10):
+                self.sendbitpointer = 0
+                self.sendbytepointer = 0
+                self.sendstate = 4
+
+
+        elif(self.sendstate==4):
+            #Finish and reset
+            self.clearsendqueue()
+        else:
+            #improper condition, should not occur
+            self.clearsendqueue()
+
+        return
+    
+    def update_recv(self):
+
+        if(self.recvstate==0):
+            bit = read_pin(self.recvpin)
+            if(bit==1):
+                self.recvstate = 1
+                self.recvbitpointer = 1
+                self.recvmessage_byte = 0b0000001000000000
+                self.recvbytepointer = 0
+                
+        elif(self.recvstate==1):
+            bit = read_pin(self.recvpin)
+            self.recvmessage_byte = self.recvmessage_byte + (bit<<(9-self.recvbitpointer));
+            self.recvbitpointer = self.recvbitpointer + 1
+
+            if(self.recvbitpointer>=10):
+                self.recvbitpointer = 0
+                if(self.recvmessage_byte == 0b0000001111111111):
+                    self.recvstate = 2
+                    self.recvbytepointer = 0
+
+                    #append to message
+                    #byte2 = np.uint8(self.recvmessage_byte & 0b0000000011111111)
+                    #self.recvmessage = np.append(self.recvmessage,byte2) 
+                    
+                    self.recvmessage_byte = 0
+                else:
+                    #garbled message
+                    self.clearrecvqueue()
+        
+        elif(self.recvstate==2):
+            #receive messsage byte
+            bit = read_pin(self.recvpin)
+            self.recvmessage_byte = self.recvmessage_byte + (bit<<(9-self.recvbitpointer));
+            self.recvbitpointer = self.recvbitpointer + 1
+
+            if(self.recvbitpointer>=10):
+                self.recvbitpointer = 0
+                
+                if(self.recvmessage_byte==0):
+                    #end of message byte
+                    self.recmessage_byte = 0
+                    self.recvstate = 3
+                else:
+                    #append to message
+                    byte2 = np.uint8(self.recvmessage_byte & 0b0000000011111111)
+                    self.recvmessage = np.append(self.recvmessage,byte2) 
+                    self.recvmessage_byte = 0
+
+                    #DEBUG
+                    # if(len(self.recvmessage)>10):
+                    #     self.recmessage_byte = 0
+                    #     self.recvstate = 3
+
+        elif(self.recvstate==3):
+            #has a message, - wait until this is handled
+            pass
+        else:
+            #invalid state
+            self.clearrecvqueue()
+
+        return
+
+    def has_message(self):
+        ret = False
+
+        if(self.recvstate==3):
+            ret = True
+
+        return ret
+
+    def recv_message(self):
+
+        message = None
+        if(self.has_message()):
+            message = self.recvmessage
+            self.clearrecvqueue()
+
+        return message
+    
+    def send_message(self,message):
+
+        ret = False
+
+        if(type(message) is type(str)):
+            message = message.decode("utf-8")
+        if(type(message) is type(bytes)):
+            message = np.frombuffer(message,dtype=np.uint8)
+
+        if(self.sendstate==0):
+            ret = True
+            self.sendmessage = message
+            self.sendstate = 1
+            self.sendmessage_byte = 0
+            self.sendbitpointer = 0
+            self.sendbytepointer = 0
+        
+        return ret
+

raspberry_pi/terminalprogram.py

@@ -0,0 +1,35 @@
+#!/usr/bin/python
+
+import os,sys,math
+import numpy as np
+from amsswcomm import *
+import time
+
+
+## Setup
+GPIO.setmode(GPIO.BOARD);
+    #other mode is GPIO.BCM - pin numberings are different?
+
+com = amsswcomm()
+com.comminit(1,3,7,5,4)
+
+
+
+
+while(True):
+
+    msg = input("Cmd: ")
+    msgb = msg.encode(encoding="utf-8")
+    msgb = np.frombuffer(msgb, dtype=np.uint8)
+    
+
+    t0 = time.time()
+    t = time.time()
+    com.send_message(msgb)
+    while(com.has_message()==False and (t<t0+1)):
+        com.update_step()
+        t = time.time()
+
+    
+    reply = com.recv_message()
+    print("reply: {}".format(reply))