Ejemplo n.º 1
0
def process_logfile_data(filename, doc, logdb, voltsdb):
    data_output_dir = config.log_file_download_path

    out_file_path = (os.path.join(data_output_dir, filename))
    out_file = open(out_file_path, 'wb')
    out_file.write(logdb.get_attachment(doc, filename).read())
    out_file.close()

    devices = sensors()

    with open(out_file_path, "r") as input_file:
        in_csv = csv.DictReader(input_file, delimiter=',')

        for line in in_csv:
            print(line)
            try:
                dt = datetime.datetime.strptime(line['Date'],
                                                "%m/%d/%y %H:%M:%S")

                for k, v in devices.items():
                    if v['sensor'] in line:
                        volts_doc = Volts(sensor_sn=v['sensor-sn'],
                                          gps=v['gps'],
                                          location=v['location'],
                                          logger_sn=v['logger-sn'],
                                          date=dt,
                                          volts=line[v['sensor']])
                        print(volts_doc)
                        volts_doc.store(voltsdb)
            except Exception as e:
                print(e)

    return True
Ejemplo n.º 2
0
Archivo: gui.py Proyecto: spalk/dimeteo
    def __init__(self, *args, **kwargs):
        Tk.__init__(self, *args, **kwargs)

        # get data
        d = db.Gui_Data().get_temp_24h()

        t3 = Toplevel(self,  bg='gray')
        t3.overrideredirect(1)
        t3.geometry('%sx%s' % (X, Y)) # сделать определение разрешения экрана

        self.canvas = Canvas(t3, width = X, height= Y)

        curtime = datetime.datetime.now().strftime('%H:%M:%S')
        self.sensors = sensors.sensors()
        curtemp_out = 'Temp Out: %s' % round(self.sensors.read_temp_DS18B20(), 2)
        curtemp_in = 'Temp In: %s' % round(self.sensors.read_temp_BME280(), 2)

        self.temp = graf(self.canvas, (0,0), (1,1), border = 1, border_color = 'red')
        self.temp.add_graf((20,5,28,25), d, smooth = 1, border = 1, tag = 'graf_temp_out')
        self.temp.add_x_axe(4, dash_shift = -24, x_lables_shift=(0, -11), x_lable_color = 'dark slate gray', x_lable_angle = 90)
        self.temp.add_y_axe(300, dash_shift = -4, y_dash_color = 'SteelBlue2',  y_lables_shift=(-10, 0), y_labels_font=('tahoma', 8))
        self.temp.add_title(curtime, position = (50,10), font = ('tahoma', 9), color = 'green', tag = 'time')
        self.temp.add_title(curtemp_out, position = (265,10), font = ('tahoma', 9), color = 'red', tag = 'cur_temp_out')
        self.temp.add_title(curtemp_in, position = (150,10), font = ('tahoma', 9), color = 'purple', tag = 'cur_temp_in')
        self.canvas.pack()


        self.update_clock()
        self.update_graf()
        self.update_axes()
        self.update_cur_temp()
Ejemplo n.º 3
0
def process_logfile_data(filename, doc, logdb, voltsdb):
    data_output_dir = config.log_file_download_path

    out_file_path = (os.path.join(data_output_dir, filename))
    out_file = open(out_file_path, 'wb')
    out_file.write(logdb.get_attachment(doc, filename).read())
    out_file.close()

    devices = sensors()

    with open(out_file_path, "r") as input_file:
        in_csv = csv.DictReader(input_file, delimiter=',')

        for line in in_csv:
            print(line)
            try:
                dt = datetime.datetime.strptime(line['Date'], "%m/%d/%y %H:%M:%S")

                for k, v in devices.items():
                    if v['sensor'] in line:
                        volts_doc = Volts(sensor_sn=v['sensor-sn'], gps=v['gps'], location=v['location'],
                                          logger_sn=v['logger-sn'], date=dt, volts=line[v['sensor']])
                        print(volts_doc)
                        volts_doc.store(voltsdb)
            except Exception as e:
                print(e)

    return True
Ejemplo n.º 4
0
    def __init__(self, *args, **kwargs):
        Tk.__init__(self, *args, **kwargs)

        # get data
        d = db.Gui_Data().get_temp_24h()

        t3 = Toplevel(self, bg='gray')
        t3.overrideredirect(1)
        t3.geometry('%sx%s' % (X, Y))  # сделать определение разрешения экрана

        self.canvas = Canvas(t3, width=X, height=Y)

        curtime = datetime.datetime.now().strftime('%H:%M:%S')
        self.sensors = sensors.sensors()
        curtemp_out = 'Temp Out: %s' % round(self.sensors.read_temp_DS18B20(),
                                             2)
        curtemp_in = 'Temp In: %s' % round(self.sensors.read_temp_BME280(), 2)

        self.temp = graf(self.canvas, (0, 0), (1, 1),
                         border=1,
                         border_color='red')
        self.temp.add_graf((20, 5, 28, 25),
                           d,
                           smooth=1,
                           border=1,
                           tag='graf_temp_out')
        self.temp.add_x_axe(4,
                            dash_shift=-24,
                            x_lables_shift=(0, -11),
                            x_lable_color='dark slate gray',
                            x_lable_angle=90)
        self.temp.add_y_axe(300,
                            dash_shift=-4,
                            y_dash_color='SteelBlue2',
                            y_lables_shift=(-10, 0),
                            y_labels_font=('tahoma', 8))
        self.temp.add_title(curtime,
                            position=(50, 10),
                            font=('tahoma', 9),
                            color='green',
                            tag='time')
        self.temp.add_title(curtemp_out,
                            position=(265, 10),
                            font=('tahoma', 9),
                            color='red',
                            tag='cur_temp_out')
        self.temp.add_title(curtemp_in,
                            position=(150, 10),
                            font=('tahoma', 9),
                            color='purple',
                            tag='cur_temp_in')
        self.canvas.pack()

        self.update_clock()
        self.update_graf()
        self.update_axes()
        self.update_cur_temp()
