Esempio n. 1
0
def main():
    if os.environ.get('MOCK', default='0') == '1':
        status_handler = LogStatusHandler()
        readers = [
            MockWaterMeterDeviceReader('TestMeter1'),
            MockWaterMeterDeviceReader('TestMeter2'),
        ]
    else:
        pi = pigpio.pi()
        status_handler = LedStatusHandler(green_led=LED(pi, GREEN_LED_PIN),
                                          red_led=LED(pi, RED_LED_PIN))
        readers = [
            WaterMeterDeviceReader('JimenezWaterMeter', pi,
                                   JIMENEZ_SENSOR_PIN),
            WaterMeterDeviceReader('PahuckiWaterMeter', pi, PAHUCKI_SENSOR_PIN)
        ]

    metering = None
    try:
        logger.info('Starting metering...')
        metering = Metering(readers, socket.gethostname(), status_handler, 15,
                            True)
        status_handler.ok()
        metering.run()
    except Exception:
        logger.critical('Exiting due to unexpected error %s' %
                        traceback.format_exc())
        status_handler.not_ok()
    except KeyboardInterrupt:
        logger.info('Exiting at user request...')
        status_handler.not_ok()

    logger.info('Stopping metering...')
    metering.stop()
    logger.info('Done.')
def importAni():
    global leds
    global frame_number
    with open('animation8x4.py') as ll:
        line_count = sum(1 for _ in ll)
    ll.close()

    #animation = {}
    frame_number = 1
    file = open('animation8x4.py')
    for r in range(4):
        file.readline()

    for frame  in range(line_count-9):
        buff = file.readline()

        load_frame = buff.split('], [')
        #print(load_frame)
        counter = 1
        uh_leds =[]
        for f in load_frame:

            if counter == 1:
                f = f[3:]
            elif counter == 64:
                f = f[:-5]
            elif counter%8 == 0 and counter != 64:
                f = f[:-1]
            elif (counter-1)%8 == 0:
                f = f[1:]

            y = int((counter-1)/8)
            x = int((counter-1)%8)
            #print(counter,x,y)


            led = LED(radius=20,pos=(x, y))
            #print(' x= ' + str(led.pos_x) + ' y= ' + str(led.pos_y))

            #print(f)
            if f == '0, 0, 0':
                led.lit = False

            else:
                led.lit = True
                f_colours = f.split(',')
                #print(f_colours)
                led.color = [int(f_colours[0]),int(f_colours[1]),int(f_colours[2])]
            uh_leds.append(led)

            counter+=1
        leds = []
        for pp in range(32):
                        leds.append(uh_leds[pp])

        animation[frame_number] = copy.deepcopy(leds)
        frame_number+=1
        counter+=1

    file.close()
Esempio n. 3
0
def setup():
  global Network, lora
  global sleep_time, STOP, myId
  global dust, meteo, thisGPS, useGPS

  display("MySense V %s" % __version__[:6], (0,0), clear=True)
  display("s/n " + myID)
  display("PM   : " + Dust[dust])
  display("meteo: " + Meteo[meteo])
  if useGPS:
    display('G:%.4f/%.4f' % (thisGPS[LAT],thisGPS[LON]))
  sleep(15)

  if Network == 'TTN':
    # Connect to LoRaWAN
    display("Try  LoRaWan", (0,0), clear=True)
    display("LoRa App EUI:")
    display(str(app_eui))
    lora = LORA()
    if lora.connect(dev_eui,app_eui,app_key, ports=2, callback=CallBack):
       display("Joined LoRaWan")
       SendInfo()
    else:
       display("NOT joined LoRa!")
       lora = None
       Network = 'None'
    sleep(10)
  if Network == 'None':
    display("No network!", (0,0), clear=True)
    LED.blink(10,0.3,0xff00ff,True)
    # raise OSError("No connectivity")
  display("Setup done")
Esempio n. 4
0
def ProgressBar(x,y,width,height,secs,blink=0,slp=1):
  global oled, LED, STOP
  if not oled: return
  rectangle(x,y,width,height)
  if (height > 4) and (width > 4):
    rectangle(x+1,y+1,width-2,height-2,0)
    x += 2; width -= 4;
    y += 2; height -= 4
  elif width > 4:
    rectangle(x+1,y,width-2,height,0)
    x += 2; width -= 4;
  else:
    rectangle(x,y,width,height,0)
  step = width/(secs/slp); xe = x+width; myslp = slp
  if blink: myslp -= (0.1+0.1)
  for sec in range(int(secs/slp+0.5)):
    if STOP:
      return False
    if blink:
      LED.blink(1,0.1,blink,False)
    sleep(myslp)
    if x > xe: continue
    rectangle(x,y,step,height)
    oled.show()
    x += step
  return True
def exportAni():

    global saved
    FILE = open("animation8x8.py", "wb")
    FILE.write("from astro_pi import AstroPi\n")
    FILE.write("import time\n")
    FILE.write("ap=AstroPi()\n")
    FILE.write("FRAMES = [\n")
    global leds
    global frame_number
    animation[frame_number] = copy.deepcopy(leds)
    # print 'length of ani is ' + str(len(animation))
    for playframe in range(1, (len(animation) + 1)):
        # print(playframe)
        leds = []
        for x in range(0, 8):
            for y in range(0, 8):
                led = LED(pos=(x, y))
                leds.append(led)
            for saved_led in animation[playframe]:
                if saved_led.lit:
                    for led in leds:
                        if led.pos == saved_led.pos:
                            led.color = saved_led.color
                            led.lit = True
        grid, png_grid = buildGrid()

        FILE.write(str(grid))
        FILE.write(",\n")
    FILE.write("]\n")
    FILE.write("for x in FRAMES:\n")
    FILE.write("\t ap.set_pixels(x)\n")
    FILE.write("\t time.sleep(" + str(1.0 / fps) + ")\n")
    FILE.close()
    saved = True
Esempio n. 6
0
    def send(self, data, port=2):
        """
    Send data over the network.
    """
        if (port < 2) or (port > len(self.s)):
            raise ValueError('Unknown LoRa port')
        if not self.s[port]: raise OSError('No socket')

        rts = True
        try:
            self.s[port].send(data)
            LED.blink(2, 0.1, 0x0000ff)
            # print("Sending data")
            # print(data)
        except OSError as e:
            if e.errno == 11:
                print("Caught exception while sending")
                print("errno: ", e.errno)
            rts = False

        LED.off()
        data = self.s[port].recv(64)
        # print("Received data:", data)
        if self.callback and data:
            self.callback(port, data)
        return rts
