def main():
shared.init()
receiver_ev = Event()
receiver_ev.set()
receiver_thread = SerialReceiver(receiver_ev)
heartbeat_ev = Event()
heartbeat_ev.set()
heartbeat_thread = Heartbeat(heartbeat_ev)
time.sleep(2)
START = '1'
shared.comm.send(START)
rcv=shared.comm.receive()
print(rcv)
with shared.camera:
try:
receiver_thread.start()
heartbeat_thread.start()
server = StreamingServer(shared.address, StreamingHandler)
print('Server started on port ' + str(shared.address[1]))
server.serve_forever()
except Exception as err:
print(err)
finally:
heartbeat_ev.clear()
heartbeat_thread.join()
END = '9'
shared.comm.send(END)
receiver_ev.clear()
receiver_thread.join()
def server(listenPort, serverName="__NO_NAME_GIVEN__"):
listenSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sh.init() # call only once
listenSocket.bind(('', listenPort))
listenSocket.listen(LISTEN_QUEUE_LIMIT)
# register server
if serverName == "__NO_NAME_GIVEN__":
serverName = generate_serverID()
# log server to psql database
if cm.check_server_exists(serverName):
cm.insert_server_metadata(listenSocket, serverName)
else:
cm.insert_server(serverName)
cm.insert_server_metadata(listenSocket, serverName)
channels__newuserevents = {} # for notifying of new users
while True:
sock_msgs = []
currSock, currAddr = listenSocket.accept()
print ("got a connection")
client = register_session(currSock, sock_msgs)
channel = get_channel_from_client(currSock, sock_msgs)
client.set_channel(channel)
print (client)
with sh.channel_newusersLock:
if channel in sh.channel_newusers:
sh.channel_newusers[channel].append((client, sock_msgs))
else:
sh.channel_newusers[channel] = [(client, sock_msgs)]
if channel in channels__newuserevents:
channels__newuserevents[channel].set()
continue
channels__newuserevents[channel] = threading.Event()
servletThread = srv.Servlet(channel,
channels__newuserevents[channel],
serverName)
servletThread.setDaemon(True)
servletThread.start()
channels__newuserevents[channel].set()
except Exception as e:
if e == KeyboardInterrupt:
print ("KeyboardInterrupt: exiting now")
else:
print (e)
traceback.print_exc()
finally:
this_thread = threading.currentThread()
sh.killself_event.set()
for thread in threading.enumerate():
if thread != this_thread:
thread.join()
if listenSocket:
listenSocket.close()
def generate_app(config_file: Optional[str] = None) -> Flask:
"""Generate app"""
if config_file is None:
try:
config_file = os.environ["BOBCAT_INVOICE_CONFIG"]
except KeyError:
config_file = DEFAULT_CONFIG
shared.init(config_file)
return app_factory()
def main():
file = open('../data/db.csv', 'rb')
reader = csv.reader(file)
ser = shared.init()
data = []
label = []
label_map = []
i = 0
for row in reader:
data.append(row[:-1])
label.append(i)
label_map.append(row[-1])
i = i + 1
clf = svm.SVC(kernel = 'linear')
clf.fit(data, label)
#ser.flushInput()
while 1:
# read input from serial
list = shared.read(ser)
#print list
print label_map[int(clf.predict(list))]
file.close()
def main():
file = open('../data/db.csv', 'rb')
reader = csv.reader(file)
ser = shared.init()
data = []
label = []
label_map = []
i = 0
for row in reader:
data.append(row[:-1])
label.append(i)
label_map.append(row[-1])
i = i + 1
clf = svm.SVC(kernel='linear')
clf.fit(data, label)
#ser.flushInput()
print "i'm ready!"
while 1:
# read input from serial
list = shared.read(ser)
if list[0] > 0:
#print list
word = label_map[int(clf.predict(list[1]))]
subprocess.call('espeak ' + '"' + word + '"' +
' -s 140 --stdout | aplay',
shell=True)
print word
file.close()
def main():
# open db file and set up writer
file = open('../data/db.csv', 'a')
writer = csv.writer(file)
# intialize serial read
ser = shared.init()
# flush input initially
#ser.flushInput()
print "Reading from input..."
# read input from serial
list = shared.read(ser)[1]
print list
# read in label for training data and append to list
label = raw_input('Enter a label: ')
list.append(label)
print "Adding new training data to database..."
# write list into csv file
writer.writerow(list)
file.close()
def main():
file = open('../data/db.csv', 'rb')
reader = csv.reader(file)
ser = shared.init()
data = []
label = []
label_map = []
i = 0
for row in reader:
data.append(row[:-1])
label.append(i)
label_map.append(row[-1])
i = i + 1
clf = svm.SVC(kernel = 'linear')
clf.fit(data, label)
#ser.flushInput()
print "i'm ready!"
while 1:
# read input from serial
list = shared.read(ser)
if list[0] > 0:
#print list
word = label_map[int(clf.predict(list[1]))]
subprocess.call('espeak '+'"'+word+'"'+' -s 140 --stdout | aplay', shell=True)
print word
file.close()
def main():
# open db file and set up writer
file = open('../data/db.csv', 'a')
writer = csv.writer(file)
# intialize serial read
ser = shared.init()
# flush input initially
#ser.flushInput()
print "Reading from input..."
# read input from serial
list = shared.read(ser)
print list
# read in label for training data and append to list
label = raw_input('Enter a label: ')
list.append(label)
print "Adding new training data to database..."
# write list into csv file
writer.writerow(list)
file.close()
def main():
print "Welcome to Dukesound, the best sign to spoken language device ever created"
print "##########################################################################"
print "__---------------------------------------_---|-------------\--------------"
print "|-\-|---|-|-/-|==--==--|==|-|---|-|\--|-|-\--|---------\----\-------------"
print "|-|-\---/-|=--|==--|_--|--|-\---/-|-\-|-|-|--|------|---|----|------------"
print "|_/--\_/--|-\-|==---_|-|==|--\_/--|--\|-|_/-/=\--------/----/-------------"
print "--------------------------------------------\=/------------/--------------"
print "##########################################################################"
# open db file and set up writer
file = open('../data/db.csv', 'a')
writer = csv.writer(file)
# intialize serial read
ser = shared.init()
done = False
while not done:
# flush input initially
#ser.flushInput()
print "Reading from input..."
# read input from serial
list = shared.read(ser)[1]
print list
# read in label for training data and append to list
label = raw_input('Enter a label: ')
list.append(label)
inp = raw_input("Do you want to train another set? y/n: ")
done = not (inp == 'y')
print "Adding new training data to database..."
# write list into csv file
writer.writerow(list)
file.close()
try:
import Tkinter as tk
except ImportError:
import tkinter as tk
try:
import ttk
py3 = False
except ImportError:
import tkinter.ttk as ttk
py3 = True
from gui import GUI
from emotions import EmotionRecogniser
import myLogger
import shared
if __name__ == "__main__":
print('Starting...')
shared.init()
shared.logger = myLogger.Logger()
gui = GUI()
emrec = EmotionRecogniser()
import time
import RPi.GPIO as GPIO
from classes.piezo_player import PiezoPlayer # For controlling piezo
import globals as g
import shared
g.init() # Initialize global constants
shared.init() # Initialize shared variables
class PlayPauseButton:
def __init__(self, BUTTON):
self._running = True
self.BUTTON = BUTTON
GPIO.setup(self.BUTTON, GPIO.IN)
def terminate(self):
self._running = False
def run(self):
while self._running:
print("=========Interrupt Start==========")
GPIO.wait_for_edge(self.BUTTON, GPIO.RISING)
shared.pause = not shared.pause
print("Pause Button pressed | shared.pause = ", shared.pause)
time.sleep(0.5)
class TurnOffButton:
def __init__(self, BUTTON, piezo):
self._running = True
import serial import shared ser = shared.init() while 1: print shared.read(ser)
import serial import shared ser = shared.init() while 1: list = shared.read(ser) print list[0], list[1]
#!usr/bin/env python
import numpy as np
import numpy.linalg as linalg
import sys, time, random
from optparse import OptionParser
import shared as SH
import auxilary as aux
import graph as graph
import plot as myplt
import complement # Actually use this
import roadmap as roadmap
###This code assumes that the input format is correct
debug = False
SH.init() # initialize the global variables
(options, args) = OptionParser().parse_args()
originlist, ellipselist = complement.processinput([], [], args[0]) # processinput(originlist, ellipselist):
if debug == True:
print "originlist = ", originlist
print "ellipselist = ", ellipselist
print "num = ", SH.num
print "dim = ", SH.dim
print "adjmatrix = ", SH.adjmatrix
print "primA = ", SH.primA
roadmap.CreateRoad(
0, [], [0 for x in range(SH.dim)], originlist, ellipselist, False
) # CreateRoad(traversalAxis, CriticalPoints, parentvector ,originlist, ellipselist )
from dotenv import load_dotenv, find_dotenv import shared as s # Load .env load_dotenv(find_dotenv()) # Load global variables s.init() from recognition_engine.recognition import FaceRecognition thread = FaceRecognition() thread.start() # Init from DB from management.faceloader.loader import load_faces load_faces() # Launch Flask from management import app app.run(debug=False)