Ejemplo n.º 5
0
 def run(self):
     sms_ = sms(rx=board.GP5, tx=board.GP4)
     sensors_ = sensors(i2c)
     gps_ = gps(i2c, 1000)
     sms_.send_msg("gps+sensors ok")
     sleep_ms(50)
     sms_.report()
     print("Done")
     return calibration(sms_, sensors_, gps_)
Ejemplo n.º 6
0
def beginMQTTClient(
):  ############################ DEFINING COROUTINE###################
    client = hbmqttclient.MQTTClient()
    yield from client.connect(MQTT_BROKER_URI)
    yield from client.subscribe([(CHANNEL_ID, hbmqtt.mqtt.constants.QOS_0)])
    while True:
        weGotMail = False
        try:
            msg = yield from client.deliver_message(timeout=.1)
            weGotMail = True
        except asyncio.TimeoutError:
            pass
        except asyncio.IncompleteReadError:
            print("GGWP")
        # Handle local user trying to send a message
        try:
            inputLine = inputQueue.get_nowait()
            response = CLIENT_ID + " " + inputLine
            yield from client.publish(CHANNEL_ID, bytearray(response, "utf-8"))

        except queue.Empty:
            pass  # No new user input

        if weGotMail:
            # DECODING BYTEARRAY INTO utf-8
            rawStrMsg = msg.data.decode("utf-8")
            clientId = rawStrMsg[0:CLIENT_ID_LENGTH]
            textMessage = rawStrMsg[CLIENT_ID_LENGTH + 1:]
            #textMessage = str(sensors())
            #continue

            # IGNORE OWN MESSAGES
            if clientId == CLIENT_ID:
                continue

            print("Client " + clientId + ": " + textMessage)
            if (textMessage == "GET_DATA"):
                try:
                    pre_response = str(sensors())
                    response = "Client" + clientId + ":" + pre_response
                    #print(response)
                    yield from client.publish(
                        CHANNEL_ID, bytearray(response, "utf-8")
                    )  #######################REPLY TO SENDER WITH INFO(SENSOR STUFF)#############
                except asyncio.IncompleteReadError:
                    print("Try again")
Ejemplo n.º 7
0
    def run(self) -> state:
        check = Pin(4, Pin.IN, Pin.PULL_UP)

        while check.value():
            utime.sleep(1)
            indicate("Waiting")

        sensor = sensors()

        n_logs = len(list(filter(lambda s: "log" in s, listdir())))
        if n_logs != 0:
            buzzer.playsong("miichannel.txt")
        buffer = storage(STORAGE_BUFFER_SIZE * DATA_SIZE, 0,
                         open("log{}.bin".format(n_logs), "wb"))
        buzzer.playsong("takeonme.txt")
        buzzer.playsong("nokia.txt")
        buzzer.playsong("nokia.txt")
        buzzer.playsong("nokia.txt")
        utime.sleep(PREFLIGHT_DELAY)
        return flight(buffer, sensor)
Ejemplo n.º 8
0
    def __init__(self):
        self.mode = "m"

        self.pitch_hold = False
        #self.hdg_hold=False
        self.alt_hold = False
        self.auto_hold = False

        self.status = c.OK
        self.servos_init = False
        self.throttle_updated = False

        self.pitch = 0.0
        self.roll = 0.0
        self.throttle = 0.0
        self.compass = 0.0
        self.altittude = 0.0

        self.elevons = elevons()
        self.sensors = sensors()
        self.motor = motor_handler()
        self.camera = camera()