Esempio n. 7
0
def exportAni():

    global saved
    FILE=open('animation8x8.py','w')
    FILE.write('from sense_hat import SenseHat\n')
    FILE.write('import time\n')
    FILE.write('sh=SenseHat()\n')
    FILE.write('FRAMES = [\n')
    global leds
    global frame_number
    animation[frame_number] = copy.deepcopy(leds)
    #print 'length of ani is ' + str(len(animation))
    for playframe in range(1,(len(animation)+1)):
        #print(playframe)
        leds =[]
        for x in range(0, 8):
            for y in range(0, 8):
                led = LED(radius=20,pos=(x, y))
                leds.append(led)
            for saved_led in animation[playframe]:
                if saved_led.lit:
                    for led in leds:
                        if led.pos == saved_led.pos:
                            led.color = saved_led.color
                            led.lit = True
        grid, png_grid = buildGrid()

        FILE.write(str(grid))
        FILE.write(',\n')
    FILE.write(']\n')
    FILE.write('for x in FRAMES:\n')
    FILE.write('\t sh.set_pixels(x)\n')
    FILE.write('\t time.sleep('+ str(1.0/fps) + ')\n')
    FILE.close()
    saved = True
Esempio n. 8
0
    def handle(self):
        req_raw = self.request.recv(1024)
        self.logger.debug("Recv from:{0}, data:{1}".format(
            self.client_address, req_raw))
        try:
            req = json.loads(req_raw)
        except Exception:
            self.logger.exception(
                "Failed to parse request: {0}".format(req_raw))
            socket.sendto(json.dumps({
                "code": -1,
                "data": "Error"
            }), self.client_address)
            return

        if req['cmd'] == 'led-control':
            data = req['data']
            led = LED(LED_NAMES.get(data['led-name'].upper()))
            if data['op'].lower() == 'blink':
                if led.blink(count=data.get('count', 1),
                             delay=data.get('delay', 0.5)):
                    self.request.sendall(json.dumps({"code": 0, "data": "OK"}))
                else:
                    self.request.sendall(
                        json.dumps({
                            "code": 1,
                            "data": "FAIL"
                        }))
        elif req['cmd'] == 'quit':
            tcp_stop_event.set()
            self.request.sendall(json.dumps({"code": 1, "data": "OK"}))
        self.logger.debug("Request handled.")
Esempio n. 9
0
def exportAni():

    global saved
    FILE=open('animation8x8.py','w')
    FILE.write('from sense_emu import SenseHat\n')
    FILE.write('import time\n')
    FILE.write('sh=SenseHat()\n')
    FILE.write('FRAMES = [\n')
    global leds
    global frame_number
    animation[frame_number] = copy.deepcopy(leds)
    #print 'length of ani is ' + str(len(animation))
    for playframe in range(1,(len(animation)+1)):
        #print(playframe)
        leds =[]
        for x in range(0, 8):
            for y in range(0, 8):
                led = LED(radius=20,pos=(x, y))
                leds.append(led)
            for saved_led in animation[playframe]:
                if saved_led.lit:
                    for led in leds:
                        if led.pos == saved_led.pos:
                            led.color = saved_led.color
                            led.lit = True
        grid, png_grid = buildGrid()

        FILE.write(str(grid))
        FILE.write(',\n')
    FILE.write(']\n')
    FILE.write('for x in FRAMES:\n')
    FILE.write('\t sh.set_pixels(x)\n')
    FILE.write('\t time.sleep('+ str(1.0/fps) + ')\n')
    FILE.close()
    saved = True
Esempio n. 10
0
 def __init__(self, pin_config):
     self.data = Data()
     self.led = LED()
     self.temp_hum = Temp_Hum()
     self.led_color = (0, 0, 0)
     self.pump = GPIOOut(pin_config.pump_pin)
     self.valve_active = GPIOOut(pin_config.valve_pin)
     self.water_level = GPIOIn(pin_config.water_level_pin)
     self.fan = GPIOOut(pin_config.fan_pin)
Esempio n. 11
0
def importAni():
    global leds
    global frame_number
    with open('animation8x8.py') as ll:
        line_count = sum(1 for _ in ll)
    ll.close()

    #animation = {}
    frame_number = 1
    file = open('animation8x8.py')
    for r in range(3):
        file.readline()

    for frame in range(line_count - 8):
        buff = file.readline()

        load_frame = buff.split('], [')
        #print load_frame
        counter = 1
        leds = []
        for f in load_frame:

            if counter == 1:
                f = f[3:]
            elif counter == 64:
                f = f[:-5]
            elif counter % 8 == 0 and counter != 64:
                f = f[:-1]
            elif (counter - 1) % 8 == 0:
                f = f[1:]

            y = int((counter - 1) / 8)
            x = int((counter - 1) % 8)
            #print(counter,x,y)

            #print(str(counter) + ' ' + f + ' x= ' + str(x) + ' y= ' + str(y))
            led = LED(radius=20, pos=(x, y))
            if f == '0, 0, 0':
                led.lit = False

            else:
                led.lit = True
                f_colours = f.split(',')
                #print(f_colours)
                led.color = [
                    int(f_colours[0]),
                    int(f_colours[1]),
                    int(f_colours[2])
                ]
            leds.append(led)
            counter += 1
        animation[frame_number] = copy.deepcopy(leds)
        frame_number += 1
        counter += 1

    file.close()
Esempio n. 12
0
    def connect(self, dev_eui, app_eui, app_key, ports=1, callback=None):
        """
    Connect device to LoRa.
    Set the socket and lora instances.
    """

        dev_eui = unhexlify(dev_eui)
        app_eui = unhexlify(app_eui)
        app_key = unhexlify(app_key)
        self.callback = callback  # call back routine on LoRa reply callback(port,response)
        # Disable blue blinking and turn LED off
        LED.heartbeat(False)
        LED.off()

        # Initialize LoRa in LORAWAN mode
        self.lora = LoRa(mode=LoRa.LORAWAN)

        # Join a network using OTAA (Over the Air Activation)
        self.lora.join(activation=LoRa.OTAA,
                       auth=(dev_eui, app_eui, app_key),
                       timeout=0)

        # Wait until the module has joined the network
        count = 0
        while not self.lora.has_joined():
            LED.blink(1, 2.5, 0xff0000)
            if count > 20:
                return False
            print("Trying to join: ", count)
            count += 1

        # Create a LoRa socket
        LED.blink(2, 0.1, 0x009900)
        self.s = []
        self.s.append(socket.socket(socket.AF_LORA, socket.SOCK_RAW))

        # Set the LoRaWAN data rate
        self.s[0].setsockopt(socket.SOL_LORA, socket.SO_DR, 5)

        # Make the socket non-blocking
        self.s[0].setblocking(False)

        print("Success after %d tries" % count)
        # print("Create LoRaWAN socket")

        # Create a raw LoRa socket
        # default port 2
        self.s.append(None)
        for nr in range(ports):
            print("Setting up port %d" % (nr + 2))
            self.s.append(socket.socket(socket.AF_LORA, socket.SOCK_RAW))
            self.s[nr + 2].setblocking(False)
            if nr: self.s[nr + 2].bind(nr + 2)
        LED.off()
        return True
Esempio n. 13
0
    def __init__(self):

        from machine import Pin
        from machine import SoftI2C as I2C
        i2 = I2C(scl=Pin(22), sda=Pin(21), freq=400000)
        AXP192PLUS.__init__(self, i2)
        LED.__init__(self)
        ST7789PLUS.__init__(self)
        BUTTON.__init__(self)
        RTCPLUS.__init__(self, i2)
        SOUND.__init__(self)
        self.wlan = WIFI('', '')
