Exemplo n.º 1
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")
Exemplo n.º 2
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
Exemplo n.º 3
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
Exemplo 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
Exemplo n.º 5
0
def DoDust():
  global useDust, Dust, dust, nl, STOP, STOPPED, useGPS, lastGPS
  dData = {}
  display('PM sensing',(0,0),clear=True,prt=False)
  if useDust and (useDust.mode != useDust.NORMAL):
    useDust.Normal()
    if not showSleep(secs=15,text='starting up fan'):
      display('stopped SENSING', (0,0), clear=True)
      LED.blink(5,0.3,0xff0000,True)
      return [0,0,0]
    else:
      if useGPS != None:
        display("G:%.4f/%.4f" % (lastGPS[LAT],lastGPS[LON]))
      display('measure PM')
  if useDust:
    LED.blink(3,0.1,0x005500)
    # display('%d sec sample' % sample_time,prt=False)
    try:
      STOPPED = False
      try:
        SleepThread(sample_time,'%d sec sample' % sample_time)
      except:
        STOPPED = True
        display('%d sec sample' % sample_time)
      dData = useDust.getData()
      for cnt in range(10):
        if STOPPED: break
        STOP = True
        print('waiting for thread')
        sleep(2)
      STOP = False
    except Exception as e:
      display("%s ERROR" % Dust[dust])
      print(e)
      LED.blink(3,0.1,0xff0000)
      dData = {}
    LED.blink(3,0.1,0x00ff00)

  if len(dData):
    for k in dData.keys():
        if dData[k] == None: dData[k] = 0
    try:
      if 'pm1' in dData.keys():   #  and dData['pm1'] > 0:
        display(" PM1 PM2.5 PM10", (0,0), clear=True)
        display("% 2.1f % 5.1f% 5.1f" % (dData['pm1'],dData['pm25'],dData['pm10']))
      else:
        display("ug/m3 PM2.5 PM10", (0,0), clear=True)
        display("     % 5.1f % 5.1f" % (dData['pm25'],dData['pm10']))
        dData['pm1'] = 0
    except:
      dData = {}
  if not dData:
    display("No PM values")
    LED.blink(5,0.1,0xff0000,True)
    dData = [0,0,0]
  else:
    dData = [round(dData['pm1'],1),round(dData['pm25'],1),round(dData['pm10'],1)]
    LED.off()
  return dData
Exemplo n.º 6
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
Exemplo n.º 7
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.")
Exemplo n.º 8
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)
Exemplo n.º 9
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
Exemplo n.º 10
0
import time
import logging

from led import LED_NAMES, LED
from server import Server

logging.basicConfig(level=logging.DEBUG)

if __name__ == "__main__":
    print("Initializing...")
    led_usr1 = LED(LED_NAMES.USR1)
    print("blinking 'usr1'")
    s1 = led_usr1.blink()
    led_usr2 = LED(LED_NAMES.USR2)
    print("blinking 'usr2'")
    s2 = led_usr2.blink()
    if not (s1 and s2):
        print("Initialization failed")
        exit(-1)
    Server.start_all("config.json")
    
Exemplo n.º 11
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
Exemplo n.º 12
0
grovepi.pinMode(buzzer,"OUTPUT")

while True:
    try:
        # Buzz for 1 second
        grovepi.digitalWrite(buzzer,1)
        print ('start')
        time.sleep(1)

        # Stop buzzing for 1 second and repeat
        grovepi.digitalWrite(buzzer,0)
        print ('stop')
        time.sleep(1)

    except KeyboardInterrupt:
        grovepi.digitalWrite(buzzer,0)
        break
    except IOError:
        print ("Error")



led = LED(3)
t = 0.02
d = 0.01
while t>=d:
    print t
    led.blink(100, t)
    t = t-d
Exemplo n.º 13
0
def DoMeteo():
  global useMeteo, nl, LF
  global Meteo, meteo
  global M_SDA, M_SCL
  mData = [0,0,0,0,0]; sData = ""
  if not useMeteo or not meteo: return mData

  # Measure temp oC, rel hum %, pres pHa, gas Ohm, aqi %
  LED.blink(3,0.1,0x002200,False)
  error = None
  try: 
    nr = indexBus(i2cPINs,i2c,(M_SDA,M_SCL))
    if (meteo == 4) and (not useMeteo.gas_base): # BME680
      display("AQI base: wait"); nl -= LF
    i2c[nr].init(nr, pins=i2cPINs[nr]) # SPI oled causes bus errors
    sleep(1)
    try:
      mData[TEMP] = float(useMeteo.temperature) # string '20.12'
      sData += "%4.1f " % round(mData[TEMP],1)
    except:
      mData[TEMP] = 0; error = TEMP
      sData += "  ?  "
    try:
      mData[HUM] = float(useMeteo.humidity)     # string '25'
      sData += "%2d " % round(mData[HUM])
    except:
      mData[HUM] = 0; error = HUM
      sData += " ? "
    try:
      mData[PRES] = float(useMeteo.pressure)    # string '1021.60'
      sData += "%4d " % round(mData[PRES])
    except:
      mData[PRES] = 0; error = PRES
      sData += "   ? "
    if meteo == 4: # BME680
      try:
        mData[GAS] = float(useMeteo.gas)        # Ohm 29123
        # sData += "%4.1f " % round(mData[GAS]/1000.0,1)
      except:
        mData[GAS] = 0; error = GAS
        #sData += "  ?  "
      try:
        mData[AQI] = round(float(useMeteo.AQI),1) # 0-100% ok
        sData += "%2d" % round(mData[AQI])
      except:
        mData[AQI] = 0; error = AQI
        sData += " ?"
      rectangle(0,nl,128,LF,0)
  except Exception as e:
    display("%s ERROR" % Meteo[meteo])
    print(e)
    LED.blink(5,0.1,0xff00ff,True)
    return [0,0,0,0,0]
  if error != None:
    print("no value for %s" % ['oC','RH','hPa','gas','AQI'][error])
    LED.blink(5,0.1,0xff0099,True)

  LED.off()
  nl += 6  # oled spacing
  display("  C hum%% pHa%s" % (' AQI' if mData[GAS] > 0 else ''))
  display("o",(8,-5),prt=False)
  display(sData)
  return mData # temp, hum, pres, gas, aqia
Exemplo n.º 14
0
    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 blink:
            LED.blink(1, 0.1, blink, False)
        sleep(myslp)
        if x > xe: continue
        rectangle(x, y, step, height)
        if oled: oled.show()
        x += step
    return True


try:
    # Turn off hearbeat LED
    pycom.heartbeat(False)
    display('test bar', 0, 0, True)
    if not ProgressBar(0, 44, 128, 8, 10, 0xebcf5b, 1):
        LED.blink(5, 0.3, 0xff0000, True)
    else:
        LED.blink(5, 0.3, 0x00ff00, False)
    display("MySense PyCom", 0, 0, True)
    myID = binascii.hexlify(unique_id()).decode('utf-8')
    display("s/n " + myID, 0, 16, False)
except:
    print("Failed")
from led import LED

ledYellow = LED(15, "Red")
ledYellow.blink(0.5, 3)
Exemplo n.º 16
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()