Ejemplo n.º 9
0
def main():
    # Create logger
    logging.basicConfig(filename='/home/pi/growlab.log',
                        level=logging.INFO,
                        format='%(asctime)s %(message)s')
    logging.getLogger("growlab")

    print("-----------")
    logging.info("================")
    logging.info("Starting growlab")
    logging.info("================")

    logging.info(os.getcwd())

    # Parse config file
    config = {}
    try:
        with open("./config.json") as f:
            config = json.loads(f.read())
    except Exception as e:
        logging.error("Error: {}".format(e))
        sys.exit(1)

    logging.info("Loaded config, saving images every {} seconds to {}".format(
        config["timelapse"]["interval_seconds"],
        config["images"]["output_directory"]))

    # initialize objects
    capt = sensors()
    prev = preview(config["preview"])
    hmdata = homedata(config["homedata"])
    cam = camera(config["images"])
    spec = specimen(config["text"], config["images"])
    pwd = os.getcwd()

    while True:

        tz_Paris = pytz.timezone('Europe/Paris')
        datetime_Paris = datetime.now(tz_Paris)
        hour = datetime_Paris.hour

        if (config["timelapse"]["start"] <= hour <=
                config["timelapse"]["end"]):
            logging.info(
                "Current hour: {}. A capture is possible.".format(hour))
            logging.info("New capture in progress ... ")
            # get sensors data
            readings = capt.get_readings()
            logging.info(readings)

            # Send sensors data to homedata application
            hmdata.send(readings)

            # get new image
            cam = camera(config["images"])
            frame = cam.get_frame()

            # Save image with incrusted data from sensors
            spec.save_image("{}/image.jpg".format(pwd), frame, readings)
            logging.info("=== Image capturing : done")

            # Archive for timelapse
            if (config["timelapse"]["active"] == "true"):
                spec.copyFile("{}/image.jpg".format(pwd),
                              config["images"]["output_directory"])
                logging.info("=== Image archiving : done")
            else:
                logging.info("=== Image archiving : disabled")

            # Build preview files (image )
            prev.check_preview_directory()
            spec.save_html("{}/image.jpg".format(pwd),
                           config["preview"]["git_dir"], readings)
            logging.info("=== Preview files : done")

            # Publish the preview
            prev.publish_preview()
            logging.info("=== Preview publishing : done")

        else:
            logging.info("Current hour: {} No image between {} and {}".format(
                hour, config["timelapse"]["start"],
                config["timelapse"]["end"]))

        logging.info("... sleep for {} seconds".format(
            config["timelapse"]["interval_seconds"]))
        sleep(config["timelapse"]["interval_seconds"])
Ejemplo n.º 10
0
#!/usr/bin/python
""" try this as an example
 sudo ./taskRun.py reverse 2 left 2 right 2  forward 2
"""
import chassis
import sys
import time
import RPi.GPIO as GPIO
import sensors

c = chassis.chassis()
s = sensors.sensors()

argNum = 1
while (argNum < len(sys.argv)):
    c.run(sys.argv[argNum], sys.argv[argNum + 1])
    s.readAll()
    argNum = argNum + 2