Esempio n. 14
0
def main():
   #Create unix pipe
   main_pipe, fingerpint_pipe = Pipe()
   LCD_IN, LCD_OUT = Pipe()
   
   # Initializes LCD and LED
   LCD.init()
   LED.init()
   # Create an object of the class Parser and Poller
   parser = Parser()
   poller = Poller(parser, fingerpint_pipe, 1)
   # Create child process
   pid = os.fork()

   # Parent process
   if pid:
      try:
         # start the individual threads for LCD, NFC and poller
         lcd_thread = threading.Thread(target=LCD.new_start, args=(LCD_IN,))
         lcd_thread.daeomon = True
         lcd_thread.start()
         nfc_thread = threading.Thread(target=nfcread.readNFC, args=(parser, fingerpint_pipe, LCD_OUT,))
         nfc_thread.daeomon = True
         nfc_thread.start()
         poll_thread = threading.Thread(target=poller.startPolling)
         poll_thread.daeomon = True
         poll_thread.start()
      except:
         print "Error: unable to start thread"
      try:
         # Poll fingerprint pipe
         while 1:
            if fingerpint_pipe.poll(1):
               parser.course_id = fingerpint_pipe.recv()
      # Kill the threads and clears the LCD screen
      except KeyboardInterrupt:
         LCD.clear()
         os.kill(pid, signal.SIGKILL)
         os.kill(os.getpid(), signal.SIGKILL)
         sys.exit()
         
         
   else:
      # Start fingerprint on child procces
      try:
         fingerprint = Fingerprint()
         fingerprint.start(parser, main_pipe, LCD_OUT)
      # Clear the screen
      except KeyboardInterrupt:
         LCD.clear()
         sys.exit()
Esempio n. 15
0
def importAni():
    global leds
    global frame_number
    with open('animation8x8.py') as ll:
        line_count = sum(1 for _ in ll)
    ll.close()

# start of actual good code

    #animation = {}
    frame_number = 1
    file = open('animation8x8.py')
    for r in range(line_count):
        buff = file.readline()
        if (buff[:2] == '[['):
            load_frame = buff.split('], [')
            counter = 1
            leds =[]
            for f in load_frame:

                if counter == 1:
                    f = f[2:]
                elif counter == 64:

                    f = f[:-4]

                y = int((counter-1)/8)
                x = int((counter-1)%8)

                #print(str(counter) + ' ' + f + ' x= ' + str(x) + ' y= ' + str(y))
                led = LED(radius=20,pos=(x, y))
                if f == '0, 0, 0':
                    led.lit = False

                else:
                    led.lit = True
                    f_colours = f.split(',')
                    #print(f_colours)
                    led.color = [int(f_colours[0]),int(f_colours[1]),int(f_colours[2])]
                leds.append(led)
                counter+=1
            animation[frame_number] = copy.deepcopy(leds)
            frame_number+=1
            counter+=1


##### end of actual good code



    file.close()
Esempio n. 16
0
def heating(temperature, thermostat_temp):
    # red = [255, 0, 0]
    # black = [0, 0, 0]

    pin = 16
    led = LED(rpi, pin)
    if thermostat_temp <= temperature:
        # sense.led_2(black)
        led.turn_off()
        return "OFF"
    else:
        # sense.led_2(red)
        led.turn_on()
        return "ON"
Esempio n. 17
0
 def pollPendingPracticals(self):
     if self.parser.course_id == None:
         # Try to get pending practicals
         pending_practical = self.parser.query_pending_practicals(
             self.pi_id)
         if pending_practical.error != None:
             print("There was an error:" + pending_practical.error)
         elif pending_practical.pending:
             print("Practical for course: " + pending_practical.course_id +
                   " started")
             LED.asyncGreen()
             # Inform fingerprint about practical
             self.fingerprint_pipe.send(pending_practical.course_id)
     # Wait 10 seconds
     time.sleep(10)
Esempio n. 18
0
    def __init__(self, rows, columns, serial_type=1, led_pin=18):
        ##
        # serial_type 信号线连接方式, 1表示弓字形连线,2表示Z字形连线
        ##
        self.rows = rows
        self.columns = columns
        self.led_numbers = rows * columns
        self._mod = 1
        self.leds = []
        for i in range(self.led_numbers):
            self.leds.append(LED(i))

        self.led_index = [[0 for i in range(self.columns)]
                          for i in range(self.rows)]
        if (serial_type == 1):
            for i in range(0, rows, 2):
                for j in range(0, self.columns):
                    self.led_index[i][j] = i * self.columns + j

            for i in range(1, rows, 2):
                for j in range(0, self.columns):
                    self.led_index[i][j] = (i + 1) * self.columns - (j + 1)
        elif (serial_type == 2):
            for i in range(0, rows):
                for j in range(0, columns):
                    self.led_index[i][j] = i * self.columns + j

        self.strip = PixelStrip(self.led_numbers, led_pin)
        self.strip.begin()
        self.strip.setBrightness(255)
Esempio n. 19
0
def main():
    gpio_classes = [
    ]  # Add any GPIO class we use, so we can clean up at the end

    try:

        buzzerController = Buzzer()
        ledController = LED()

        gpio_classes.append(buzzerController)
        gpio_classes.append(ledController)
        sensor = UltraSonic()
        socket = ServerSocket()
        socket.setLightsUpdated(ledController.setState)
        sensor.setHandDetectedCallback(lambda: (buzzerController.playSound(
        ) or True) and socket.sendFlameState(True))
        sensor.setHandRemovedCallback(lambda: socket.sendFlameState(False))
        sensor.start()

        while True:
            time.sleep(1)

    except KeyboardInterrupt:
        print("Program stopped...")
        for g in gpio_classes:
            g.cleanup()
Esempio n. 20
0
def importAni():
    global leds
    global frame_number
    with open('animation8x8.py') as ll:
        line_count = sum(1 for _ in ll)
    ll.close()

    #animation = {}
    frame_number = 1
    file = open('animation8x8.py')
    for r in range(4):
        file.readline()

    for frame  in range(line_count-8):
        buff = file.readline()

        load_frame = buff.split('], [')
        counter = 1
        leds =[]
        for f in load_frame:

            if counter == 1:
                f = f[2:]
            elif counter == 64:

                f = f[:-4]

            y = int((counter-1)/8)
            x = int((counter-1)%8)

            #print(str(counter) + ' ' + f + ' x= ' + str(x) + ' y= ' + str(y))
            led = LED(radius=20,pos=(x, y))
            if f == '0, 0, 0':
                led.lit = False

            else:
                led.lit = True
                f_colours = f.split(',')
                #print(f_colours)
                led.color = [int(f_colours[0]),int(f_colours[1]),int(f_colours[2])]
            leds.append(led)
            counter+=1
        animation[frame_number] = copy.deepcopy(leds)
        frame_number+=1
        counter+=1

    file.close()
Esempio n. 21
0
def initLEDs(config):
	"""
	Given a LockingConfigParser configuration instance, create a dictionary of 
	GPIOLED instances to control the various LEDs.
	"""
	
	# Create the GPIOLED instances
	leds = {}
	for color in ('red', 'yellow', 'green'):
		try:
			pin = config.get('LED', '%spin' % color)
			leds[color] = LED(pin)
			
		except NoSectionError:
			leds[color] = LED(-1)
			
	# Done
	return leds
