Exemple #1
0
    def store_scan(self, scan):
        # Check if we already did a scan too recently.
        now = time.time()
        if (now - self.last_scan_time) < MIN_STORE_TIME:
            # Nothing to do.
            return
        self.last_scan_time = now

        # Seek to end of file
        self.data_file.seek(0,2)
        
        def store_info(info):
            # Store binary info.
            self.data_file.write(info)
            self.data_file.write(b"\n")
            
        store_info(b'machine-' + hex_str(machine.unique_id()))
        store_info(b'time-%d' % (now, ))
        if self.reset:
            store_info(b'reset-%d' % (machine.reset_cause()))
            self.reset = False
            
        for s in scan:
            bssid = s[1]
            strength = s[3]
            store_info(b'ap-%s-%d' % (hex_str(bssid), strength))
        store_info(b'eom')
        # Make sure data are written.
        self.data_file.flush()
def main():
	import utime, array                         # ESP stuff
	from machine import Pin, Signal

	import tphg, pm25             			    # Version 905 sensors - comment this line for stub.py
	#import stub								 # when no sensors are attached.
	import iot		          					# IOT networking
	start_time = utime.ticks_ms()				# let's track runtime (for measuring current usage)

	aq = {} 
	id = machine.unique_id()
	chipId='{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}'.format(id[0], id[1], id[2], id[3], id[4], id[5]) # make each sensor its own group

	#aq.update(analog.measure())
	#aq.update(dht11.measure())
	#aq.update(enviro.measure())
	#aq.update(ppd42.measure())
	#aq.update(tph.measure())
	aq.update(tphg.measure())
	#aq.update(stub.measure())	# when you only want the MCU and no sensors.
	# for reasons I can't explain, UART takes time to setup - so do this last? WTF.
	aq.update(pm25.measure())

	iot.init_ap(False)
	iot.init_sta(True)
	# Now let's post all
	
	iot.io_post(chipId,aq)
	#iot.io_post({"runtime": ((utime.ticks_ms() - start_time)/1000)})
	print("Runtime is:", (utime.ticks_ms() - start_time)/1000)
	sleep.init(sleep_interval)                # see you later!
Exemple #3
0
    def mqtt_subscribe(self):
        client_id = b'tom_' + ubinascii.hexlify(machine.unique_id())
        self.mqtt = MQTTClient(client_id, self.config['host'],
                               port=int(self.config['port']))

        self.mqtt.set_callback(self.mqtt_callback)
        self.mqtt.connect()
        self.mqtt.subscribe(self.config['topic'])
Exemple #4
0
 def get_machine_stats(self):
     import machine
     import ubinascii
     id = "0x{}".format(ubinascii.hexlify(machine.unique_id()).decode().upper())
     return {
         'freq': machine.freq(),
         'unique_id': id
     }
def default_remote_id():
    """generate remote id based on machine.unique_id()"""
    import uhashlib
    from ustruct import unpack
    # we compute a hash of board's unique_id, since a boards manufactured
    # closely together probably share prefix or suffix, and I don't know
    # which one. we want to avoid accidental remote_id clashes
    unique_hash = uhashlib.sha256(machine.unique_id()).digest()
    # and a 4 byte prefix of a sha256 hash is more than enough
    uint32 = unpack("I", unique_hash[:4])[0]
    # let's mask it to 26 bits
    uint26 = uint32 & (2**26 - 1)
    return uint26
Exemple #6
0
import micropython
import network
import esp
esp.osdebug(None)
import gc
gc.collect()

running = True

ssid = 'J_C'
password = '******'
mqtt_server = 'jcerasmus.ddns.net'
#EXAMPLE IP ADDRESS
#mqtt_server = '192.168.1.144'
mac_string = ubinascii.hexlify(network.WLAN().config('mac'), ':').decode()
client_id = ubinascii.hexlify(machine.unique_id())
topic_sub = b'/down/' + mac_string
topic_pub = b'/up/' + mac_string

print("My MAC is: " + mac_string)

last_message = 0
message_interval = 1

station = network.WLAN(network.STA_IF)

station.active(True)
station.connect(ssid, password)

while station.isconnected() == False:
    print("We are waiting for WIFI connection")
Exemple #7
0
def generate_key():
    id_str = ubinascii.hexlify(machine.unique_id()).decode('utf-8')
    id_str = id_str * 5
    id_str = id_str[:32]
    return id_str
Exemple #8
0
def get_unique_id():
  id = machine.unique_id()
  id = ("000000" + hex((id[3] << 16) | (id[4] << 8) | id[5])[2:])[-6:]
  return id
    audio.recorder_deinit()


def play_wave(freq):
    global P8
    P8 = MPythonPin(8, PinMode.PWM)
    P8.write_analog(512, freq)


def stop_wave():
    global P8
    P8.pwm.deinit()


# MAC id
machine_id = ubinascii.hexlify(machine.unique_id()).decode().upper()