GPIO.cleanup()
Ejemplo n.º 11
0
    def loaderStep0(self):

        #self.s3dtextures = Screen3dtextures()
        #self.s3dtextures.setGui(self)
        #self.rl.ids.bl3dtextures.add_widget( self.s3dtextures.l )
        from sensors import sensors

        self.cDefVals = {
            'screenCurrent': 'Sensors',
            'totalUptime': 0,
            'totalMiles': 0.0,
            'apDirectionReverse': 0,
            'apDriver': 'driver9',
            'apCommunicationMode': "audio jack",
            'apWifiIp': '192.168.4.1'
        }

        for k in self.cDefVals.keys():
            try:
                print("config  			", k, " -- > ", self.config[k])
            except:
                print("config default - > no value [", k, "] setting [",
                      self.cDefVals[k], "]")
                self.config[k] = self.cDefVals[k]

        if self.virtualButtons:
            self.vBut = ScreenVirtualButtons(self)

        wfa = self.workingFolderAdress.split("/")
        dirName = wfa[-2]

        try:
            print("working folder adres ",
                  self.fa.mkDir(self.workingFolderAdress[:-1]))
        except:
            pass

        #self.tcp = helperTCP(ip)
        self.rl.passGuiApp(self)
        self.sen = sensors(self)
        self.sen.comCal.addCallBack(self.sen)

        #self.sen.run()
        """
		self.graph = Graph(xlabel='time', ylabel="angle", x_ticks_minor=1,
			ymax=1.0,ymin=0.0			
			)
		self.pPitch = MeshLinePlot(color=[1,1,0,1])
		self.pHeel = MeshLinePlot(color=[1,0,1,1])
		self.graph.add_plot(self.pPitch)
		self.graph.add_plot(self.pHeel)
		self.rl.ids.blModSimGra.add_widget(self.graph)

		self.graphGyro = Graph(xlabel='time', ylabel="gyro", x_ticks_minor=1,
			ymax=1.0,ymin=0.0			
			)
		self.pgx = MeshLinePlot(color=[1,1,0,1])
		self.pgy = MeshLinePlot(color=[1,0,1,1])
		self.pgz = MeshLinePlot(color=[1,0,0,1])
		self.graphGyro.add_plot(self.pgx)
		self.graphGyro.add_plot(self.pgy)
		self.graphGyro.add_plot(self.pgz)
		self.rl.ids.blModSimGra.add_widget(self.graphGyro)


		self.graphFFT = Graph(xlabel="Hz Heel", ylabel="Db Heel", ymax=1.0, ymin=0.0)
		self.pFFTHeel = MeshLinePlot(color=[1,0,0,1])
		self.pFFTPitch = MeshLinePlot(color=[0,1,0,1])
		self.pFFTUD = MeshLinePlot(color=[0,0,1,1])

		self.graphFFT.add_plot(self.pFFTHeel)
		self.graphFFT.add_plot(self.pFFTPitch)
		self.graphFFT.add_plot(self.pFFTUD)
		self.rl.ids.blModSimFFT.add_widget( self.graphFFT )

		self.compasGyro = Graph(xlabel='time', ylabel="compas", x_ticks_minor=1,
			ymax=1.0,ymin=0.0			
			)
		self.pc = MeshLinePlot(color=[1,1,0,1])
		self.compasGyro.add_plot(self.pc)
		self.rl.ids.blModSimGra.add_widget(self.compasGyro)

		self.graphMic = Graph(xlabel="Hz mic", ylabel="Db mic", ymax=1.0, ymin=0.0)
		self.pMic = MeshLinePlot(color=[1,0,0,1])
		self.pMic1 = MeshLinePlot(color=[0,1,0,1])
		self.pMic2 = MeshLinePlot(color=[0,0,1,1])
		self.graphMic.add_plot(self.pMic)
		self.graphMic.add_plot(self.pMic1)
		self.graphMic.add_plot(self.pMic2)
		self.rl.ids.blMicScre.add_widget(self.graphMic)
		"""

        #self.d3tex2 = d3tex2()
        #self.d3tex2.setGui(self)
        #self.rl.ids.bl3dtextures2.add_widget( self.d3tex2 )

        #action bar
        if True:
            self.mw = BoxLayout(orientation="vertical")
            self.ab = ActionBar()
            av = ActionView()
            self.ab.add_widget(av)
            ap = ActionPrevious(title="ykpilot",
                                with_previous=False,
                                app_icon="icons/ico_sailboat_256_256.png")
            ap.bind(on_release=self.screenChange)
            av.add_widget(ap)

            ao = ActionOverflow()
            ab = ActionButton(text="Sensors",
                              icon="icons/ico_find_256_256.png")
            ab.bind(on_release=self.screenChange)
            av.add_widget(ab)
            ab = ActionButton(text="Model Screen",
                              icon="icons/ico_sailboat_256_256.png")
            ab.bind(on_release=self.screenChange)
            av.add_widget(ab)
            ab = ActionButton(text="Simulator",
                              icon="icons/ico_sum_256_256.png")
            ab.bind(on_release=self.screenChange)
            av.add_widget(ab)

            if self.virtualButtons:
                ab = ActionButton(text="Virtual Buttons",
                                  icon="icons/ico_in_256_256.png")
                ab.bind(on_release=self.screenChange)
                av.add_widget(ab)

            ab = ActionButton(text="Compass")
            ab.bind(on_release=self.screenChange)
            av.add_widget(ab)
            """
			ab = ActionButton(text="3dtextures")
			ab.bind(on_release=self.screenChange)
			av.add_widget(ab)
			
			ab = ActionButton(text="3dtextures2")
			ab.bind(on_release=self.screenChange)
			av.add_widget(ab)
			"""

            ab = ActionButton(text="Race", icon="icons/ico_time_256_256.png")
            ab.bind(on_release=self.screenChange)
            av.add_widget(ab)

            ab = ActionButton(text="Autopilot")
            ab.bind(on_release=self.screenChange)
            av.add_widget(ab)

            ab = ActionButton(text="Mic Screen")
            ab.bind(on_release=self.screenChange)
            av.add_widget(ab)

            ao = ActionOverflow()
            ab = ActionButton(text="Day")
            ab.bind(on_release=self.screenDay)
            av.add_widget(ab)
            ao = ActionOverflow()
            ab = ActionButton(text="Night")
            ab.bind(on_release=self.screenNight)
            av.add_widget(ab)

            ab = ActionButton(text="Widgets")
            ab.bind(on_release=self.screenChange)
            av.add_widget(ab)

            #ab = ActionButton(text="MSM")
            #ab.bind(on_release=self.screenChange)
            #av.add_widget(ab)

            ab = ActionButton(text="NMEA multiplexer")
            ab.bind(on_release=self.screenChange)
            av.add_widget(ab)

            av.add_widget(ao)

            self.mw.add_widget(self.ab)
            try:
                rlParent = self.rl.parent
                rlParent.remove_widget(self.rl)

            except:
                print("rl. don't have parent !")
            self.mw.add_widget(self.rl)

            toreturn = self.mw
        else:
            toreturn = self.rl
        # actionbar

        #play from file
        toreturn = self.sen.buidPlayer(toreturn)
        #play from file

        #self.sWidgets.setUpGui()

        #self.ap.setupDriver()

        #Window.set_title("ykpilot")

        #self.ode = odeRTB(self)
        #self.sen.accel.addCallBack(self.ode)

        rlParent.add_widget(toreturn)
Ejemplo n.º 12
0
# This script simply starts the sensor-thread & gives out the sensor-data in a desired mode.

from debug_log import debug_print
lg = debug_print()
import sensors
import time

mod = int(raw_input("Modus? 0, 1 oder 2? "))

sens = sensors.sensors(mode=mod, start=False)

raw_input("Press enter to start")
sens.start()

time.sleep(1)