Esempio n. 22
0
 def __init__(self):
     self._show_timeout = 0
     self._first_update = True
     self._led = LED(Pins.RED, Pins.GREEN, Pins.BLUE)
     self._led.blink((1, 0, 0))
     self._simple = Geoclue.Simple.new('geoclue-where-am-i', # Let's cheat
                                       Geoclue.AccuracyLevel.EXACT,
                                       None,
                                       self._on_simple_ready)
Esempio n. 23
0
    def start(self):
        led = LED()

        s = socket.socket()
        ai = socket.getaddrinfo("0.0.0.0", 8080)
        print("Bind address info:", ai)
        addr = ai[0][-1]

        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

        s.bind(addr)
        s.listen(5)
        print("Listening, connect your browser to http://<this_host>:8080/")

        counter = 0
        while True:
            res = s.accept()
            client_s = res[0]
            client_addr = res[1]
            print("Client address:", client_addr)
            print("Client socket:", client_s)

            req = client_s.recv(4096)
            arr = req.decode().split('\n')
            dic = {}
            for line in arr:
                if line.startswith('GET /?'):
                    print(line)
                    queryString = line.split(' ')[1][2:]
                    print('queryString=', queryString)
                    params =  queryString.split('&')
                    for param in params:
                        p = param.split('=')
                        print(p)
                        dic[p[0]] = int(p[1])

                    led.set(dic)

            print(dic)

            client_s.send(CONTENT % counter)
            client_s.close()
            counter += 1
            print()
Esempio n. 24
0
class DataBoard:

	temperature = dict()
	defaultWait = 5

	def __init__(self):
		self.weatherDataObj    = WeatherData()
		self.palletObj         = Pallet()
		self.fbNotificationObj = fbNotification()
		self.fb_led            = LED(22)

	def show_temperature(self, temperature = None):

		self.weatherDataObj.get_weather()
		if temperature is not None:
			print "\n Temperature : %f" % temperature
		else:
			print "\n Temperature : %f" % self.weatherDataObj.weather['temperature']

		self.__temperature_gradient(temperature)
		self.palletObj.color( self.temperature['led']['r'],
		                      self.temperature['led']['g'],
		                      self.temperature['led']['b'])
		time.sleep( self.defaultWait )


	def __temperature_gradient(self, temperature=None):
		leds = dict()
		if temperature is None:
			leds['r'] = self.__calculate_temperature_gradient( self.weatherDataObj.weather['temperature'] )
		else:
			leds['r'] = temperature
		leds['b'] = 255 - leds['r']
		leds['g'] = 0
		self.temperature['led'] = leds

	def __calculate_temperature_gradient(self, temperature):
		return round( (255 * temperature )/ 90 )

	def fb_notification(self):
		fb_notifications = self.fbNotificationObj.notifications(True)
		if len( fb_notifications ) :
			self.fb_led.pulse()
Esempio n. 25
0
    def add_reactor(self, button, led):
        # Setup the button
        GPIO.setup(button, GPIO.IN)
        button_obj = TactileSwitch(button)

        # Setup the LED
        GPIO.setup(led, GPIO.OUT)
        led_obj = LED(led)

        self.reactors.append((button_obj, led_obj))
Esempio n. 26
0
    def __init__(self, token, duration, interval, retrytime, last_uploaded_file):
        self.token = token
        self.duration = duration
        self.interval = interval
        self.retrytime = retrytime
        self.last_uploaded_file = last_uploaded_file

        self.led = LED(red=13, green=19, blue=26, initial_color='white')
        self._q = Queue()
        self.default_blink_interval = (5, 300)
        self.fast_blinking = (0.5, 500)
Esempio n. 27
0
 def __init__(self, start, angle, nleds, spacing, task_period):
     self.start = start
     self.xstep = spacing * cos(radians(angle))
     # Invert Y because processing's coordinate system is backwards
     self.ystep = -(spacing * sin(radians(angle)))
     self.leds = [LED(5)] * nleds
     self.end = Point(self.start.x + (self.xstep * nleds),
                      self.start.y + (self.ystep * nleds))
     self.next = None
     self.colours = deque([color(0)] * nleds)
     self.task = Task(task_period)
Esempio n. 28
0
    def _ConfigureBoard(self):
        """Initializes the board."""
        Log('Configuring board')
        if self.status_led_pin:
            self._status_led = LED(self.status_led_pin)
        self._shutter_btn = machine.Pin(self.shutter_pin, machine.Pin.IN)
        self._shutter_btn.irq(trigger=machine.Pin.IRQ_FALLING,
                              handler=self._ShutterCallback)

        if self.next_mode_pin:
            self._next_mode_btn = machine.Pin(self.next_mode_pin,
                                              machine.Pin.IN)
            self._next_mode_btn.irq(trigger=machine.Pin.IRQ_FALLING,
                                    handler=self._ModeWheelCallback)

        if self.prev_mode_pin:
            self._prev_mode_btn = machine.Pin(self.prev_mode_pin,
                                              machine.Pin.IN)
            self._prev_mode_btn.irq(trigger=machine.Pin.IRQ_FALLING,
                                    handler=self._ModeWheelCallback)
Esempio n. 29
0
    def send(self, data):
        """
    Send data over the network.
    """

        try:
            self.s.send(data)
            LED.blink(2, 0.1, 0x00ff00)
            print("Sending data:")
            print(data)
        except OSError as e:
            if e.errno == 11:
                print("Caught exception while sending")
                print("errno: ", e.errno)

        LED.off()
        data = self.s.recv(64)
        print("Received data:", data)

        return data
Esempio n. 30
0
def play():

	global leds
	global frame_number
	animation[frame_number] = copy.deepcopy(leds)
	#print 'length of ani is ' + str(len(animation))
	for playframe in range(1,(len(animation)+1)):
		#print(playframe)
		leds =[]
		for x in range(0, 8):
			for y in range(0, 8):
				led = LED(radius=20,pos=(x, y))
				leds.append(led)
			for saved_led in animation[playframe]:
				if saved_led.lit:
					for led in leds:
						if led.pos == saved_led.pos:
							led.color = saved_led.color
							led.lit = True
		piLoad()
		time.sleep(1.0/fps)
Esempio n. 31
0
def play():
	
	global leds
	global frame_number
	animation[frame_number] = copy.deepcopy(leds)
	#print 'length of ani is ' + str(len(animation))
	for playframe in range(1,(len(animation)+1)):
		#print(playframe) 
		leds =[]
		for x in range(0, 8):
			for y in range(0, 8):
				led = LED(pos=(x, y))
				leds.append(led)
			for saved_led in animation[playframe]:
				if saved_led.lit:
					for led in leds:
						if led.pos == saved_led.pos:
							led.color = saved_led.color
							led.lit = True
		piLoad()
		time.sleep(1.0/fps)