# a,b按键中断处理函数:蜂鸣器响
def btn_A_irq(_):
    if button_a.value() == 0:
        music.pitch(1000)
    else:
        music.stop()


def btn_B_irq(_):
    if button_b.value() == 0:
        music.pitch(1000)
    else:
        music.stop()
Exemple #10
0
def uid():
    from machine import unique_id
    from ubinascii import hexlify
    return hexlify(unique_id()).decode("utf-8").upper()
Exemple #11
0
'''

import machine
import os
from network import WLAN

mch = os.uname().machine
if not 'LaunchPad' in mch and not'WiPy' in mch:
    raise Exception('Board not supported!')

wifi = WLAN()

print(machine)
machine.idle()
print(machine.freq() == (80000000,))
print(machine.unique_id() == wifi.mac())

machine.main('main.py')

rand_nums = []
for i in range(0, 100):
    rand = machine.rng()
    if rand not in rand_nums:
        rand_nums.append(rand)
    else:
        print('RNG number repeated')
        break

for i in range(0, 10):
    machine.idle()
Exemple #12
0
    def assemble(self, sensor_period):
        name = machine.unique_id()
        assert len(name) == 6
        task_num = len(self._tasks)
        # we have a start-character, '#'
        start_char = 1
        # after that start character, we follow up with the of the
        # total message.  It's the length in one byte, followd by the
        # XOR of that length.  The reason for this verified storage is
        # that we need a reliable way of syncing after the start-char
        # to the expected number of bytes
        message_length = 2
        # Then comes the unique ID of the device, 6 bytes
        name_length = len(name)
        # After that, the task count and descriptor. The descriptor specifies
        # the attached sensors/tasks, that all have a specific byte-size.
        # Each sensor is described as a nibble, with the first in the lowest
        # nibble of the first byte, second upper nibble, etc.
        task_count = 1
        descriptor_length = task_num // 2 + task_num % 2
        # it follows the payload, the size is the accumulated size of
        # all tasks' storage needs
        payload_size = sum(buffer_size
                           for _, _, _, buffer_size, _ in self._tasks)
        # the final checksum is just all bytes so far summed up as uint8_t
        checksum_size = 1
        buffer_size = start_char + message_length + name_length + \
          task_count + descriptor_length + \
          payload_size + checksum_size

        name_start = start_char + message_length
        descriptor_byte_count_offset = start_char + \
            message_length + name_length
        descriptor_start = descriptor_byte_count_offset + task_count
        payload_start = descriptor_start + descriptor_length
        if payload_start % 4:
            padding = 4 - (payload_start % 4)
            payload_start += padding
            buffer_size += padding
        self.buffer = bytearray(buffer_size)
        self.buffer[0] = ord(b'#')
        self.buffer[1] = buffer_size
        self.buffer[2] = 0xff ^ buffer_size
        self.buffer[name_start:name_start + name_length] = name
        self.buffer[descriptor_byte_count_offset] = task_num

        descriptor = memoryview(
            self.buffer)[descriptor_start:descriptor_start + descriptor_length]
        newjoy.init(sensor_period, self.buffer)
        osc_payload_start = task_byte_offset = payload_start

        for i, (bus, address, task, task_size,
                busno) in enumerate(self._tasks):
            self._osc_spec.append((
                osc_payload_start,
                self.TASK_SPEC[task],
            ))
            self._osc_descriptor[busno] += self.TASK_ID[task]
            offset = i // 2
            current = descriptor[offset]
            current |= task << (4 * (i % 2))
            descriptor[offset] = current
            newjoy.add_task(bus, address, task, task_byte_offset)
            task_byte_offset += task_size
            osc_payload_start += task_size

        osc_descriptor = ""
        for busno, devices in sorted(self._osc_descriptor.items()):
            if devices:
                osc_descriptor += "{}{}".format(busno, devices)
        self._osc_descriptor = osc_descriptor
Exemple #13
0
"""

import machine
import ubinascii
import time
import dht
from machine import Pin
from umqtt.simple import MQTTClient

d = dht.DHT11(Pin(2))

config = {
    'broker': 'io.adafruit.com',
    'user': '******',
    'key': '你的AIO KEY',
    'id': 'room/' + ubinascii.hexlify(machine.unique_id()).decode(),
    'topic_temp': b'poushen/feeds/temperature',
    'topic_humi': b'poushen/feeds/humidity'
}


def publish(topic, data):
    client = MQTTClient(client_id=config['id'],
                        server=config['broker'],
                        user=config['user'],
                        password=config['key'])

    client.connect()
    client.publish(topic, data.encode())
    time.sleep(1)
    client.disconnect()
Exemple #14
0
import machine
import ubinascii

MY_ID = str(ubinascii.hexlify(machine.unique_id()), 'utf-8')

AP_PIN = 35 # ground this pin to activate AP mode on reset
CFG_NAME = '_config' # store wifi ssid/pswd and tWeb ip:port
TS_NAME = '_timestamp' # timestamp for ntp
DATA_FILE = '_data' # measuring storage
DATA_LENGTH = 64 # number of records to store
CONNECT_WAIT = 10 # wait seconds to connect
LVL_PIN = 34 # 220k/220k to power/ground and middle node to check power level
LVL_LOWPWR = 1880 # low power level ~= 3.15V
LVL_SUNPIN = 33 # Solar battery level pin (33) or None
LED_PIN = 5
I2CSCL_PIN = 22
I2CSDA_PIN = 21
I2C_FREQ = 10000

DEEP_SLEEP = 900 # seconds
FAKE_SLEEP = 0 # 1 -- no really go to deep sleep (for debug only)

NTP_SYNC_PERIOD = DEEP_SLEEP*6 # ntp sync interval

POSITIONING = 'YES' # NO -- no positioning

# positioning with mg995 servo
TZ = 1 # timezone difference with UTC in hours, could be float. NOT SUMMER TIME!
AZ_PIN = 25
ALT_PIN = 27
from machine import unique_id
from utime import sleep, ticks_ms, ticks_diff

def tdiff():
    new_semantics = ticks_diff(2, 1) == 1
    def func(old, new):
        nonlocal new_semantics
        if new_semantics:
            return ticks_diff(new, old)
        return ticks_diff(old, new)
    return func

ticksdiff = tdiff()

SERVER = "192.168.0.23"
CLIENT_ID = ubinascii.hexlify(unique_id())
TOPIC = b"led"
QOS = 1

t = 0
maxt = 0
mint = 5000


def sub_cb(topic, msg):
    global t, maxt, mint
    dt = ticksdiff(t, ticks_ms())
    print('echo received in {} ms'.format(dt))
    print((topic, msg))
    maxt = max(maxt, dt)
    mint = min(mint, dt)
Exemple #16
0
client.connect()
time.sleep(10)
uart = UART(1, 9600, pins=("G28","G22"), timeout_chars=2000)
i2c = I2C(0, I2C.MASTER, baudrate=100000)
sensor = sht31.SHT31(i2c, addr=0x44)
rtc = machine.RTC()
rtc.ntp_sync("tw.pool.ntp.org", 3600)
sd = SD()
os.mount(sd, '/sd')

# check the content
os.listdir('/sd')

# try some standard file operations
deviceid = binascii.hexlify(machine.unique_id())
p_out = Pin('P3', mode=Pin.OUT)
p_out1 = Pin('P22', mode=Pin.OUT)
def axis():
    i2c.writeto_mem(29, 0x2A, bytes([0x00]))
    i2c.writeto_mem(29, 0x2A, bytes([0x01]))
    i2c.writeto_mem(29, 0x0E, bytes([0x00]))
    data = i2c.readfrom_mem(29, 0x00, 7)

    xAccl = (data[1] * 256 + data[2]) / 16
    if xAccl > 2047 :
        xAccl -= 4096

    yAccl = (data[3] * 256 + data[4]) / 16
    if yAccl > 2047 :
        yAccl -= 4096
Exemple #17
0
#---End Wifi Config---

from machine import Pin

led = Pin(2, Pin.OUT, value=1)

#---MQTT Sending---

from time import sleep_ms
from ubinascii import hexlify
from machine import unique_id
#import socket
from umqtt import MQTTClient

SERVER = "192.168.0.101"
CLIENT_ID = hexlify(unique_id())
TOPIC1 = b"/sensor1/tem"
TOPIC2 = b"/sensor1/hum"
TOPIC3 = b"/sensor1/led"

def envioMQTT(server=SERVER, topic="/foo", dato=None):
    try:
        c = MQTTClient(CLIENT_ID, server)
        c.connect()
        c.publish(topic, dato)
        sleep_ms(200)
        c.disconnect()
        #led.value(1)
    except Exception as e:
        pass
        #led.value(0)
Exemple #18
0
from umqtt.simple import MQTTClient
import machine
import utime
import ubinascii
import p9813
from machine import Pin

from config import SERVER, COMMAND_TOPIC, STATE_TOPIC, AVAILABILITY_TOPIC

LED = machine.Pin(2, machine.Pin.OUT, value=1)

CLIENT = None
CLIENT_ID = ubinascii.hexlify(machine.unique_id())

pin_clk = Pin(5, Pin.OUT)
pin_data = Pin(4, Pin.OUT)

num_leds = 1
chain = p9813.P9813(pin_clk, pin_data, num_leds)


def new_msg(topic, msg):

    print("Received {}".format(msg))

    if msg == b"on":
        LED.value(0)
        chain[0] = (0, 0, 0)
        chain.write()
        CLIENT.publish(STATE_TOPIC, "on")
    elif msg == b"off":
Exemple #19
0
# $Id: MySense.py,v 2.8 2018/05/04 14:55:41 teus Exp teus $
#
__version__ = "0." + "$Revision: 2.8 $"[11:-2]
__license__ = 'GPLV4'

from time import sleep, time
from time import localtime, timezone
from machine import Pin # user button/led
from machine import unique_id
import binascii
import pycom
import struct
from micropython import const
PyCom = 'PyCom'
# identity PyCom SN
myID = binascii.hexlify(unique_id()).decode('utf-8')
# Turn off hearbeat LED
pycom.heartbeat(False)

try:
  from Config import Network
except:
  pass
if not Network: raise OSError("No network config found")
if Network == 'TTN':
  PyCom = 'LoPy'
  try:
    from Config import dev_eui, app_eui, app_key
    from lora import LORA
    lora = None
  except:
Exemple #20
0
def main():

    # Enable automatic garbage collector
    gc.enable()

    if machine.reset_cause() == machine.DEEPSLEEP_RESET:
        print('wake from deep sleep')
        hard_reset = False
    else:
        hard_reset = True
        print('wake from hard reset')

    chipid = hexlify(machine.unique_id())

    # Read from file the whole configuration
    config.read_config()

    # Get WiFi defaults and connect
    ssid = config.get_config('ssid')
    pwd = config.get_config('pwd')
    interface = do_connect(ssid, pwd, network.STA_IF, hard_reset)

    # Turn on Access Point only with passw
    apssid = 'YoT-%s' % bytes.decode(chipid)
    appwd = config.get_config('appwd')
    if hard_reset:
        ap_interface = do_connect(apssid, appwd, network.AP_IF)

    if not interface and not ap_interface:
        print('Restart 10"')
        time.sleep(10.0)
        machine.reset()
        return

    # Set Parameters in configuration
    (address, mask, gateway, dns) = interface.ifconfig()
    config.set_config('address', address)
    config.set_config('mask', mask)
    config.set_config('gateway', gateway)
    config.set_config('dns', dns)
    config.set_config('mac', hexlify(interface.config('mac'), ':'))
    config.set_config('chipid', chipid)

    # Set Time RTC
    from ntptime import settime
    try:
        settime()
        (y, m, d, h, mm, s, c, u) = time.localtime()
        starttime = '%d-%d-%d %d:%d:%d UTC' % (y, m, d, h, mm, s)
    except:
        starttime = '2016-01-01 00:00:00'
        print('Cannot set time')

    # Set hostname
    interface.config(dhcp_hostname=chipid)
    config.set_config('hostname', interface.config('dhcp_hostname'))

    # We will save new configuration only at powerup
    if hard_reset:
        config.set_config('starttime', starttime)
        config.save_config()

    # Free some memory
    ssid = pwd = None
    apssid = appwd = None
    address = mask = gateway = dns = None
    gc.collect()

    # The application hook
    from application import application
    try:
        application(interface)
    except KeyboardInterrupt:
        pass
    except Exception as e:
        print(e)

    # Restart
    print('Restarting')
    time.sleep(5.0)

    machine.reset()
import utime
from machine import I2C, Pin, UART, unique_id
import neopixel, machine


id = unique_id()
chipId='{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}'.format(id[0], id[1], id[2], id[3], id[4], id[5])
print('chipId shows: ', chipId)
i2c = machine.I2C(scl=Pin(22), sda=Pin(21))
print('i2c bus shows: ', i2c.scan())
uart2=UART(1,rx=26,tx=27,baudrate=9600)
uart1=UART(2,rx=0,tx=2,baudrate=9600)
utime.sleep(2)
print('uart1 shows:', uart1.read(32))
print('uart2 shows:', uart2.read(32))
RED = (255,0,0); GREEN = (0,255,0); BLUE = (0,0,255)
colors = [RED, GREEN, BLUE]
np = neopixel.NeoPixel(Pin(12), 1)
for color in colors:
	np[0] = color
	np.write()
	utime.sleep(1)
Exemple #22
0
""" LoPy LoRaWAN Nano Gateway configuration options """

import machine
import ubinascii

WIFI_MAC = ubinascii.hexlify(machine.unique_id()).upper()
# Set  the Gateway ID to be the first 3 bytes of MAC address + 'FFFE' + last 3 bytes of MAC address
GATEWAY_ID = WIFI_MAC[:6] + "FFFE" + WIFI_MAC[6:12]

SERVER = 'router.eu.thethings.network'
PORT = 1700

NTP = "pool.ntp.org"
NTP_PERIOD_S = 3600

WIFI_SSID = 'my-wifi'
WIFI_PASS = '******'

# for EU868
LORA_FREQUENCY = 868100000
LORA_GW_DR = "SF7BW125" # DR_5
LORA_NODE_DR = 5

# for US915
# LORA_FREQUENCY = 903900000
# LORA_GW_DR = "SF7BW125" # DR_3
# LORA_NODE_DR = 3
import machine
import ubinascii

led = Pin(16, Pin.OUT)
msg1 = " "
CONFIG = {

    # Configuration details of the MQTT broker
    "MQTT_BROKER": "test.mosquitto.org",
    "USER": "",
    "PASSWORD": "",
    "PORT": 1883,
    "TOPIC": b"test",

    # unique identifier of the chip
    "CLIENT_ID": b"esp8266_" + ubinascii.hexlify(machine.unique_id())
}


def settimeout(duration):

    pass


station = network.WLAN(network.STA_IF)

station.active(True)

station.connect("sandeep", "22122012")

while (not (station.isconnected())):
Exemple #24
0
 def get_machine_stats(self):
     import machine
     import ubinascii
     id = "0x{}".format(
         ubinascii.hexlify(machine.unique_id()).decode().upper())
     return {'freq': machine.freq(), 'unique_id': id}
Exemple #25
0
        print("Sending sensor data")
        result = th.read()
        while not result.is_valid():
            time.sleep(.5)
            result = th.read()

        client.publish(topic_pub,'{"fipy_nc_sensor": {"dht temp":' + str(result.temperature) +
                                                ',"dht RH":' + str(result.humidity) +
                          '}}')
        print('Sensor data sent ..')
        blink_led()
        client.check_msg()

    except (NameError, ValueError, TypeError) as err:
        print('Failed to send!', err)

topic_pub = 'nenad/home-sens/'
topic_sub = 'nenad/home-sens/control'
broker_url = 'sjolab.lnu.se'
client_name = ubinascii.hexlify(hashlib.md5(machine.unique_id()).digest()) # create a md5 hash of the pycom WLAN mac
print('client_name:',client_name)

client = MQTTClient(client_name, broker_url, user=config['user_mqtt'], password=config['pass_mqtt'], keepalive=600)

client.set_callback(sub_cb)
client.connect()
client.subscribe(topic_sub)


_thread.start_new_thread(interval_send,[30])
Exemple #26
0
import machine

# if there are multiple u2if connected, we must specify its serial number by this command before using it.
# Test with your id (use machine_info.py test program to get it)
machine.select_interface("0xE66038B713644F31")

print('S/N: %s' % machine.unique_id())
print('V/N: %s' % machine.firmware_version())
    networkUtils.connectToNetwork(nc.wifi_network, nc.wifi_password)

    print("Connecting to Mqtt...")

    client = MQTTClient(client_id=nc.mqtt_client,
                        server=nc.mqtt_server,
                        user=nc.mqtt_user,
                        password=nc.mqtt_password,
                        ssl=False)
    client.connect()

    print("Connected")

    return client


# ------ Main script execution starts here ------

gc.collect()

client_id = b"receiver_{}".format(ubinascii.hexlify(machine.unique_id()))
topic = b'temperature'

client = connect()

while True:
    try:
        client.check_msg()
        time.sleep(1)
    except Exception as e:
        client = connect()
Exemple #28
0
            pass
    print('Network configuration:', sta_if.ifconfig())

   
# main
# connecting to local LAN    
do_connect()

#config mqtt change SERVER, USER, PASSWORD and TOPIC to mach your own data
SERVER = "192.168.20.xxx"
PORT = 1883
USER = "******"
PASSWORD = "******"
TOPIC = b'kapgdom/Meteo' # change it to match your desire topic
#CLIENT_ID = ubinascii.hexlify(machine.unique_id())
CLIENT_ID = machine.unique_id()
keepalive = 60 
c = MQTTClient(CLIENT_ID, server=SERVER, port=PORT, user=USER, password=PASSWORD, keepalive=keepalive)

###pinScl      = 22  #ESP8266 GPIO5 (D1)
###pinSda      = 18  #ESP8266 GPIO4 (D2)
addrOled    = 60  #0x3c
addrBME280  = 118 #0x76
hSize       = 64  # display heigh in pixels
wSize       = 128 # display width in pixels

oledIsConnected = False
bmeIsConnected  = False
    
# initializing I2C bus
i2c = machine.I2C(scl=machine.Pin(5), sda=machine.Pin(4))
Exemple #29
0
def get_eui():
    id = ubinascii.hexlify(machine.unique_id()).decode()
    return id  #mac2eui(id)
Exemple #30
0
main.py
read temperature from ADC pin and publish to mqtt
"""

import machine
import math
import network
import time
import ubinascii
import uos
from umqtt.simple import MQTTClient

motd = "2018-11-24 bbq temperature"

broker = 'jarvis'
client_id = 'esp8266_'+str(ubinascii.hexlify(machine.unique_id()), 'utf-8')
print("client_id = "+client_id)
topic = 'strip/' + client_id
client = MQTTClient(topic, broker)
print("listening to ", broker, " for ", topic)

adc = machine.ADC(0)

def time_check():
    publish("time check")
    client.check_msg()
    try:
        ntptime.settime()
    except:
        print(".")
Exemple #31
0
    if wifi.is_connected():
        # 5.1. Send Specific Gravity data & battery level by MQTT
        if send_data_to_mqtt:
            from mqtt_client import MQTT
            hydrometer_dict = {
                'temperature': temp,
                'sg': sg,
                'plato': plato,
                'battery': battery_voltage
            }
            mqtt_data = ujson.dumps(hydrometer_dict)
            client = MQTT(settings)
            client.publish(mqtt_data)
        # 5.2. Send Specific Gravity data & battery level to Fermenter ESP32 by HTTP
        else:
            machine_id = int.from_bytes(machine.unique_id(), 'big')
            hydrometer_dict = {
                'name': settings.get('apSsid'),
                'ID': machine_id,
                'temperature': temp,
                'angle': tilt,
                'battery': battery_voltage,
                'fahrenheit': round(temp * 1.8 + 32, 1),
                'currentGravity': sg,
                'currentPlato': plato,
                'batteryLevel': battery_percent,
                'updateIntervalMs': int(settings['deepSleepIntervalMs'])
            }

            host = settings['fermenterAp']['host']
            api = settings['fermenterAp']['api']
Exemple #32
0
import utime
print('main.py: Press CTRL+C to drop to REPL...')
utime.sleep(3)

from machine import reset, deepsleep
import mqtt
import SparkFun_TMP102 as tmp102

sleep_interval = 20  # Seconds
sleep_type = 'normal'  # normal or deep

# Get Unique Client ID
from ubinascii import hexlify
from machine import unique_id
client_id = hexlify(unique_id()).decode(
    'utf-8')  # String with Unique Client ID

# Get MQTT Broker IP from key_store.db
import key_store
broker = key_store.get('mqtt_broker')
topic = 'devices/' + client_id


def main():
    # Read Timestamp and Data
    timestamp = utime.time()  # Epoch UTC
    temperature = round(tmp102.read_temp('F'), 1)

    # Send Data to MQTT Broker
    mqtt.publish(broker, topic + '/temp/value', str(temperature))
Exemple #33
0
def mac():
    mac=ubinascii.hexlify(machine.unique_id(),':').decode()
    mac=mac.replace(":","")
    return(mac)
Exemple #34
0
from Blocky.MQTT import *
from Blocky.Indicator import indicator
from machine import unique_id, reset
from binascii import hexlify
import gc
from time import sleep_ms
from Blocky.Timer import *
from ujson import dumps, loads
#import uasyncio as asyncio
import Blocky.uasyncio as asyncio
from Blocky.asyn import cancellable, Cancellable
BROKER = 'broker.getblocky.com'
CHIP_ID = hexlify(unique_id()).decode('ascii')
from machine import Timer, Pin
from Blocky.Global import flag_UPCODE


class Network:
    def __init__(self):
        self.state = 0
        self.has_msg = False
        self.topic = ''
        self.msg = ''
        self.message_handlers = {}
        self.retry = 0
        self.echo = []
        from json import loads
        self.config = loads(open('config.json', 'r').read())
        self.mqtt = MQTTClient(CHIP_ID, BROKER, 0, CHIP_ID,
                               self.config['auth_key'], 1883)
        self.sysPrefix = self.config.get('auth_key') + '/sys/' + CHIP_ID + '/'
Exemple #35
0
""" LoPy LoRaWAN Nano Gateway configuration options """

import machine
import ubinascii

WIFI_MAC = ubinascii.hexlify(machine.unique_id()).upper()
# Set  the Gateway ID to be the first 3 bytes of MAC address + 'FFFE' + last 3 bytes of MAC address
GATEWAY_ID = WIFI_MAC[:6] + "FFFE" + WIFI_MAC[6:12]

SERVER = 'lora.campusiot.imag.fr'
PORT = 1700

NTP = "pool.ntp.org"
NTP_PERIOD_S = 3600

WIFI_SSID = 'campusiot'
WIFI_PASS = '******'

# for EU868
LORA_FREQUENCY = 868300000
#LORA_FREQUENCY = 868500000
#LORA_FREQUENCY = 868700000
LORA_GW_DR = "SF7BW125"  # DR_5
LORA_NODE_DR = 5

# for US915
# LORA_FREQUENCY = 903900000
# LORA_GW_DR = "SF7BW125" # DR_3
# LORA_NODE_DR = 3
Exemple #36
0
# Wireless network
WIFI_SSID = "LANCOMBEIA"
WIFI_PASS = "******"

#  Use on-board sensors
py = Pysense()
mp = MPL3115A2(py, mode=ALTITUDE)  # Returns height in meters.
mpp = MPL3115A2(py, mode=PRESSURE)  # Returns pressure in Pa.
si = SI7006A20(py)  # Returns temperature in deg C and relative humidity RH
lt = LTR329ALS01(py)  # Returns blue and red light intensity in lux
# li = LIS2HH12(py)

# MQTT configuration
AIO_SERVER = "mqtt.beia-telemetrie.ro"
AIO_PORT = 1883
AIO_CLIENT_ID = ubinascii.hexlify(machine.unique_id())  # Can be anything

wlan = WLAN(mode=WLAN.STA)
wlan.connect(WIFI_SSID, auth=(WLAN.WPA2, WIFI_PASS), timeout=5000)

while not wlan.isconnected():
    machine.idle()

print("Connected to Wifi\n")
client = MQTTClient(AIO_CLIENT_ID, AIO_SERVER, AIO_PORT)
client.connect()

while True:
    temperature = mp.temperature()
    altitude = mp.altitude()
    pressure = mpp.pressure()
Exemple #37
0
class WebApp:

    PRODUCT_NAME = "smartsensor"
    DIR = "./"
    ID = str(ubinascii.hexlify(machine.unique_id()).decode('utf-8'))
    RETRIES = 3
    BROKER = '192.168.0.103'
    PORT = 1883
    ApCfg = {"ssid": "SmartSensor-" + ID, "pwd": "mato", "ip": "192.168.0.200"}

    Time = None
    NetCon = None

    WebserverInterval = const(1)
    WebpageTitle = "SmartSensor - WiFi instellingen"

    Webpage = """<html><head>
        <title>""" + WebpageTitle + """</title>
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <link rel="icon" href="data:,">
        <style>html{font-family: Helvetica; display:inline-block; margin: 0px auto; text-align: center;}
        h1{color: #0F3376; padding: 2vh;}p{font-size: 1.5rem;}.button{display: inline-block; background-color: #e7bd3b; border: none;
        border-radius: 4px; color: white; padding: 16px 40px; text-decoration: none; font-size: 30px; margin: 2px; cursor: pointer;}
        .button2{background-color: #4286f4;}
        </style>
        </head>
        <body> <h1>""" + WebpageTitle + """</h1>
        <h2>Sensor ID: """ + ID + """</h2>
        <form action="/wifi_settings.php">
        Netwerk naam (SSID): <input type="text" name="ssid" value=""><br>
        Wachtwoord:          <input type="password" name="pwd" value=""><br>
        <input type="submit" value="Opslaan">
        </form>
        </body>
        </html>"""

    Ssid = None
    Pwd = None

    def __init__(self, netcon_obj):

        # Create objects.
        self.Time = SystemTime.InstanceGet()
        WebApp.NetCon = netcon_obj
        self.Scheduler = ServiceScheduler()

    def Setup(self):
        # Create LED driver instances.
        self.LedRed = Led(Pins.CFG_HW_PIN_LED_RED)
        self.LedGreen = Led(Pins.CFG_HW_PIN_LED_GREEN)
        self.LedBlue = Led(Pins.CFG_HW_PIN_LED_BLUE)

        wlan_ap = WLAN(network.AP_IF)
        self.NetCon.WlanInterface(wlan_ap, NetCon.MODE_ACCESS_POINT)

        self.Webserver = Webserver(self.Webpage)

        self.Webserver.RegisterQueryHandle('ssid', WebApp.QueryHandleWifiSsid)
        self.Webserver.RegisterQueryHandle('pwd', WebApp.QueryHandleWifiPwd)

        self.Webserver.SvcDependencies(
            {self.NetCon: Service.DEP_TYPE_RUN_ALWAYS_BEFORE_INIT})

        self.Scheduler.ServiceRegister(self.NetCon)
        self.Scheduler.ServiceRegister(self.Webserver)

        self.Webserver.SvcIntervalSet(self.WebserverInterval)

    def Reset(self):
        return

    def Run(self):
        self.Scheduler.Run()

    @staticmethod
    def QueryHandleWifiSsid(query, value):
        print("{}:{}".format(query, value))
        WebApp.Ssid = value
        if WebApp.Pwd is not None:
            WebApp.SaveAndReset()

    @staticmethod
    def QueryHandleWifiPwd(query, value):
        print("{}:{}".format(query, value))
        WebApp.Pwd = value
        if WebApp.Ssid is not None:
            WebApp.SaveAndReset()

    @staticmethod
    def SaveAndReset():
        WebApp.NetCon.StationSettingsStore(WebApp.Ssid, WebApp.Pwd)
        WebApp.NetCon.AccessPointStop()
        utime.sleep(1)
        machine.reset()
Exemple #38
0
import machine
import time
import network
import socket
import ubinascii
import json
from umqtt.robust import MQTTClient

NETWORK_CONNECT_TIMEOUT = 60  #seconds
DEV_ID = "uPy-{0}".format(
    ubinascii.hexlify(machine.unique_id()).decode('utf-8'))

# TODO implement settings file for WIFI, MQTT etc.
# enable settings edit after reset button pressed

# you can put multiple networks here,
# device will try to connect to reachable ones
MY_NETS = {
    #"your_net1": "password1",
    #"your_net2": "password2",
}

print("sleep at the beginning...")
time.sleep(1)

led = machine.Pin(2, machine.Pin.OUT, value=1)
led.low()  # blue led on ESP8266 module is reversed
mqtt_server = "10.0.0.17"  # your MQTT server
topic = "/socket/uPy/" + DEV_ID

# button needs to be pulled down with 1kR
Exemple #39
0
            str(voc) + ',"bmp P":' + str(bmp_P) + ',"bmp temp":' + str(bmp_T) +
            ',"dht temp":' + str(dht_T) + ',"dht RH":' + str(dht_RH) + '}}')
        print('Sensor data sent ..')
        blink_led()

    except (NameError, ValueError, TypeError):
        print('Failed to send!')


# topic = 'testtopic7891/1'
# broker_url = 'broker.hivemq.com' # HiveMQ can be used for testing, open broker
topic_pub = 'devices/office-sens/'
topic_sub = 'devices/office-sens/control'
broker_url = 'sjolab.lnu.se'
client_name = ubinascii.hexlify(hashlib.md5(
    machine.unique_id()).digest())  # create a md5 hash of the pycom WLAN mac

c = MQTTClient(client_name,
               broker_url,
               user=config['user_mqtt'],
               password=config['pass_mqtt'])
c.set_callback(sub_cb)
c.connect()
c.subscribe(topic_sub)

# not used at the moment in this code. But - if you want to have something sent
# back to the device run this function in a loop (or in a thread)

# def listen_command():
#     while True:
#         if True:
Exemple #40
0
def get_machine_guid():
    return hexlify(unique_id())
Exemple #41
0
# single led rgb handler
import wifi
import machine
from machine import Pin, PWM
import time
import ubinascii
from umqtt.simple import MQTTClient

import config
# make unique
config.mqtt_client_id += b"_" + ubinascii.hexlify(machine.unique_id())

state_topic = config.mqtt_topic + b"/status"
command_topic = config.mqtt_topic + b"/set"
brightness_state_topic = config.mqtt_topic + b'/brightness/status'
brightness_command_topic = config.mqtt_topic + b'/brightness/set'
rgb_state_topic = config.mqtt_topic + b'/rgb/status'
rgb_command_topic = config.mqtt_topic + b'/rgb/set'

light_is_on = False
brightness = 0
last_rgb = (0, 0, 0)

current_rgb = (0, 0, 0)

green_pin = PWM(Pin(2))
red_pin = PWM(Pin(0))
blue_pin = PWM(Pin(4))

OVERFLOW = 1000
import time
from umqtt.simple import MQTTClient
import json
import ubinascii
import machine

client_id = 'esp8266-light' + ubinascii.hexlify(
    machine.unique_id()).decode('utf-8')
esp8266_set = "home/controller/woonkamer/gordijn_lang"
command_topic = 'home/woonkamer/gordijn_lang/set'
state_topic = 'home/woonkamer/gordijn_lang'

mqtt_server_ip = '192.168.1.10'
mqtt_server_port = 1883
retries = 0
max_retries = 86400  # one day


class led_pwm():
    def __init__(self, pin):
        if pin not in (
                0,
                2,
                4,
                5,
                12,
                13,
                14,
                15,
        ):
            raise ValueError("pin must be 0, 2, 4, 5, 12, 13, 14, or 15")
from mqtt import MQTTClient
import machine
import time
import ubinascii
from machine import Timer

CLIENT_ID = ubinascii.hexlify(machine.unique_id())
SERVER = "test.mosquitto.org"
#SERVER = "broker.hivemq.org"
PORT = 1883

def push_heartbeat():
    c_mqtt.connect()
    c_mqtt.publish(b"mhermans/heartbeat", b'1')
    c_mqtt.disconnect()

global c_mqtt
c_mqtt = MQTTClient(client_id = CLIENT_ID, server = SERVER, port = PORT)

while True:
    c_mqtt.check_msg()


# main loop
# pub: heartbeat every 5sec.
# sub: print every msg immediatly 
import network   # For WiFI connection
from robust import MQTTClient
from ubinascii import hexlify
from machine import unique_id

# Change the file names from where to read configuration parameters
AP_FILENAME = "ap.txt"
WIFI_FILENAME = "wifi.txt"
MQTT_FILENAME = "mqtt.txt"
info = None

ID = hexlify(unique_id())
AP = network.WLAN(network.AP_IF)
wlan = network.WLAN(network.STA_IF)

mqttActive = False


def readFile(filename):
    f = open(filename, 'r')
    text = f.read().split('\r\n')
    f.close()
    info = {}
    for i in text:
        if len(i) > 0 and i[0] != '#':
            info[i.split('=')[0]] = i.split('=')[1]
    return info


# Reads configuration parameteres from a text file and sets the access point accordingly.
# Bool arg, to turn off or on.