while True:
	out = str(sens.running) + ": " + str(sens.measurements[0][0]) + ", ("
	for entry in sens.measurements[1]:
		out = out + str(entry[0]) + ", "
	out = out + "), "  + str(sens.measurements[2][0])
	f=open("test.txt", "w")
	print out + "\n"
	f.write(out + "\n")
	f.close()
	time.sleep(.5)
Ejemplo n.º 13
0
def run():
    machine.freq(160000000)
    print('Machine ID: ' + str(machine.unique_id()))
    print('CPU Speed: ' + str(machine.freq()))
    print("Starting WiFi")

    led = machine.Pin(2, machine.Pin.OUT)

    sta_if = network.WLAN(network.STA_IF)
    sta_if.active(True)

    print("Connecting WiFi")
    sta_if.connect("Tomato24", "Stephen123")
    while not sta_if.isconnected():
        utime.sleep(1)
    print(sta_if.ifconfig())

    s = usocket.socket()
    addr = usocket.getaddrinfo('192.168.1.112', 61111, 0,
                               usocket.SOCK_STREAM)[0][-1]

    sens = sensors([27, 25, 17, 16])
    sens.scan()

    led.value(1)
    utime.sleep_ms(500)
    led.value(0)
    frame = 0

    first = True

    while True:
        utime.sleep_ms(10)

        # Get the machine id on first loop
        if first:
            sens.read_id()
            first = False
        else:
            sens.read_data()

        # Send the data
        try:
            for data in sens.data_list:
                s.send(data)

            frame += 1
            if frame > 300:
                frame = 0
                sens.check_cal()
                #for data in sens.data_list:
                #    print(data)
                #sens.status()

        except OSError:
            first = True
            s.close()
            s = usocket.socket()
            print("Connecting...", end='')
            connected = False
            connect_attempt = 0
            while not connected:
                try:
                    connect_attempt += 1
                    s.connect(addr)
                    connected = True
                    print(" Connected")
                except OSError:
                    print(".", end='')
                    if connect_attempt > 5:
                        machine.reset()
                    utime.sleep_ms(2000)
Ejemplo n.º 14
0
 def read_sensors():
     data = sensors.sensors().read_all()
     dbase = db.db()
     dbase.insert_sensor_data(data)
     dbase.close_connection()