Esempio n. 32
0
def main():
    '''
        Test LED
            Blink Red
            Solid Red
            Blink Green
            Solid Green
        Test Trigger
            Push trigger
            Hold trigger
        Test Send fake IR code
            Listen for callback
    '''
    led = LED()
    print("Testing LEDs.\n")
    eventOne = threading.Event()
    threadOne = threading.Thread(name='ledOnRed', target=setLED, args=(eventOne, 'red', led, 1))
    threadOne.start()
    answer = input("Is the Red LED on? y/n: ")
    eventOne.set()
    if not answer.lower() == 'y': return False
    eventTwo = threading.Event()
    threadTwo = threading.Thread(name='ledBlinkRed', target=toggleLED, args=(eventTwo, 'red', led, 1))
    threadTwo.start()
    answer = input("Is the Red LED blinking? y/n: ")
    # Get user input.
    eventTwo.set()
    if not answer.lower() == 'y': return False
    eventThree = threading.Event()
    threadThree = threading.Thread(name='ledOnGreen', target=setLED, args=(eventThree, 'green', led, 1))
    threadThree.start()
    answer = input("Is the Green LED on? y/n: ")
    eventThree.set()
    if not answer.lower() == 'y': return False
    eventFour = threading.Event()
    threadFour = threading.Thread(name='ledBlinkGreen', target=toggleLED, args=(eventFour, 'green', led, 1))
    threadFour.start()
    answer = input("Is the Green LED blinking? y/n: ")
    # Get user input.
    eventFour.set()
    if not answer.lower() == 'y': return False
    trigger = Trigger()
    print("Push and hold the trigger for 10 events.")
    i = 0
    while i < 10:
        if GPIO.input(trigger.TRIGGER) == GPIO.HIGH:
            time.sleep(0.1)
            print(("{}: Trigger detected.").format(datetime.datetime.now()))
            i += 1
    time.sleep(1)
    print("LaserPi programmed remote codes:")
    call(["irsend", "LIST", "laserpi", ""])
    return True
 def __init__(self, local_led=None):
     self.valid_coins = {
         NICKEL: .05,
         DIME: 0.1,
         QUARTER: 0.25,
         DOLLAR: 1.00
     }
     self.coins = []
     self.products = {APPLE: 0.65, ORANGE: 0.75, BANANA: 1.0}
     self.green_light = local_led
     if not self.green_light:
         self.green_light = LED(LED.GREEN_LIGHT)
Esempio n. 34
0
def runMe():
  global lora, sleep_time, oled
  global useDust

  setup() # Setup network & sensors

  while True:

    toSleep = time()
    dData = DoDust()
    mData = DoMeteo()

    # Send packet
    if lora != None:
      if  lora.send(DoPack(dData,mData,LocUpdate())):
        LED.off()
      else:
        display(" LoRa send ERROR")
        LED.blink(5,0.2,0x9c5c00,False)

    toSleep = sleep_time - (time() - toSleep)
    if useDust:
      if toSleep > 30:
        toSleep -= 15
        useDust.Standby()   # switch off laser and fan
      elif toSleep < 15: toSleep = 15
    if not ProgressBar(0,63,128,2,toSleep,0xebcf5b,10):
      display('stopped SENSING', (0,0), clear=True)
      LED.blink(5,0.3,0xff0000,True)
    if STOP:
      sleep(60)
      oled.poweroff()
      # and put ESP in deep sleep: machine.deepsleep()
      return False
Esempio n. 35
0
def start_animation():
	global animation_process
	global saved
	FILE=open('/home/pi/RPi_8x8GridDraw/animation8x8.py','wb')
	FILE.write('from sense_hat import AstroPi\n')
	FILE.write('import time\n')
	FILE.write('ap=AstroPi()\n')
	FILE.write('FRAMES = [\n')
	global leds
	global frame_number
	animation[frame_number] = copy.deepcopy(leds)
	#print 'length of ani is ' + str(len(animation))
	for playframe in range(1,(len(animation)+1)):
		#print(playframe) 
		leds =[]
		for x in range(0, 8):
			for y in range(0, 8):
				led = LED(pos=(x, y))
				leds.append(led)
			for saved_led in animation[playframe]:
				if saved_led.lit:
					for led in leds:
						if led.pos == saved_led.pos:
							led.color = saved_led.color
							led.lit = True
		grid, png_grid = buildGrid()
		
		FILE.write(str(grid))
		FILE.write(',\n')
	FILE.write(']\n')
	FILE.write('while True:\n')
	FILE.write('\tfor x in FRAMES:\n')
	FILE.write('\t\tap.set_pixels(x)\n')
	FILE.write('\t\ttime.sleep('+ str(1.0/fps) + ')\n')
	FILE.close()
	saved = True
	if animation_process is not None:
		animation_process.terminate()
	animation_process = subprocess.Popen(["python", "/home/pi/RPi_8x8GridDraw/animation8x8.py"])
Esempio n. 36
0
def main():
    global g_event, g_led

    cwd = os.path.abspath(os.path.dirname(__file__))
    logging.basicConfig(filename=cwd+'/log.log',level=logging.DEBUG,format='%(asctime)s %(filename)s[line:%(lineno)d] %(message)s',datefmt='%Y-%m-%d %H:%M:%S')

    # 初始化 event
    g_event = threading.Event()

    # 初始化 gpio
    GPIO.setwarnings(True) # Ignore warning for now
    GPIO.setmode(GPIO.BOARD) # Use physical pin numbering

    # 初始化 LED
    g_led = LED()
    g_led.set_value(15)

    regist_button()

    b_reboot = False
    try:
        # 等待事件触发
        g_event.wait()
        b_reboot = True

    except KeyboardInterrupt as e:
        logging.warning("KeyboardInterrupted")
        pass

    # 清理GPIO
    logging.debug("gpio cleaning")
    GPIO.cleanup() # Clean up
    logging.debug("gpio cleaned")

    if b_reboot:
        logging.debug("shutting down")
        os.system('shutdown -r 0')
Esempio n. 37
0
def nextFrame():

    global frame_number
    global leds
    #print(frame_number)
    animation[frame_number] = copy.deepcopy(leds)
    #clearGrid()
    frame_number+=1
    if frame_number in animation:
        leds =[]
        for x in range(0, 8):
            for y in range(0, 8):
                led = LED(radius=20,pos=(x, y))
                leds.append(led)
        load_leds_to_animation()
Esempio n. 38
0
    def run(self):
        led = LED()
        sensor_reader = SensorReader(self.device_port, self.baudrate)
        sensor_reader.start_reading()
        # database = Database(self.db_file)
        light_controller = Controller(sensor_reader, led)

        try:
            log.startLogging(sys.stdout)
            factory = WebSocketServerFactory()
            factory.protocol = RPiServerProtocol
            factory.protocol.controller = light_controller
            light_controller._init_read_thread()
            broadcast_task = task.LoopingCall(self.broadcast, factory)
            broadcast_task.start(self.broadcast_frequency)
            reactor.listenTCP(self.port, factory)
            reactor.run()
        except CannotListenError:
            print "Another server already opened at port: ", self.port
        finally:
            sensor_reader.close()
            light_controller.stop()
            # database.close_connection()
            led.stop()
