class Serial(Sensor):
# Interval in seconds
interval = 0.1
sensor1 = 0
sensor2 = 0
button = False
voltage = 0
voltageCounter = 0
def __init__(self, logger, device):
super(Serial, self).__init__(logger)
#Logger for voltage sensor
self.voltagelogger = SensorLogger('Voltage',logger)
#Set serial with baudrate 9600 and a timeout of 3 seconds
self.ser = serial.Serial(device, baudrate=9600, timeout=3.0)
#Flushes the input. If we don't flush the input we will recieve old input.
self.ser.flushInput()
#Semaphores
self.mutex1 = threading.Semaphore(1)
self.mutex2 = threading.Semaphore(1)
self.mutexVoltage = threading.Semaphore(1)
self.mutexButton = threading.Semaphore(1)
def run(self):
while self.alive:
#Gets the sensor values
self.getValues()
#Sleep
time.sleep(self.interval)
def getValues(self):
#Readline from serial
responses = self.ser.readline()
responses = responses.decode('ascii')
#Remove characters that we don't need
responses = responses.replace("\r\n","")
responses = responses.replace("\x00","")
responses = responses.replace("n'","")
responses = responses.replace("'","")
#split the line
responses = responses.split(',')
#loop through the responses
for response in responses:
#Checks if we need the response
if len(response) > 2:
#Convert to int
response = int(response)
#Voltage
if(response < 2000):
voltage = float(response) / float(100)
self.setVoltage(voltage)
#First glove sensor
if(response >= 2000 and response < 2500):
sensor1 = response - 2000
self.setSensor1(sensor1)
#Second glove sensor
elif(response >= 2500 and response < 3000):
sensor2 = response - 2500
self.setSensor2(sensor2)
#Light sensor off
elif(response == 3001):
self.setButton(False)
#Light sensor on
elif(response == 3002):
self.setButton(True)
def stop(self):
#Stop loop
self.alive = False
def start(self):
#Start loop
self.thread.start()
def getSensor1(self):
#Mutex
self.mutex1.acquire()
value = self.sensor1
self.mutex1.release()
return value
def setSensor1(self, value):
#Mutex
self.mutex1.acquire()
self.sensor1 = value
self.mutex1.release()
def getSensor2(self):
#Mutex
self.mutex2.acquire()
value = self.sensor2
self.mutex2.release()
return value
def setSensor2(self, value):
#Mutex
self.mutex2.acquire()
self.sensor2 = value
self.mutex2.release()
def getButton(self):
#Mutex
self.mutexButton.acquire()
value = self.button
self.mutexButton.release()
return value
def setButton(self, value):
#Mutex
self.mutexButton.acquire()
self.button = value
self.mutexButton.release()
def getVoltage(self):
#Mutex
self.mutexVoltage.acquire()
value = self.voltage
self.mutexVoltage.release()
return value
def setVoltage(self, value):
#Mutex
self.mutexVoltage.acquire()
self.voltage = value
#Log every ten times
if self.voltageCounter == 0 or self.voltageCounter == 10:
self.voltageCounter = 0
self.voltagelogger.log_waarde("{0:.2f}".format(self.voltage))
if self.voltageCounter <=9.2 and self.voltageCounter != 0 :
import os
os.system("sudo poweroff")
self.mutexVoltage.release()
class MPU6050(Sensor):
# Interval in seconds
interval = 1
# Default value
current_value = {'yaw': 0, 'pitch': 0, 'roll': 0}
def __init__(self, logger):
#initialize
super(MPU6050, self).__init__(logger)
self.sensorlogger = SensorLogger('MPU6050',logger)
self.mutex = threading.Semaphore(1)
self.mpu = MPU6050BASE()
self.mpu.dmpInitialize()
self.mpu.setDMPEnabled(True)
# get expected DMP packet size for later comparison
self.packetSize = self.mpu.dmpGetFIFOPacketSize()
#get Values
def run(self):
while self.alive:
self.getValues()
time.sleep(self.interval)
def getValues(self):
# Get INT_STATUS byte
mpuIntStatus = self.mpu.getIntStatus()
if mpuIntStatus >= 2: # check for DMP data ready interrupt (this should happen frequently)
# get current FIFO count
fifoCount = self.mpu.getFIFOCount()
# check for overflow (this should never happen unless our code is too inefficient)
if fifoCount == 1024:
# reset so we can continue cleanly
self.mpu.resetFIFO()
# print('FIFO overflow!')
# wait for correct available data length, should be a VERY short wait
fifoCount = self.mpu.getFIFOCount()
while fifoCount < self.packetSize:
fifoCount = self.mpu.getFIFOCount()
result = self.mpu.getFIFOBytes(self.packetSize)
q = self.mpu.dmpGetQuaternion(result)
g = self.mpu.dmpGetGravity(q)
ypr = self.mpu.dmpGetYawPitchRoll(q, g)
#save sensordata
sensorData = {'yaw': ypr['yaw'] * 180 / math.pi, 'pitch': ypr['pitch'] * 180 / math.pi, 'roll': ypr['roll'] * 180 / math.pi}
self.setValue(sensorData)
fifoCount -= self.packetSize
#log sensor
self.sensorlogger.log_waarde("y:{0:.3f}, p:{1:.3f}, r:{2:.3f}".format(sensorData['yaw'], sensorData['pitch'], sensorData['roll']))
#stop thread
def stop(self):
self.alive = False
#start thread
def start(self):
self.thread.start()
#get yaw, pith, roll
def getValue(self):
self.mutex.acquire()
value = self.current_value
self.mutex.release()
return value
#set sensorData
def setValue(self, value):
self.mutex.acquire()
self.current_value = value
self.mutex.release()