Ejemplo n.º 15
0
	def loaderNextStep(self,a=0,b=0):
		self.loaderStep+=1 
		print("loaderNextStep step now",self.loaderStep)
		
		
		if self.loaderStep == 1:
			if kplatform == 'android':
				self.platform = 'android'
			else:
				self.platform = 'pc'
			
			self.ll.ids.l_loaMaiWin.text = "DONE"
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		
		elif self.loaderStep == 2:
			from TimeHelper import TimeHelper
			from FileActions import FileActions
			self.th = TimeHelper()
			self.fa = FileActions()
			self.homeDirPath = self.fa.getHomeDirectoryForApp(
				'ykpilot', 
				kplatform
				)
			print("homeDir",self.homeDirPath)
			#sys.exit(0)
			self.timeAppStart = self.th.getTimestamp()
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 3:
			self.ll.ids.l_loaHel.text = "DONE"
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
				
			
		
		elif self.loaderStep == 4:
			bS = self.th.benStart()
			Builder.load_file('layoutMain.kv')
			self.rl = RootLayout()
			self.bE = self.th.benDone(bS,'')
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 5:
			self.ll.ids.l_appRooLay.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
				
		elif self.loaderStep == 6:
			bS = self.th.benStart()
			Builder.load_file('layoutActionBar.kv')
			self.ab = ykpActionBar()
			self.bE = self.th.benDone(bS,'')
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 7:
			self.ll.ids.l_actBarLay.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
			
			
		elif self.loaderStep == 8:
			bS = self.th.benStart()
			self.config = DataSR_restore(
				self.fa.join( self.homeDirPath,'ykpilot.conf')
				)
			if self.config == None:
				self.config = {}
			self.doLocalIp()
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 9:
			self.ll.ids.l_loaCon.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		
		elif self.loaderStep == 10:
			bS = self.th.benStart()
			if kplatform == 'android':
				self.platform = 'android'
				self.animation = False
				ipSens = '192.168.43.56'
				if len(self.ips)>0:
					ipSens = self.ips[0]			
				ip = ipSens
				self.senderIp = ip
				self.senderPort = 11223
				makeRender = True
				print("- setting up a sensor server at ",ipSens,":",self.senderPort)
				
				# android service
				if mkservice:
					from android import AndroidService
					service = AndroidService("ykpilot background","running ....")
					service.start("service started")
					self.service = service
				# android service
	
				self.workingFolderAdress = '/storage/emulated/0/ykpilot/'
				self.virtualButtons = False
	
			else:
				self.platform = 'pc'
				self.animation = True
				ipSens = '192.168.43.56'
				if len(self.ips)>0:
					ipSens = self.ips[0]			
				ip = ipSens
				self.senderIp = ip
				self.senderPort = 11225
				makeRender = True
				self.workingFolderAdress = './ykpilot/'
				self.virtualButtons = False
	
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 11:
			self.ll.ids.l_loaPlaChk.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		
		elif self.loaderStep == 12:
			bS = self.th.benStart()
			print("preloaderStep0")
			self.loaderStep0()
			print("postloaderStep0")
			self.bE = self.th.benDone(bS, "")
			#Clock.schedule_once( 
			self.loaderNextStep()#, 0.1 )
			
		elif self.loaderStep == 13:
			self.ll.ids.l_loaRest.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.5 )
			
			
			
		elif self.loaderStep == 14:
			bS = self.th.benStart()
			from sensors import sensors
			self.sen = sensors(self)
			print("pre ask for permissions")
			self.sen.askForPermissions()
			print("post ask for permissions")
			self.bE = self.th.benDone(bS, "")
			
			Clock.schedule_once( self.loaderNextStep, 0.5 )
			
		elif self.loaderStep == 15:
			if self.platform == 'android' and self.sen.permissonsStatus == False:
				self.loaderStep-=1
			else:
				self.ll.ids.l_permissions.text = "DONE in %s sec."%self.bE
				
				
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			


		elif self.loaderStep == 16:
			bS = self.th.benStart()
			
			self.sen.makeSensors()
			p = self.rl.parent
			p.remove_widget(self.rl)
			rl = self.sen.buidPlayer(self.rl)
			p.add_widget(rl)
			#self.sen.run()
			#try:
			#	self.sen.gps_start(1000, 0)
			#except:
			#	print("EE - can't start sen.gps")
			#	print(sys.exc_info())
			#	pass
			
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 17:
			self.ll.ids.l_sensors.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		
		
		elif self.loaderStep == 18:
			bS = self.th.benStart()
			from ScreenWidgets import ScreenWidgets
			self.sWidgets = ScreenWidgets(self)
			self.sWidgets.setGui()
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 19:
			self.ll.ids.l_loaSWid.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
		
		
		
		elif self.loaderStep == 20:
			bS = self.th.benStart()
			from ScreenAutopilot import ScreenAutopilot
			self.ap = ScreenAutopilot(self)
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 21:
			self.ll.ids.l_loaSAut.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
		
		
		
		elif self.loaderStep == 22:
			bS = self.th.benStart()
			from ScreenRace import ScreenRace
			self.sRace = ScreenRace(self)
			self.sRace.setupGui()
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 23:
			self.ll.ids.l_loaSRac.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
			
			
		elif self.loaderStep == 24:
			bS = self.th.benStart()
			from ScreenCompass import ScreenCompass
			self.sCompass = ScreenCompass()
			self.sCompass.setGui(self)
			self.rl.ids.blCompass.add_widget( self.sCompass )
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 25:
			self.ll.ids.l_loaSCom.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
		
		
		
		elif self.loaderStep == 26:
			bS = self.th.benStart()
			from ScreenNMEAMultiplexer import ScreenNMEAMultiplexer
			self.sNMEAMul = ScreenNMEAMultiplexer()
			self.sNMEAMul.setGui(self)
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 27:
			self.ll.ids.l_loaSMul.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )


		
		elif self.loaderStep == 28:
			bS = self.th.benStart()	
			from boatRender import Renderer		
			self.senBoat = Renderer()
			self.senBoat.setGui(self)
			self.rl.ids.blModelScreen.add_widget( self.senBoat )
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 29:
			self.ll.ids.l_loaMScr.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )

		
		
		elif self.loaderStep == 30:
			bS = self.th.benStart()
			from simRender import simRender
			from simEngine import simEngine
			from driver1 import driver1
			from driver2 import driver2
			from driver3 import driver3
			from driver4 import driver4
			from driver5 import driver5
			from driver6 import driver6
			from driver7 import driver7
			from driver8 import driver8
			from driver9 import driver9
			from driver10 import driver10

			self.simRen = simRender()
			self.simEng = simEngine(self,self.simRen)
			self.simRen.setSim(self.simEng)
			self.simRen.setGui(self)
			self.simEng.renderFrame()

			self.rl.ids.blSimulator.add_widget( self.simRen )

			self.driver1 = driver1(self.simEng)
			self.driver2 = driver2(self.simEng)
			self.driver3 = driver3(self.simEng)
			self.driver4 = driver4(self.simEng)
			self.driver5 = driver5(self.simEng)
			self.driver6 = driver6(self.simEng)
			self.driver7 = driver7(self.simEng)
			self.driver8 = driver8(self.simEng)
			self.driver9 = driver9(self.simEng)
			self.driver10 = driver10(self.simEng)
			
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 31:
			self.ll.ids.l_loaSSim.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
		

		
		
		elif self.loaderStep == 32:
			bS = self.th.benStart()
			print("Sender Server is on port[%s]"%self.senderPort)
			self.sf = MyServerFactory(self)
			reactor.listenTCP(self.senderPort, self.sf )
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 33:
			self.ll.ids.l_loaTcpSer.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
		
		
		
		elif self.loaderStep == 34:
			bS = self.th.benStart()
			self.tcp4ap = ttc(self)
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 35:
			self.ll.ids.l_AutoWifiArmTCP.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
		
	
	
		elif self.loaderStep == 36:
			bS = self.th.benStart()
			from ScreenTriangulacja import Triangulacja, TrianAddDialog
			self.triangulacja = Triangulacja(self)
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 37:
			self.ll.ids.l_Tri.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
	
	
		elif self.loaderStep == 38:
			bS = self.th.benStart()
			from ScreenTakePhoto import ScreenTakePhoto
			self.stp = ScreenTakePhoto(self)
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 39:
			self.ll.ids.l_takPho.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
	
		
		elif self.loaderStep == 40:
			bS = self.th.benStart()
			from ScreenSensors import ScreenSensors
			self.sSensors = ScreenSensors()
			self.sSensors.setGui(self)
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 41:
			self.ll.ids.l_screSen.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		
		
		
		
		elif self.loaderStep == 999:
			bS = self.th.benStart()
			
			self.bE = self.th.benDone(bS, "")
			Clock.schedule_once( self.loaderNextStep, 0.1 )
			
		elif self.loaderStep == 1000:
			#self.ll.ids.l_loaSWid.text = "DONE in %s sec."%self.bE
			Clock.schedule_once( self.loaderNextStep, 0.1 )
		
		
		
		
		
		
		else:
			print(" loader finished ?")
				
				
			print(" starting main loop for sensors ")
			self.sen.run()
		
		
		
			
		
		
			if self.sen.gpsD.androidServiceStatus == False:
				try:
					self.sen.gps_start(1000, 0)
				except:
					print("EE - can't gps_start :(")
			
			
			
			self.sen.gpsD.addCallBack( self.sCompass,'Compass' )
			self.sen.comCal.addCallBack( self.sCompass,'Compass' )
			self.sen.comCalAccelGyro.addCallBack( self.sCompass,'Compass' )
			self.sen.gpsD.addCallBack( self.sRace )
			self.sen.comCal.addCallBack( self.ap )
			self.sen.comCal.addCallBack( self.sen )
			self.sen.comCal.addCallBack( self.senBoat )
			#self.gui.senBoat.setRoseta( self.hdg )
			
			#Clock.schedule_once(self.sen.on_PlayFromFile_play, 1.0)
			#Clock.schedule_once(self.sWidgets.on_addEditDelButton, 1.0)
			#Clock.schedule_once(self.sWidgets.rebuildWs, 5.0)
		
			print("starting listener for sensors :) if pc")
			if self.platform == 'pc':
				Clock.schedule_once(self.connectToSensorsRemoteTcp, 1 )
				
				#if 1:
				#	self.plt = PCPlot(self)
				
		
			print('flip layouts....')
			par = self.ll.parent
			par.remove_widget(self.ll)
			par.add_widget(self.rootLayout)
			self.ll = None
			print("	DONE")
			
			
			if self.config['apCommunicationMode'] == 'wifi tcp':
				self.ap.startTcp()
			
			print("config",self.config)
			defScreen = 'ykpilot'
			goToScreen = defScreen
			dontStartAt = ['Loader','EditWidget', 'SettingUpWidget', 'SelectWidgetToAdd']
			try:
				goToScreen = self.config['screenCurrent']
			except:
				print("EE - no def  config['screenCurrent'] :/")
			
			if goToScreen in dontStartAt:
				print("goToScreen is in dont start list")
				goToScreen = defScreen
				
			print("go to screen is ",goToScreen)
			try:
				self.screenChange(goToScreen)
			except:
				print("EE - no screen [",goToScreen,"] in screenmanager")
				self.screenChange(defScreen)
			
		
			#multiplexer screen
			self.rl.ids.cb_nmeBSensors.active = True if self.config['nmeBSensors'] else False
			self.rl.ids.cb_nmeBAutopilot.active = True if self.config['nmeBAutopilot'] else False
			self.rl.ids.cb_nmeBNmea.active = True if self.config['nmeBNmea'] else False
			
			self.triangulacja.isReady()	
			
			
			#self.makeIFT()
			
			self.isReady = True