Esempio n. 39
0
def prevFrame():

	global frame_number
	global leds
	#print(frame_number)
	animation[frame_number] = copy.deepcopy(leds)
	clearGrid()
	if frame_number != 1:
		frame_number-=1
	if frame_number in animation:
		leds =[]
		for x in range(0, 8):
			for y in range(0, 8):
				led = LED(pos=(x, y))
				leds.append(led)
		load_leds_to_animation()
Esempio n. 40
0
    def connect(self, dev_eui, app_eui, app_key):
        """
    Connect device to LoRa.
    Set the socket and lora instances.
    """

        dev_eui = unhexlify(dev_eui)
        app_eui = unhexlify(app_eui)
        app_key = unhexlify(app_key)

        # Disable blue blinking and turn LED off
        LED.heartbeat(False)
        LED.off()

        # Initialize LoRa in LORAWAN mode
        self.lora = LoRa(mode=LoRa.LORAWAN)

        # Join a network using OTAA (Over the Air Activation)
        self.lora.join(activation=LoRa.OTAA,
                       auth=(dev_eui, app_eui, app_key),
                       timeout=0)

        # Wait until the module has joined the network
        count = 0
        while not self.lora.has_joined():
            LED.blink(1, 2.5, 0xff0000)
            # print("Trying to join: " ,  count)
            count = count + 1

        # Create a LoRa socket
        LED.blink(2, 0.1)
        self.s = socket.socket(socket.AF_LORA, socket.SOCK_RAW)

        # Set the LoRaWAN data rate
        self.s.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)

        # Make the socket non-blocking
        self.s.setblocking(False)

        # print ("Joined! ",  count)
        # print("Create LoRaWAN socket")

        # Create a raw LoRa socket
        self.s = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
        self.s.setblocking(False)
Esempio n. 41
0
def main():
	
	action = request.values['action']

	led = LED(17)

	if action == 'on':
		led.on()

	if action == 'off':
		led.off()

	return 'success'
Esempio n. 42
0
from led import LED

led = LED(27)

while(True):
	led.wait(1)

	led.turnOn()

	led.wait(1)

	led.turnOff()
Esempio n. 43
0
class PyBlaster:
    """Daemon for PiBlaster project"""

    def __init__(self):
        """Whole project is run from this constructor
        """

        # +++++++++++++++ Init +++++++++++++++ #

        self.keep_run = 0  # used in run for daemon loop, reset by SIGTERM

        self.log = Log(self)
        self.settings = Settings(self)
        self.led = LED(self)
        self.dbhandle = DBHandle(self)
        self.mixer = AlsaMixer(self)
        self.usb = UsbManager(self)
        self.rfcomm = RFCommServer(self)
        self.cmd = EvalCmd(self)
        self.listmngr = PlayListManager(self)
        self.play = Play(self)
        self.lirc = LircThread(self)
        self.buttons = Buttons(self)
        self.keep_run = 1
        self.ret_code = 0  # return code to command line (10 = shutdown)

        self.led.reset_leds()

        # invoke arg parser and parse config or create new config if not found
        self.settings.parse()

        # check if we can load database, create otherwise
        self.dbhandle.dbconnect()

        # restore alsa mixer settings
        self.mixer.restore_mixer()

        # load connected usb before bluetooth
        self.usb.check_new_usb()

        # initialize sound mixer
        self.play.init_mixer()

        # load latest playlist from database
        self.listmngr.load_active_playlist()

        # open cmd fifo to read commands
        self.cmd.open_fifo()

        # fire up bluetooth service
        self.rfcomm.start_server_thread()

        # start lirc thread
        self.lirc.start()

        # fire up one thread per each button
        self.buttons.start()

        # +++++++++++++++ Daemoninze +++++++++++++++ #

        self.check_pidfile()
        self.daemonize()
        self.create_pidfile()

        self.led.show_init_done()

        # +++++++++++++++ Daemon loop +++++++++++++++ #

        self.run()

        # +++++++++++++++ Finalize +++++++++++++++ #

        self.listmngr.save_active()
        self.led.cleanup()
        self.delete_pidfile()

    def run(self):
        """Daemon loop"""

        # Expensive operations like new usb drive check
        # should not be run every loop run.
        poll_count = 0

        # -e flag is set, run only init and exit directly.
        self.keep_run = 0 if self.settings.exitafterinit else 1

        reset_poll_count = self.settings.keep_alive_count * 30 * 4

        # # # # # # DAEMON LOOP ENTRY # # # # # #

        while self.keep_run:

            poll_count += 1

            # Check cmd fifo for new commands.
            if poll_count % 10 == 0:
                # each 300 ms is enough
                self.cmd.read_fifo()

            # Check button events
            if self.buttons.has_button_events():
                self.buttons.read_buttons()

            # Check bluetooth channel for new messages/connections.
            self.rfcomm.check_incomming_commands()

            # Check if lirc thread has command in queue
            if self.lirc.queue_not_empty():
                ircmd = self.lirc.read_command()
                if ircmd is not None:
                    self.cmd.evalcmd(ircmd, "lirc")

            # Check if song has ended
            if poll_count % 4 == 0:
                # every 120 ms
                self.play.check_pygame_events()

            time.sleep(self.settings.polltime / 1000.)  # 30ms default in
                                                        # config

            if poll_count % self.settings.keep_alive_count == 0:
                self.led.set_led_green(1)

            if (poll_count - self.settings.flash_count) % \
                    self.settings.keep_alive_count == 0:
                self.led.set_led_green(0)

            # Check for new USB drives.
            if poll_count % 30 == 0:
                # If new usb device found, new usbdev instance will be created,
                # including dir and mp3 entries.
                # If usb device got lost, all its entries will be removed.
                # To check every ~900ms is enough
                self.usb.check_new_usb()

            # Multiple of all poll counts reached:
            # may reset poll count at reset_poll_count.
            if poll_count >= reset_poll_count:
                poll_count = 0

            # end daemon loop #

        # # # # # # DAEMON LOOP EXIT # # # # # #

        # join remaining threads
        self.mixer.save_mixer()
        self.lirc.join()
        self.buttons.join()
        self.rfcomm.join()

        self.log.write(log.MESSAGE, "---- closed regularly ----")

    # end run() #

    def daemonize(self):
        """Fork process and disable print in log object"""

        signal.signal(signal.SIGTERM, self.term_handler)
        signal.signal(signal.SIGINT, self.term_handler)

        if not self.settings.daemonize:
            self.log.init_log()
            return

        self.log.write(log.DEBUG1, "daemonizing")

        try:
            pid = os.fork()
        except OSError:
            self.log.write(log.EMERGENCY, "Failed to fork daemon")
            raise

        if pid == 0:
            os.setsid()
            try:
                pid = os.fork()
            except OSError:
                self.log.write(log.EMERGENCY, "Failed to fork daemon")
                raise

            if pid == 0:
                os.chdir("/tmp")
                os.umask(0)
            else:
                os._exit(0)
        else:
            os._exit(0)

        self.settings.is_daemonized = True
        self.log.init_log()
        self.log.write(log.MESSAGE, "daemonized.")

    # end daemonize() #

    def term_handler(self, *args):
        """ Signal handler to stop daemon loop"""
        self.keep_run = 0

    def check_pidfile(self):
        """Check if daemon already running, throw if pid file found"""

        if os.path.exists(self.settings.pidfile):
            self.log.write(log.EMERGENCY, "Found pid file for pyblaster, "
                           "another process running?")
            raise Exception("pid file found")

    def create_pidfile(self):
        """Write getpid() to file after daemonize()"""

        try:
            fpid = open(self.settings.pidfile, "w")
        except IOError:
            self.log.write(log.EMERGENCY, "failed to create pidfile %s" %
                           self.settings.pidfile)
            raise

        fpid.write("%s\n" % os.getpid())

    def delete_pidfile(self):
        """Try to remove pid file after daemon should exit"""

        if os.path.exists(self.settings.pidfile):
            try:
                os.remove(self.settings.pidfile)
            except OSError:
                self.log.write(log.EMERGENCY, "failed to remove pidfile %s" %
                               self.settings.pidfile)
                raise

    def kill_other_pyblaster(self):
        """Check if pid found in pid file and try to kill this (old) process"""

        if not os.path.exists(self.settings.pidfile):
            return

        try:
            f = open(self.settings.pidfile, "r")
        except IOError:
            self.log.write(log.EMERGENCY, "failed to read pidfile %s" %
                           self.settings.pidfile)
            raise

        pid = int(f.readline().strip())

        print("Trying to kill old process with pid %s..." % pid)

        try:
            os.kill(pid, signal.SIGTERM)
        except OSError:
            self.log.write(log.EMERGENCY,
                           "failed to kill process with pid %s" % pid)
            raise

        exit(0)
