def enviar(comando,ser): #función enviar , recibe el caracter a enviar (comando) y el
objeto serial (ser) que puede hacer referencia tanto al mega como al esp32
ser.write(bytes(comando,'utf-8'))#escribe en el serial el comando
print('enviado',comando)
while (not ser.read().decode('utf-8')=='F'): #mientras no reciba una 'F' no sale de este bucle
print('Ejecutando accion')
print('F')
def run(self):
global voluto
integrale = 0
derivata = 0
errore = 10
while ((1) and not self.event.is_set()):
errore = (voluto) - dato
derivata = errore - derivata
integrale = integrale + errore
if (integrale < -windup):
integrale = -windup
if (integrale > windup):
integrale = windup
valore = (prop * voluto) - (kp * errore) - (ki * integrale) - (
kd * derivata)
#print(valore)
derivata = errore
if (valore < 0):
valore = 45
if (valore > 255):
valore = 255
valore = valore
valore = int(valore)
#print(valore)
serial(valore)
time.sleep(0.01)
def main(e):
if e.display:
# Now we can connect a client to the server
client(e)
elif e.stream:
# Now we can run the server
server(e)
elif e.serial:
serial(e)
else:
writer(e, force=True)
def main(e):
if e.display:
# Now we can connect a client to the server
client(e)
elif e.stream:
# Now we can run the server
server(e)
elif e.serial:
serial(e)
else:
writer(e, force=True)
def _queueJobsInQueue(self, queue, quota_names, job_infos, serialize=True,
begin_by=None, begin_after=None):
"""Queue multiple jobs in the specified queue."""
scheduled = [self.wrapJob(job_info) for job_info in job_infos]
if serialize:
job = serial(*scheduled)
else:
job = parallel(*scheduled)
return self.__queueJobInQueue(begin_by, begin_after,
queue, quota_names, job)
def timedRead(self, timeout):
sera = serial()
start_time = time.time()
while (time.time() - start_time < timeout):
c = sera.read()
if c >= 0:
self.result = c
else:
self.result = -1
return self.result
def update(self):
if self.lectura1 == True:
i = 0
for i in range(10):
ch1, ch2, chd1, chd2 = serial()
self.pch1.extend(ch1)
self.pch2.extend(ch2)
self.pchd1.extend(chd1)
self.pchd2.extend(chd2)
self.lectura1=False
else:
del self.pch1[:200]
del self.pch2[:200]
del self.pchd1[:200]
del self.pchd2[:200]
ch1, ch2, chd1, chd2 = serial()
self.pch1.extend(ch1)
self.pch2.extend(ch2)
self.pchd1.extend(chd1)
self.pchd2.extend(chd2)
zero = np.zeros(2000)
if self.c1 == True:
self.trace("CH1",self.t,self.pch1,'y')
else:
self.trace("CH1",self.t,zero,'k')
if self.c2 == True:
self.trace("CH2",self.t,self.pch2,'r')
else:
self.trace("CH2",self.t,zero,'k')
if self.cd1 == True:
self.trace("CHD1",self.t,self.pchd1,'y')
else:
self.trace("CHD1",self.t,zero,'k')
if self.cd2 == True:
self.trace("CHD2",self.t,self.pchd2,'r')
else:
self.trace("CHD2",self.t,zero,'k')
def run(self):
global voluto
selettore=0
while((1) and not self.event.is_set()):
selettore+=1
selettore=selettore%2
if(selettore==0):
if(ASX.voluto==0):
serial(0,0)
ASX.integrale=0
else:
ASX.errore=ASX.voluto-ASX.enc
ASX.derivata=ASX.errore-ASX.derivata
ASX.integrale=ASX.integrale+ASX.errore
if(ASX.integrale<-windup):
ASX.integrale=0
if(ASX.integrale>windup):
ASX.integrale=0
ASX.valore=(prop*ASX.voluto)-(kp*ASX.errore)-(ki*ASX.integrale)-(kd*ASX.derivata)
ASX.derivata=ASX.errore
if(ASX.valore<0):
ASX.valore=0
if(ASX.valore>255):
ASX.valore=255
ASX.valore=int(ASX.valore)
serial(ASX.valore,0)
time.sleep(0.01)
if(selettore==1):
if(ADX.voluto==0):
serial(0,1)
ADX.integrale=0
else:
ADX.errore=ADX.voluto-ADX.enc
ADX.derivata=ADX.errore-ADX.derivata
ADX.integrale=ADX.integrale+ADX.errore
if(ADX.integrale<-windup):
ADX.integrale=0
if(ADX.integrale>windup):
ADX.integrale=0
ADX.valore=(prop*ADX.voluto)-(kp*ADX.errore)-(ki*ADX.integrale)-(kd*ADX.derivata)
ADX.derivata=ADX.errore
if(ADX.valore<0):
ADX.valore=0
if(ADX.valore>255):
ADX.valore=255
ADX.valore=int(ADX.valore)
serial(ADX.valore,1)
time.sleep(0.01)
def _queueJobsInQueue(self, queue, quota_names, job_infos, serialize=True):
"""Queue multiple jobs in the specified queue."""
portal = getUtility(ISiteRoot)
portal_path = portal.getPhysicalPath()
uf_path, user_id = _getAuthenticatedUser()
scheduled = []
for (func, context, args, kwargs) in job_infos:
context_path = context.getPhysicalPath()
job = Job(_executeAsUser, context_path, portal_path, uf_path, user_id,
func, *args, **kwargs)
scheduled.append(job)
if serialize:
job = serial(*scheduled)
else:
job = parallel(*scheduled)
if quota_names:
job.quota_names = quota_names
job = queue.put(job)
job.addCallbacks(success=job_success_callback,
failure=job_failure_callback)
return job
def _queueJobsInQueue(self, queue, quota_names, job_infos, serialize=True):
portal = getUtility(ISiteRoot)
portal_path = portal.getPhysicalPath()
pm = getToolByName(portal, 'portal_membership')
user = pm.getAuthenticatedMember()
user_id = user.getId()
uf_path = user.aq_parent.aq_parent.getPhysicalPath()
scheduled = []
for (func, context, args, kwargs) in job_infos:
context_path = context.getPhysicalPath()
job = Job(_executeAsUser, portal_path, context_path, user_id,
uf_path, func, *args, **kwargs)
scheduled.append(job)
if serialize:
job = serial(*scheduled)
else:
job = parallel(*scheduled)
if quota_names:
job.quota_names = quota_names
job = queue.put(job)
job.addCallbacks(success=job_success_callback,
failure=job_failure_callback)
return job
class asciirw:
_platform = 'WIN'
ser = serial()
def __init__(self):
pass
def __init__(self, platform, portName, baudrate, parity, stopbit,
databits):
config = ConfigParser.ConfigParser()
config.read('./App_V100/app.config')
self._platform = platform
log.debug(self._platform + " Selected")
self.InitializeSerialPort()
def InitializeSerialPort(self):
self.ser = serial.Serial(self.portName)
self.ser.baudrate = self.baudrate
self.ser.parity = self.parity
self.ser.stopbits = self.stopbit
self.ser.bytesize = self.databits
import serial
port = serial('/dev/cu.wchusbserial14310', basestring=115200, timeout=3.0)
port.write('2')
spd1 = '1SP' #y-axis
spd2 = '2SP' #x-axis
a = '1la-' #Position header for Y-axis
c = '2la' #Position header for X-axis
Yspd = spd1+str(spdy)
Xspd = spd2+str(spdx)
############################################################
########### Create Serial Object ############
############################################################
# CREATE SERIAL OBJECT
s = serial('COM8') #create serial object
s.InputBufferSize = 8388608
fopen(s) #connect to serial object
############################################################
############# Initialisation ##############
############################################################
fprintf(s,'JMP2') #Homing Sequence/Initialise
pause(5)
fprintf(s,Xspd) #set X-axis speed to user's choice
fprintf(s,Yspd) #set Y-axis speed to user's choice
############################################################
############# Counters ##############
if name in self.traces: self.traces[name].setData(dataset_x,dataset_y) else: self.traces[name] = self.Canvas.plot(pen=color) #self.traces[name] = self.Canvas.plot(pen=color,symbolBrush=color,symbolPen=color) #Observar puntos de muestreo <<<<<<< HEAD def update(self): #Actualizar datos if self.lectura1 == True: #Primera lectura debe leer 10 veces del serial ======= def update(self): if self.lectura1 == True: #Bucle para la lectura de los datos >>>>>>> af475479ea6477ac383016e753278b9a4c80517d i = 0 for i in range(10): ch1, ch2, chd1, chd2 = serial() self.pch1.extend(ch1) self.pch2.extend(ch2) self.pchd1.extend(chd1) self.pchd2.extend(chd2) self.lectura1=False else: #Siguientes lecturas: eliminar los 200 datos más viejos y leer nuevos del self.pch1[:200] del self.pch2[:200] del self.pchd1[:200] del self.pchd2[:200] ch1, ch2, chd1, chd2 = serial() self.pch1.extend(ch1) self.pch2.extend(ch2) self.pchd1.extend(chd1) self.pchd2.extend(chd2)
import matplotlib.pyplot as plt
from math import pi
import serial
ser = serial('/dev/ttyUSB0', 115200)
f = open('dump.csv', 'r')
lines = f.readlines()
# remove picocom output,
# strip windows line endings,
# split by comma,
# remove failures,
# and turn into numbers
# sort
# split into to lists
lines = lines[2:-25]
lines = [e[:-2] for e in lines]
lines = [e.split(',') for e in lines]
lines = [e for e in lines if e[1]!='failure']
lines = [[int(e[0]), int(e[1])] for e in lines]
lines.sort()
t = [e[0] for e in lines]
r = [e[1] for e in lines]
# reduce it to one value for each theta
data = []
i = 0
while i < len(r):
rsum = 0
def run(self):
global voluto, direzione
sel = 0
NPD = 2
NAD = 0
NPS = 3
NAS = 1
contatore = 0
while ((1) and not self.event.is_set()):
if (sel == 0):
if (AS.voluto == 0):
serial(0, 2, AS.direzione)
integrale = 0
else:
AS.errore = AS.voluto - AS.enc
AS.derivata = AS.errore - AS.derivata
AS.integrale = AS.integrale + AS.errore
if (AS.integrale < -windup):
AS.integrale = -windup
if (AS.integrale > windup):
AS.integrale = windup
AS.valore = (prop * voluto) - (kp * AS.errore) - (
ki * AS.integrale) - (kd * AS.derivata)
AS.derivata = AS.errore
if (AS.valore < 0):
AS.valore = 0
if (AS.valore > 255):
AS.valore = 255
AS.valore = int(AS.valore)
serial(AS.valore, NAS, AS.direzione)
#print(AS.valore)
if (sel == 1):
if (AD.voluto == 0):
serial(0, 3, AS.direzione)
integrale = 0
else:
AD.errore = AD.voluto - AD.enc
AD.derivata = AD.errore - AD.derivata
AD.integrale = AD.integrale + AD.errore
if (AD.integrale < -windup):
AD.integrale = -windup
if (AD.integrale > windup):
AD.integrale = windup
AD.valore = (prop * voluto) - (kp * AD.errore) - (
ki * AD.integrale) - (kd * AD.derivata)
AD.derivata = AD.errore
if (AD.valore < 0):
AD.valore = 0
if (AD.valore > 255):
AD.valore = 255
AD.valore = int(AD.valore)
serial(AD.valore, NAD, AS.direzione)
if (sel == 2):
if (PS.voluto == 0):
serial(0, 0, AS.direzione)
integrale = 0
else:
PS.errore = PS.voluto - PS.enc
PS.derivata = PS.errore - PS.derivata
PS.integrale = PS.integrale + PS.errore
if (PS.integrale < -windup):
PS.integrale = -windup
if (PS.integrale > windup):
PS.integrale = windup
PS.valore = (prop * voluto) - (kp * PS.errore) - (
ki * PS.integrale) - (kd * PS.derivata)
PS.derivata = PS.errore
if (PS.valore < 0):
PS.valore = 0
if (PS.valore > 255):
PS.valore = 255
PS.valore = int(PS.valore)
serial(PS.valore, NPS, AS.direzione)
#print(PS.valore)
if (sel == 3):
if (PD.voluto == 0):
serial(0, 1, AS.direzione)
integrale = 0
else:
PD.errore = PD.voluto - PD.enc
PD.derivata = PD.errore - PD.derivata
PD.integrale = PD.integrale + PD.errore
if (PD.integrale < -windup):
PD.integrale = -windup
if (PD.integrale > windup):
PD.integrale = windup
PD.valore = (prop * voluto) - (kp * PD.errore) - (
ki * PD.integrale) - (kd * PD.derivata)
PD.derivata = PD.errore
if (PD.valore < 0):
PD.valore = 0
if (PD.valore > 255):
PD.valore = 255
PD.valore = int(PD.valore)
serial(PD.valore, NPD, AS.direzione)
#print(PD.valore)
contatore += 1
if (((contatore % 50) == 0) and (AD.voluto != 0)):
head, roll, pitch = bno.read_euler()
if ((pitch > 5) or (pitch < -5)):
setta(2700, dati.direzione)
else:
setta(1600, dati.direzione)
time.sleep(0.001)
sel += 1
sel = sel % 4
import matplotlib.pyplot as plt
from math import pi
import serial
ser = serial('/dev/ttyUSB0', 115200)
f = open('dump.csv', 'r')
lines = f.readlines()
# remove picocom output,
# strip windows line endings,
# split by comma,
# remove failures,
# and turn into numbers
# sort
# split into to lists
lines = lines[2:-25]
lines = [e[:-2] for e in lines]
lines = [e.split(',') for e in lines]
lines = [e for e in lines if e[1] != 'failure']
lines = [[int(e[0]), int(e[1])] for e in lines]
lines.sort()
t = [e[0] for e in lines]
r = [e[1] for e in lines]
# reduce it to one value for each theta
data = []
i = 0
while i < len(r):
rsum = 0
if CSV: print x, ",", y, ",", maxRadius, ",", circles.total, ",", time.time()
if len(last_xs) == 5: del last_xs[0] # Remove first item
last_xs.append(x)
if len(last_ys) == 5: del last_ys[0] # Remove first item
last_ys.append(y)
if abs(average(last_xs)-x) > 40: # Then x is probably a bad measurement
x = average(last_xs)
if DEBUG: print "ball fixed:",x,",",y
if abs(average(last_ys)-y) > 40: # Then y is probably a bad measurement
y = average(last_ys)
if DEBUG: print "ball fixed:",x,",",y
# Communicate commands or location via serial cable
if x > 320:
# Copter must move right
serial("ROLL","RIGHT")
elif x < 320:
serial("ROLL","LEFT")
if y > 240:
# Copter must move backwards
serial("PITCH","FORWARD")
elif y < 240:
serial("PITCH","BACK")
copter.close()
# Stop taking frames from camera
self.add_event('select_prompt', r'Make an entry \[[a-z]-[a-z],x\/X\]:.*', self._select_prompt)
self.start()
def _select_prompt(self, name, data):
pass
def get_motor_calibration(self, mode='raw'):
"""
:description: Request and retrieve the display data for the motor calibration. This is a blocking call.
:return:
"""
self.execute('d', 'a')
return self._data
dh = DisplayHandler(serial=serial(port='/dev/ttyACM0', baud=115200))
raw_data = dh.get_motor_calibration()
parsed_data = dh.get_motor_calibration(mode='parsed')
if __name__ == '__main__':
def wait():
#global finished_count
global prompt_received
#while finished_count < 2:
while not prompt_received:
print prompt_received
time.sleep(0.001)
def reset():
global finished_count
""" acreroad_1420 Drive software Software designed to drive the 1420 MHz telescope on the roof of the Acre Road observatory. This class interacts with "qp", the telescope drive software by Norman Gray (https://bitbucket.org/nxg/qp) via a serial (USB) interface. The serial interfacing is done through pySerial. Parameters ---------- device : str The name of the unix device which the drive is connected to port : int The port number of the drive simulate : bool A boolean flag to set the drive in simulation mode (the class does not connect to the controller in simulation mode) """ import re, datetime, time import ConfigParser import numpy as np import astropy from astropy.coordinates import SkyCoord, ICRS, EarthLocation, AltAz import astropy.units as u
from mosquitto import
from serial import
from random import
Board = serial ("/dev/cu.usbmodemfd111",9600, timeout=2)
client = mosquitto("Courtney090")
client.connect("10.212.62.136")
client.subscribe("/Lights")
def messageRecieved (broker, obj, msg):
payload = msg.payload.decode()
print("MESSAGE "+ msg.topic + " CONTAINING:" + payload)
if (payload == "ON"):
message= "1"
if (payload == "OFF"):
message= "0"
board.write(message.encode())
client.on_message= messageRecieved
import serial
ser = serial('/dev/ttyUSB0', 9600)
# to read a single byte
data = ser.read()
# Neo4j and Cypher using Py2Neo.
results = News.objects.todays_news()
for r in results:
article = graph.merge_one("NewsArticle", "news_id", r)
if 'LOCATION' in results[r].keys():
for loc in results[r]['LOCATION']:
loc = graph.merge_one("Location", "name", loc)
try:
rel = graph.create_unique(Relationship(article, "about_place", loc))
except Exceptione:
print(e)
# Autocomplete on News Title
def get_auticomplete(text):
query = """
start n = node(*) where n.name =~ '(?i)%s.*' return n.name,labels(n) limit 10;
"""
query = query % (text)
obj = []
for res in graph.cypher.executed(query):
obj.append({'name':res[0],'entity_type':res[1]})
return res
#Templets in python
from string import Template
import sys
import serial
import threading
ser = serial('/dev/ttyUSB0', baudrate=9600, timeout=1)
while True:
input_string = ser.readline().decode()
radar = int(input_string)
input_string = ser.readline().decode()
IR_data = int(input_string)
print(radar)
print(IR_data)
print()
print( 'Logging to /tmp/'+myName+'.log')
rh = logging.handlers.RotatingFileHandler( '/tmp/'+myName+'.log',
maxBytes=10000000, backupCount=1 )
rh.setFormatter( fmt )
log.addHandler( rh )
# create mqtt client
mqttC = mqtt.Client(client_id="jee2mqtt")
mqttC.isConnected = False
mqttC.on_connect = on_connect
mqttC.on_message = on_mqtt
mqttC.on_subscribe = on_subscribe
mqttC.on_log = on_log
mqttC.loop_start() # create rx/tx thread in background
try:
mqttC.connect( args.mqtt_server, args.mqtt_port, 10)
except:
log.error("Failed to connect to mqtt server. Retry in 2 secs ....")
while not mqttC.isConnected:
time.sleep(1) # wait till mqtt server arrives.
try:
# start serial coroutine
s = serial( args.serial_port, args.serial_baudrate )
asyncio.run( s.main() )
except KeyboardInterrupt:
time.sleep(2)
mqttC.loop_stop()
print("Terminated")
def run(self):
global voluto, direzione
sel = 0
NPD = 2
NAD = 0
NPS = 3
NAS = 1
while ((1) and not self.event.is_set()):
if (sel == 0):
if (AS.voluto == 0):
serial(0, 2, AS.direzione)
integrale = 0
else:
AS.errore = AS.voluto - AS.enc
AS.derivata = AS.errore - AS.derivata
AS.integrale = AS.integrale + AS.errore
if (AS.integrale < -windup):
AS.integrale = -windup
if (AS.integrale > windup):
AS.integrale = windup
AS.valore = (prop * voluto) - (kp * AS.errore) - (
ki * AS.integrale) - (kd * AS.derivata)
AS.derivata = AS.errore
if (AS.valore < 0):
AS.valore = 0
if (AS.valore > 255):
AS.valore = 255
AS.valore = int(AS.valore)
serial(AS.valore, NAS, AS.direzione)
#print(AS.valore)
if (sel == 1):
if (AD.voluto == 0):
serial(0, 3, AS.direzione)
integrale = 0
else:
AD.errore = AD.voluto - AD.enc
AD.derivata = AD.errore - AD.derivata
AD.integrale = AD.integrale + AD.errore
if (AD.integrale < -windup):
AD.integrale = -windup
if (AD.integrale > windup):
AD.integrale = windup
AD.valore = (prop * voluto) - (kp * AD.errore) - (
ki * AD.integrale) - (kd * AD.derivata)
AD.derivata = AD.errore
if (AD.valore < 0):
AD.valore = 0
if (AD.valore > 255):
AD.valore = 255
AD.valore = int(AD.valore)
serial(AD.valore, NAD, AS.direzione)
if (sel == 2):
if (PS.voluto == 0):
serial(0, 0, AS.direzione)
integrale = 0
else:
PS.errore = PS.voluto - PS.enc
PS.derivata = PS.errore - PS.derivata
PS.integrale = PS.integrale + PS.errore
if (PS.integrale < -windup):
PS.integrale = -windup
if (PS.integrale > windup):
PS.integrale = windup
PS.valore = (prop * voluto) - (kp * PS.errore) - (
ki * PS.integrale) - (kd * PS.derivata)
PS.derivata = PS.errore
if (PS.valore < 0):
PS.valore = 0
if (PS.valore > 255):
PS.valore = 255
PS.valore = int(PS.valore)
serial(PS.valore, NPS, AS.direzione)
#print(PS.valore)
if (sel == 3):
if (PD.voluto == 0):
serial(0, 1, AS.direzione)
integrale = 0
else:
PD.errore = PD.voluto - PD.enc
PD.derivata = PD.errore - PD.derivata
PD.integrale = PD.integrale + PD.errore
if (PD.integrale < -windup):
PD.integrale = -windup
if (PD.integrale > windup):
PD.integrale = windup
PD.valore = (prop * voluto) - (kp * PD.errore) - (
ki * PD.integrale) - (kd * PD.derivata)
PD.derivata = PD.errore
if (PD.valore < 0):
PD.valore = 0
if (PD.valore > 255):
PD.valore = 255
PD.valore = int(PD.valore)
serial(PD.valore, NPD, AS.direzione)
#print(PD.valore)
time.sleep(0.001)
sel += 1
sel = sel % 4
def update(self): #Actualizar datos
if self.cont == 6:
self.cont = 0
if self.lectura1 == True: #Primera lectura debe leer 10 veces del serial
i = 0
for i in range(20):
ch1, chd1, chd2, rms = serial()
self.pch1.extend(ch1)
self.lectura1=False
else: #Siguientes lecturas: eliminar los 200 datos más viejos y leer nuevos
del self.pch1[:100]
ch1, chd1, chd2, rms = serial()
self.pch1.extend(ch1)
zero = np.zeros(2000)
if not chd1:
self.trace("CH1",self.t,self.pch1,'b')
#Conversion
RMS = ((((rms/100))**(0.5))/0.0063
#RMS = rms/(100*31*0.0063)
if self.Maximo < RMS:
self.Maximo = RMS
if self.cont == 0:
if chd2:
display = self.Maximo
self.Display.display(display)
if not chd1:
self.Maximo = 0
print(display)
else:
display = 20*math.log10(self.Maximo) #REVISAR LA CONVERSION
self.Display.display(display)
if not chd1:
self.Maximo = 0
print(display)
self.cont = self.cont + 1
def animation(self): #Timer de actualizacion
timer = QtCore.QTimer()
timer.timeout.connect(self.update)
timer.start(45) #De usarse symbolBrush y symbolPen cambiar el tiempo a 0.5 o menos, ya que tarda mucho en graficar y el buffer se llena, sino dejarlo en 90
self.start()
#FUNCION PERILLA DE VOLTAJE
def changebasevolt(self):
value = self.PerillaAmp.value()
if value == 1:
axisY = [(0.9,'0.9'),(1.2,'1.2'),(1.8,'1.8'),(2.1,'2.1')]
self.CaxisY.setTicks([axisY])
self.Canvas.setYRange(0.9, 2.1, 0)
elif value == 2:
axisY = [(0,'0'),(1,'1'),(2,'2'),(3,'3')]
self.CaxisY.setTicks([axisY])
self.Canvas.setYRange(0, 3, 0)
elif value == 3:
axisY = [(0,'0'),(3*1,'3'),(3*2,'6'),(3*3,'9')]
self.CaxisY.setTicks([axisY])
self.Canvas.setYRange(0, 3*3, 0)
#FUNCION PERILLA DE TIEMPO
def changebasetime(self):
value = self.PerillaTiempo.value()
if value == 1:
self.Canvas.setXRange(0, 1, 0)
elif value == 2:
n = 1/10
self.Canvas.setXRange(1-n, 1, 0)
elif value == 3:
n = 1/100
self.Canvas.setXRange(0.998-n, 0.998, 0)
elif value == 4:
n = 1/1000
self.Canvas.setXRange(0.9994-n, 0.9994, 0)
if __name__ == '__main__':
app = QtGui.QApplication(sys.argv)
window = MyApp()
window.show()
window.animation()
sys.exit(app.exec_())
import serial
#import RPi.GPIO as GPIO
import time
from guizero import App, Combo, Text, CheckBox, ButtonGroup, PushButton, info, TextBox
ser = serial("/dev/ttyACM0",
9600) #change ACM number as found from ls /dev/tty/ACM*
ser.baudrate = 9600
##def do_booking():
## info("Booking", "Thank you for booking")
## print(film_choice.value)
## print(vip_seat.value)
## print(row_choice.value)
serr = ser.readline()
def LeftRoom():
info("Lights on", "Keep Exploring")
if light_choiceL.value == "On":
ser.write(b'9')
if light_choiceL.value == "Off":
ser.write(b'X')
def RightRoom():
info("Lights on", "Keep Exploring")
if light_choiceR.value == "On":
ser.write(b'8')
if light_choiceR.value == "Off":
def run(self):
global voluto,direzione
sel=0
NPD=2
NAD=0
NPS=3
NAS=1
cont=0
errore_h=0
kp_h=10
kd_h=10
derivata_h=0
ki_h=0
correzione=0
integrale_h=0
while((1) and not self.event.is_set()):
if(sel==0):
if(AS.voluto==0):
serial(0,2,AS.direzione)
integrale=0
errore_h=0
correzione=0
integrale_h=0
else:
AS.errore=AS.voluto-AS.enc
AS.derivata=AS.errore-AS.derivata
AS.integrale=AS.integrale+AS.errore
if(AS.integrale<-windup):
AS.integrale=-windup
if(AS.integrale>windup):
AS.integrale=windup
AS.valore=(prop*voluto)-(kp*AS.errore)-(ki*AS.integrale)-(kd*AS.derivata)
AS.derivata=AS.errore
if(AS.valore<0):
AS.valore=0
if(AS.valore>255):
AS.valore=255
AS.valore=int(AS.valore)
serial(AS.valore,NAS,AS.direzione)
#print(AS.valore)
if(sel==1):
if(AD.voluto==0):
serial(0,3,AS.direzione)
integrale=0
else:
AD.errore=AD.voluto-AD.enc
AD.derivata=AD.errore-AD.derivata
AD.integrale=AD.integrale+AD.errore
if(AD.integrale<-windup):
AD.integrale=-windup
if(AD.integrale>windup):
AD.integrale=windup
AD.valore=(prop*voluto)-(kp*AD.errore)-(ki*AD.integrale)-(kd*AD.derivata)
AD.derivata=AD.errore
if(AD.valore<0):
AD.valore=0
if(AD.valore>255):
AD.valore=255
AD.valore=int(AD.valore)
serial(AD.valore,NAD,AS.direzione)
if(sel==2):
if(PS.voluto==0):
serial(0,0,AS.direzione)
integrale=0
else:
PS.errore=PS.voluto-PS.enc
PS.derivata=PS.errore-PS.derivata
PS.integrale=PS.integrale+PS.errore
if(PS.integrale<-windup):
PS.integrale=-windup
if(PS.integrale>windup):
PS.integrale=windup
PS.valore=(prop*voluto)-(kp*PS.errore)-(ki*PS.integrale)-(kd*PS.derivata)
PS.derivata=PS.errore
if(PS.valore<0):
PS.valore=0
if(PS.valore>255):
PS.valore=255
PS.valore=int(PS.valore)
serial(PS.valore,NPS,AS.direzione)
#print(PS.valore)
if(sel==3):
if(PD.voluto==0):
serial(0,1,AS.direzione)
integrale=0
else:
PD.errore=PD.voluto-PD.enc
PD.derivata=PD.errore-PD.derivata
PD.integrale=PD.integrale+PD.errore
if(PD.integrale<-windup):
PD.integrale=-windup
if(PD.integrale>windup):
PD.integrale=windup
PD.valore=(prop*voluto)-(kp*PD.errore)-(ki*PD.integrale)-(kd*PD.derivata)
PD.derivata=PD.errore
if(PD.valore<0):
PD.valore=0
if(PD.valore>255):
PD.valore=255
PD.valore=int(PD.valore)
serial(PD.valore,NPD,AS.direzione)
#print(PD.valore)
cont+=1
if(((cont%50)==0) and (dati.state==True) and (AS.voluto!=0)):
temp, roll, pitch = bno.read_euler()
errore_h=dati.HEADM-temp
#print(correzione)
if(dati.counter!=0):
integrale_h=integrale_h+errore_h
derivata_h=-errore_h+derivata_h
correzione=(errore_h*kp_h)+(integrale_h*ki_h)+(derivata_h*kd_h)
derivata_h=errore_h
#print(correzione)
if(errore_h<0):
#print("verso sinistra")
AS.voluto=dati.voluto
PS.voluto=dati.voluto
AD.voluto=AD.voluto+correzione
PD.voluto=AD.voluto+correzione
else:
#print("verso destra")
AD.voluto=dati.voluto
PD.voluto=dati.voluto
AS.voluto=AS.voluto-correzione
PS.voluto=AS.voluto-correzione
else:
if(errore_h>-90):
integrale_h=integrale_h+errore_h
derivata_h=-errore_h+derivata_h
correzione=(errore_h*kp_h)+(integrale_h*ki_h)+(derivata_h*kd_h)
derivata_h=errore_h
#print("verso sinistra")
AD.voluto=dati.voluto
PD.voluto=dati.voluto
AS.voluto=AS.voluto-correzione
PS.voluto=PS.voluto-correzione
elif(errore_h<-270):
errore_h=errore_h+360
integrale_h=integrale_h+errore_h
derivata_h=-errore_h+derivata_h
correzione=(errore_h*kp_h)+(integrale_h*ki_h)+(derivata_h*kd_h)
derivata_h=errore_h
#print(correzione)
#print("verso destra")
AS.voluto=dati.voluto
PS.voluto=dati.voluto
AD.voluto=AD.voluto+correzione
PD.voluto=PD.voluto+correzione
time.sleep(0.001)
sel+=1
sel=sel%4