Ejemplo n.º 16
0
 def __init__(self, simulate=False, width=240, height=320):
     ## @var simulate
     #  Stores simulate parameter from constructor call
     self.simulate = simulate
     ## @var l
     #  Handle to system logger
     self.l = logging.getLogger('system')
     pygame.init()
     # pygame.display.init()
     if not self.simulate:
         pygame.event.set_grab(True)
         pygame.mouse.set_visible(0)
     self.l.debug(
         "[OCC] EV_UPDATE_VALUES to be generated every {} ms".format(
             REFRESH_TIME))
     pygame.time.set_timer(EV_UPDATE_VALUES, REFRESH_TIME)
     self.l.debug("[OCC] EV_SAVE_CONFIG to be generated every {} s".format(
         CONFIG_SAVE_TIME / 1000))
     pygame.time.set_timer(EV_SAVE_CONFIG, CONFIG_SAVE_TIME)
     ## @var width
     #  Window/screen width
     self.width = width
     ## @var height
     #  Window/screen height
     self.height = height
     self.l.debug("[OCC] Screen size is {} x {}".format(
         self.width, self.height))
     ## @var screen
     #  Handle to pygame screen
     self.screen = pygame.display.set_mode((self.width, self.height))
     self.l.debug("[OCC] Calling sensors")
     ## @var sensors
     #  Handle to sensors instance
     self.sensors = sensors(self)
     self.l.debug("[OCC] Calling ride_parameters")
     ## @var rp
     #  Handle to ride_parameters instance
     self.rp = ride_parameters(self, simulate)
     ## @var layout_path
     #  Path to layout file
     self.layout_path = ''
     self.l.debug("[OCC] Initialising config")
     ## @var config
     #  Handle to config instance
     self.config = config(self, "config/config.yaml",
                          "config/config_base.yaml")
     self.l.debug("[OCC] Reading config")
     self.config.read_config()
     ## @var ble_scanner
     #  Handle to ble_scanner instance
     self.ble_scanner = ble_scanner(self)
     ## @var layout
     #  Handle to layout instance
     self.layout = layout(self, self.layout_path)
     self.l.debug("[OCC] Starting RP sensors")
     self.rp.start_sensors()
     self.l.debug("[OCC] Setting up rendering")
     ## @var rendering
     #  Handle to rendering instance
     self.rendering = rendering(self.layout)
     self.l.debug("[OCC] Starting rendering thread")
     self.rendering.start()
     ## @var released_t
     #  Time stamp of pygame.MOUSEBUTTONUP event (end of finger contact with touchscreen)
     self.released_t = 0
     ## @var rel_movement
     #  Vector since MOUSEBUTTONDOWN event. Used to derermine swipe motion.
     self.rel_movement = (0, 0)
     ## @var pressed_t
     #  Time stamp of pygame.MOUSEBUTTONDOWN event (start of finger contact with touchscreen)
     self.pressed_t = 0
     ## @var pressed_pos
     #  Position of pygame.MOUSEBUTTONDOWN event (start of finger contact with touchscreen)
     self.pressed_pos = (0, 0)
     ## @var released_pos
     #  Position of pygame.MOUSEBUTTONUP event (end of finger contact with touchscreen)
     self.released_pos = 0
     ## @var add_rel_motion
     #  Used to control if finger/mouse vectors should be tracked to determine total relative motion
     self.add_rel_motion = False
     ## @var running
     #  Variable controlling the main occ event loop. pygame.QUIT event triggers setting running to False
     self.running = True
     ## @var refresh
     #  Variable controlling if the screen need to be refreshed
     self.refresh = False