Esempio n. 44
0
class LEDWeather:
    def __init__(self):
        self._show_timeout = 0
        self._first_update = True
        self._led = LED(Pins.RED, Pins.GREEN, Pins.BLUE)
        self._led.blink((1, 0, 0))
        self._simple = Geoclue.Simple.new('geoclue-where-am-i', # Let's cheat
                                          Geoclue.AccuracyLevel.EXACT,
                                          None,
                                          self._on_simple_ready)

    def close(self):
        self._unshedule_weather_show()
        self._led.close()

    def _on_simple_ready(self, simple, data):
        location = simple.get_location()

        self._on_location_updated(location)

    def _on_location_updated(self, location):
        latitude = location.get_property('latitude')
        longitude = location.get_property('longitude')

        world = GWeather.Location.get_world()
        city = world.find_nearest_city(latitude, longitude)
        self.info = GWeather.Info.new(city, GWeather.ForecastType.LIST)
        self.info.set_enabled_providers(GWeather.Provider.METAR | GWeather.Provider.YR_NO)

        self.info.connect('updated', self._on_weather_updated, None)
        self._update_timeout = GLib.timeout_add_seconds(3600, self._on_weather_update_timeout)

    def _on_weather_update_timeout(self):
        self._unshedule_weather_show()
        self._led.blink((1, 0, 0))
        self.info.update()

        return True

    def _on_weather_updated(self, info, data):
        self._unshedule_weather_show()

        self._index = 0

        if self._first_update:
            self._show_weather()
            self._first_update = False
        else:
            self._show_timeout = GLib.timeout_add_seconds(5, self._on_show_weather_timeout)

    def _on_show_weather_timeout(self):
        self._show_timeout = 0

        forecast_time = self._get_current_forecast_time()
        n_blinks = round((forecast_time - time.time()) / 12 / 3600)
        if n_blinks > 0:
            self._led.blink((0, 1, 0), n_blinks, self._show_weather)
        else:
            self._show_weather()

        return False

    def _show_weather(self):
        forecasts = self.info.get_forecast_list()
        current_time = self._get_current_forecast_time()
        if self._index >= len(forecasts) or current_time >= time.time() + 3600 * 72:
            self._index = 0
            self._led.show_weather(None)
            self._show_timeout = GLib.timeout_add_seconds(5, self._on_show_weather_timeout)

            return False

        current_time = self._get_current_forecast_time()
        str = time.strftime("%c", time.gmtime(current_time))
        print("Weather at %s" % str)
        if self._index == 0:
            self._led.show_weather(self.info)
        else:
            self._led.show_weather(forecasts[self._index])

        self._set_next_index()

        self._show_timeout = GLib.timeout_add_seconds(5, self._on_show_weather_timeout)

        return False

    def _set_next_index(self):
        forecasts = self.info.get_forecast_list()
        current_time = self._get_current_forecast_time()

        index = self._index
        next_index = -1
        while index < len(forecasts):
            [ret, timestamp] = forecasts[index].get_value_update()
            if ret and timestamp >= current_time + 3600 * 12:
                next_index = index
                break
            else:
                index = index + 1

        if next_index == -1:
            self._index = 0
        else:
            self._index = next_index

    def _get_current_forecast_time(self):
        if self._index == 0:
            return time.time()

        forecasts = self.info.get_forecast_list()
        [ret, timestamp] = forecasts[self._index].get_value_update()
        if not ret:
            # Shouldn't be happening but let's be prepared
            return time.time()

        return timestamp

    def _unshedule_weather_show(self):
        if self._show_timeout == 0:
            return

        GLib.source_remove(self._show_timeout)
        self._show_timeout = 0
Esempio n. 45
0
	def __init__(self):
		self.weatherDataObj    = WeatherData()
		self.palletObj         = Pallet()
		self.fbNotificationObj = fbNotification()
		self.fb_led            = LED(22)
Esempio n. 46
0
                pass


# testing purposes
if __name__ == "__main__":

    # rpi
    sr = SensorReader('/dev/ttyUSB0', 115200)

    # red/4
    # sr = SensorReader('/dev/tty.usbserial-MFU7XGR7', 115200)

    # blue/7
    # sr = SensorReader('/dev/tty.usbserial-MFUD5O75', 115200)
    # sr.start_reading()
    led = LED()
    out_file = open(time.strftime('%Y%m%d-%H%M%S') + ".csv", "w")
    database = Database("../rpi.db")
    controller = Controller(sr, led, file=out_file)
    try:
        if len(sys.argv) >= 2:
            for arg in sys.argv:
                if arg == "single_loop":
                    print "single loop option selected"
                    controller.single_loop()
                elif arg == "single":
                    print "measure on single thread selected"
                    controller.single_measure(100)
                elif arg == "stairs":
                    print "measure on single thread selected"
                    controller.stairs_loop()
Esempio n. 47
0
import time
from led import Color, LED
import xbee_leds


if __name__ == '__main__':
    xbees = xbee_leds.get_xbee_list(True)
    if not xbees:
        raise Exception('No XBees found on network') 
    eui = xbees[0]
    
    #initialize ZigBee driver
    xbee_leds.initialize()

    while True:
        for c in (Color(red=0xF), Color(blue=0xF), Color(green=0xf), Color(0xf, 0xf, 0xf)):
            for i in xrange(50):
                bulb = LED(i, c)
                time.sleep(.25)
                xbee_leds.send_leds(bulb.export(), eui)
        
        # make sure we don't try to send too fast
        while xbee_leds.queue_size(eui) > 3:
            time.sleep(0.01)