Ejemplo n.º 17
0

validCmds = [
    "forward", "reverse", "left", "right", "nod", "arm", "camera", "cameraHS",
    "cameraRF", "cameraRFHS", "cameraVid", "mast", "reset"
]
hostname = socket.gethostname()
htmlRoot = "/var/www/html"
configRoot = htmlRoot + "/curiosity/missions"
seq = sequenceNumber()
missionName = getMissionName()
imgBaseName = "/curiosity/missions/" + hostname + "_" + missionName + "_"
getLock(configRoot, sys.argv)
missionLog = open(configRoot + "/" + missionName + "_log.html", "a")
c = chassis.chassis()
s = sensors.sensors(missionLog)
cam = camera.camera(hostname, seq, htmlRoot, imgBaseName, 4, missionLog)
missionLog.write("<h2>Sequence %s</h2><br>" % seq)
print("<h2>Mission: %s sequence %s</h2><br>" % (missionName, seq))
argNum = 1
while (argNum < len(sys.argv)):
    try:
        task = sys.argv[argNum]
        val = sys.argv[argNum + 1]
    except:
        task = "Dummy"
        val = 0
    if ((task in validCmds) and isNum(val)):
        missionLog.write("<h3>%s %s</h3><br>" % (task, val))
        print("<h3>%s %s</h3><br>" % (task, val))
        if (task.find("cam") != -1):
Ejemplo n.º 18
0
gps_waiting_time = 0.5 # time in seconds in while-loop for waiting for valid GPS
log_file_name='log/RC_log'+str(time.time())+'.txt'	# log-file-name for the GPS-data (not for debug-messages)
accuracy = 0.00003 		 # when is the target reached?? define target-radius here; in degree! (0.000015 ~ 1,7m)
current_distance = accuracy * 10 # dummy value for current distance in meter (only needed for script to start)

Extra_Wait = False 	# Extra_Wait variable to remember that it is needed to wait longer in special cases
GPS_waiting_time = 0.1	# extra GPS-waiting time: for better average in GPS-data


#----------------------------------------------------------------------------------------#

#initialization

# start sensors
sens = sensors.sensors(mode=2, start=True, sensors_min=sens_min) # mode 2 seems to be the best mode: scanning

# start GPS
lg.prt("[01] start GPS & initialize speed control", inst=__name__, lv=200)
gpsp=GPS.GpsPoller()

# open GPS-log-file
lg.prt("[02] open GPS-log-file: " + log_file_name, inst=__name__, lv=200)
log_file = GPS_log.gpslog(log_file_name)

# waiting for GPS to fix
lg.prt("[03] Waiting for valid GPS-information", inst=__name__, lv=200)
time.sleep(2)
lg.prt(gpsp.data, inst=__name__, lv=100)

while (math.isnan(gpsp.data[0])):