Esempio n. 48
0
parser.add_argument("-b", "--min_distance", help="sensor min distance measured in centimeters", type=float, default=2)
parser.add_argument("-g", "--log_level", help="log level", type=int, default=logging.INFO)
args = parser.parse_args()

# logging setup
logger = set_logger(level=args.log_level)

# initialize distance sensor
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(args.trigger_pin, GPIO.OUT)
GPIO.setup(args.echo_pin, GPIO.IN)

recent = []

led = LED('led1', 13)
led.start()

range = args.max_distance - args.min_distance
while True:
    try:
        sample = []
        for reading in range(args.sample_size):
            GPIO.output(args.trigger_pin, GPIO.LOW)
            time.sleep(args.sensor_settle)
            GPIO.output(args.trigger_pin, True)
            time.sleep(0.00001)
            GPIO.output(args.trigger_pin, False)
            while GPIO.input(args.echo_pin) == 0:
                sonar_signal_off = time.time()
            while GPIO.input(args.echo_pin) == 1:
Esempio n. 49
0
    def __init__(self):
        """Whole project is run from this constructor
        """

        # +++++++++++++++ Init +++++++++++++++ #

        self.keep_run = 0  # used in run for daemon loop, reset by SIGTERM

        self.log = Log(self)
        self.settings = Settings(self)
        self.led = LED(self)
        self.dbhandle = DBHandle(self)
        self.mixer = AlsaMixer(self)
        self.usb = UsbManager(self)
        self.rfcomm = RFCommServer(self)
        self.cmd = EvalCmd(self)
        self.listmngr = PlayListManager(self)
        self.play = Play(self)
        self.lirc = LircThread(self)
        self.buttons = Buttons(self)
        self.keep_run = 1
        self.ret_code = 0  # return code to command line (10 = shutdown)

        self.led.reset_leds()

        # invoke arg parser and parse config or create new config if not found
        self.settings.parse()

        # check if we can load database, create otherwise
        self.dbhandle.dbconnect()

        # restore alsa mixer settings
        self.mixer.restore_mixer()

        # load connected usb before bluetooth
        self.usb.check_new_usb()

        # initialize sound mixer
        self.play.init_mixer()

        # load latest playlist from database
        self.listmngr.load_active_playlist()

        # open cmd fifo to read commands
        self.cmd.open_fifo()

        # fire up bluetooth service
        self.rfcomm.start_server_thread()

        # start lirc thread
        self.lirc.start()

        # fire up one thread per each button
        self.buttons.start()

        # +++++++++++++++ Daemoninze +++++++++++++++ #

        self.check_pidfile()
        self.daemonize()
        self.create_pidfile()

        self.led.show_init_done()

        # +++++++++++++++ Daemon loop +++++++++++++++ #

        self.run()

        # +++++++++++++++ Finalize +++++++++++++++ #

        self.listmngr.save_active()
        self.led.cleanup()
        self.delete_pidfile()
Esempio n. 50
0
def led_on_demo():
    pin_number = 18  # edit pin number
    led = LED(rpi, pin_number)
    led.turn_on()
    sleep(2)
    led.turn_off()
Esempio n. 51
0
class ListenIn(object):
    def __init__(self, token, duration, interval, retrytime, last_uploaded_file):
        self.token = token
        self.duration = duration
        self.interval = interval
        self.retrytime = retrytime
        self.last_uploaded_file = last_uploaded_file

        self.led = LED(red=13, green=19, blue=26, initial_color='white')
        self._q = Queue()
        self.default_blink_interval = (5, 300)
        self.fast_blinking = (0.5, 500)


    def start_blinker(self):
        self._blinker_stop = Event()
        self._blinker_thread = Thread(target=self.blink_periodically)
        self._blinker_thread.start()

    def stop_blinker(self):
        self._blinker_stop.set()
        self._blinker_thread.join()

    def blink_periodically(self):
        last_blink_time = time.time()
        interval, duration = self.default_blink_interval

        while True:
            if self._blinker_stop.isSet():
                break

            try:
                interval, duration = self._q.get_nowait()
            except Empty:
                pass

            if time.time() - last_blink_time > interval:
                self.led.blink(duration=duration)
                last_blink_time = time.time()

            time.sleep(0.1)

    def write_last_uploaded_ts(self):
        try:
            tmp_file = self.last_uploaded_file + '.tmp'
            open(tmp_file, 'w').write(str(int(time.time())))
            os.rename(tmp_file, self.last_uploaded_file)
        except Exception:
            pass

    def listen(self):
        self.start_blinker()

        while True:
            try:
                logging.info('waiting for audio signal')
                self.led.set('purple')
                r = self.record_sample()
                next(r)
                logging.info('recording')
                self.led.set('red')
                sample = next(r)
                logging.info('uploading')
                self.led.set('blue')
                t0 = time.time()
                self.upload_sample(sample)
            except Exception as e:
                logging.error('%s: %s', e.__class__.__name__, e)
                self.led.set('orange')
                self._q.put(self.fast_blinking)
                time.sleep(self.retrytime)
                self._q.put(self.default_blink_interval)
            else:
                self.write_last_uploaded_ts()
                logging.info('sample recorded and uploaded, sleeping for %d seconds', self.interval)
                self.led.set('green')

                sleep_time = self.interval - (time.time() - t0)
                if sleep_time >= 0:
                    time.sleep(sleep_time)
        
    def record_sample(self):
        output_file = '/tmp/output.mp3'
        processed_file = '/tmp/processed.mp3'
        downsampled_output_file = '/tmp/downsampled.1c.8k.flac'

        for f in output_file, downsampled_output_file:
            if os.path.exists(f):
                os.unlink(f)

        rec_cmd = 'rec --no-show-progress -t mp3 -C 0 {} highpass 60 silence 1 0.1 -35d 1 2.0 -35d trim 0 {}'.format(
            output_file,
            self.duration,
        )

        rec_process = subprocess.Popen(rec_cmd.split())

        while True:
            rc = rec_process.poll()

            if rc is not None:
                break

            try:
                if os.path.getsize(output_file) > 0:
                    break
            except OSError:
                pass

            time.sleep(0.1)

        if rc is None:
            yield

        rc = rec_process.wait()

        if rc != 0:
            raise RuntimeError('failed to record: return code = {}'.format(rc))


        normalize_cmd = 'sox --norm {} {}'.format(output_file, processed_file)
        subprocess.check_call(normalize_cmd.split())

        downsample_cmd = 'sox {} -r 8000 -b 16 -c 1 {}'.format(processed_file, downsampled_output_file)
        subprocess.check_call(downsample_cmd.split())

        w = Wave(downsampled_output_file) 

        if w.length < self.duration:
            raise RuntimeError('sample duration too short ({}<{})'.format(w.length, self.duration))

        if w.is_silence:
            raise RuntimeError('sample is silent')

        if w.is_noise:
            raise RuntimeError('sample is 50hz hum')

        yield open(processed_file).read()

    def assert_sample_is_valid(self, sample_file):
        pass

    def upload_sample(self, sample):
        url = 'http://api.listenin.io/upload?token={}'.format(self.token)
        requests.post(url, data=sample, timeout=60).raise_for_status()

    def cleanup(self):
        self.stop_blinker()