def action_state(method, loc, params, headers, conn, addr):
return httpsrv.response(
200,
ujson.dumps(
{
"unique_id": ubinascii.hexlify(
machine.unique_id()
).decode().upper(),
"micropython_version": uos.uname().version[
1:uos.uname().version.index(" ")
],
"firmware_version": __version__,
"color_id": _color_id,
"free_memory": gc.mem_free(),
"free_flash": uos.statvfs("/")[0] * uos.statvfs("/")[3],
"run_state": [
"ERROR {}".format(runner.get_error()[0])
if runner.get_error() is not None
else "",
"STOPPED",
"CODE.PY MISSING",
"CODE.PY IMPORTED",
"CODE.PY MAIN",
][runner.get_state()],
"error_traceback": [
line.strip()
for line in runner.get_error()[1].split("\n")
if line and "Traceback" not in line
]
if runner.get_error() is not None
else None, # noqa
}
),
httpsrv.CT_JSON,
)
def __init__(A, path=C, firmware_id=C):
G = firmware_id
C = path
try:
if os.uname(
).release == '1.13.0' and os.uname().version < 'v1.13-103':
raise V('MicroPython 1.13.0 cannot be stubbed')
except F:
pass
A._report = []
A.info = _info()
E.collect()
if G: A._fwid = str(G).lower()
else: A._fwid = '{family}-{ver}-{port}'.format(**A.info).lower()
A._start_free = E.mem_free()
if C:
if C.endswith(B): C = C[:-1]
else: C = get_root()
A.path = '{}/stubs/{}'.format(C, A.flat_fwid).replace('//', B)
try:
T(C + B)
except D:
pass
A.problematic = [
'upip', 'upysh', 'webrepl_setup', 'http_client', 'http_client_ssl',
'http_server', 'http_server_ssl'
]
A.excluded = [
'webrepl', '_webrepl', 'port_diag', 'example_sub_led.py',
'example_pub_button.py'
]
A.modules = []
def Status(self, data=None):
self.destroy()
self.create_window()
w = self.window
y = 10
gap = 5
height = 35
ugfx.Label(10, y, w.width() - 20, height, 'Platform: {}'.format(util.get_version()), parent=w)
y += gap + height
ugfx.Label(10, y, w.width() - 20, height, 'Release: {}'.format(uos.uname()[2]), parent=w)
y += gap + height
ugfx.Label(10, y, w.width() - 20, height, 'firmware:', parent=w)
ugfx.set_default_font('IBMPlexMono_Bold18')
y += height
ugfx.Label(10, y, w.width() - 20, height + 10, '{}'.format(uos.uname()[3]), parent=w)
ugfx.set_default_font(self.default_font)
ugfx.set_default_font('IBMPlexSans_Regular18')
self.create_status_box()
ugfx.set_default_font(self.default_font)
try:
ota_data = ota.check_version()
except ota.OtaException as e:
self.set_status('Error: {}'.format(e))
else:
if ota_data:
self.status_box.destroy()
ugfx.Label(10, 180, 200, 40, text='New: {}'.format(ota_data['version']),
parent=w)
self.btngroup = ButtonGroup(self.window, 190, 180, 110, 40, 10)
self.btngroup.add('Upgrade', self.install_ota, ota_data)
self.btngroup.end()
else:
self.set_status('Up to date')
def main():
gc.collect() # Loop runs device out of memory without this
# Uncomment to monitor RAM usage
#print('Free Memory: %sKB' % int(gc.mem_free()/1024))
# Read the eTape Sensor
water = Milone_eTape.inches()
#print('Inches of Water: %.01f' % water)
# Send the Data to Server
data = "%s,device=%s inches=%.01f" % (measurement, client_id, water)
print(data)
response = urequests.post(url,headers=headers,data=data)
#print('STATUS:', response.status_code)
if '204' in str(response.status_code): # HTTP Status 204 (No Content) indicates server successfull fulfilled request with no response content
print('InfluxDB write: Success')
print()
if 'TinyPICO' in uname().machine:
led.blink(0,255,0,ms=1500,i=1) # Green
else:
print('InfluxDB write: Failed')
if 'TinyPICO' in uname().machine:
led.solid(255,127,0) # Orange
sleep(sleep_interval)
reset()
def __init__(self, path: str = None, firmware_id: str = None):
try:
if os.uname(
).release == '1.13.0' and os.uname().version < 'v1.13-103':
raise NotImplementedError(
"MicroPython 1.13.0 cannot be stubbed")
except AttributeError:
pass
self._report = []
self.info = self._info()
if firmware_id:
self._fwid = str(firmware_id).lower()
else:
self._fwid = "{family}-{port}-{ver}".format(**self.info).lower()
self._start_free = gc.mem_free()
if path:
if path.endswith('/'):
path = path[:-1]
else:
path = self.get_root()
self.path = "{}/stubs/{}".format(path,
self.flat_fwid).replace('//', '/')
try:
self.ensure_folder(path + "/")
except OSError:
pass
self.problematic = [
"upysh", "webrepl_setup", "http_client", "http_client_ssl",
"http_server", "http_server_ssl"
]
self.excluded = [
"webrepl", "_webrepl", "port_diag", "example_sub_led.py",
"example_pub_button.py"
]
self.modules = [
'_onewire', '_thread', '_uasyncio', 'ak8963', 'apa102', 'apa106',
'array', 'binascii', 'btree', 'builtins', 'cmath', 'collections',
'crypto', 'curl', 'dht', 'display', 'ds18x20', 'errno', 'esp',
'esp32', 'flashbdev', 'framebuf', 'freesans20', 'functools', 'gc',
'gsm', 'hashlib', 'heapq', 'inisetup', 'io', 'json', 'lcd160cr',
'lcd160cr_test', 'logging', 'lwip', 'machine', 'math',
'microWebSocket', 'microWebSrv', 'microWebTemplate', 'micropython',
'mpu6500', 'mpu9250', 'neopixel', 'network', 'ntptime', 'onewire',
'os', 'pyb', 'pycom', 'pye', 'queue', 'random', 're', 'requests',
'select', 'socket', 'ssd1306', 'ssh', 'ssl', 'stm', 'struct',
'sys', 'time', 'tpcalib', 'uarray', 'uasyncio/__init__',
'uasyncio/core', 'uasyncio/event', 'uasyncio/funcs',
'uasyncio/lock', 'uasyncio/stream', 'ubinascii', 'ubluetooth',
'ucollections', 'ucrypto', 'ucryptolib', 'uctypes', 'uerrno',
'uhashlib', 'uheapq', 'uio', 'ujson', 'ulab', 'ulab/approx',
'ulab/compare', 'ulab/fft', 'ulab/filter', 'ulab/linalg',
'ulab/numerical', 'ulab/poly', 'ulab/user', 'ulab/vector',
'umachine', 'umqtt/robust', 'umqtt/simple', 'uos', 'upip',
'upip_utarfile', 'uqueue', 'urandom', 'ure', 'urequests',
'urllib/urequest', 'uselect', 'usocket', 'ussl', 'ustruct', 'usys',
'utime', 'utimeq', 'uwebsocket', 'uzlib', 'websocket',
'websocket_helper', 'writer', 'ymodem', 'zlib'
]
self.include_nested = gc.mem_free() > 3200
def __init__(self, path: str = None, firmware_id: str = None):
try:
if os.uname(
).release == "1.13.0" and os.uname().version < "v1.13-103":
raise NotImplementedError(
"MicroPython 1.13.0 cannot be stubbed")
except AttributeError:
pass
self._log = logging.getLogger("stubber")
self._report = []
self.info = _info()
gc.collect()
if firmware_id:
self._fwid = str(firmware_id).lower()
else:
self._fwid = "{family}-{ver}-{port}".format(**self.info).lower()
self._start_free = gc.mem_free() # type: ignore
if path:
if path.endswith("/"):
path = path[:-1]
else:
path = get_root()
self.path = "{}/stubs/{}".format(path,
self.flat_fwid).replace("//", "/")
self._log.debug(self.path)
try:
ensure_folder(path + "/")
except OSError:
self._log.error("error creating stub folder {}".format(path))
self.problematic = [
"upip",
"upysh",
"webrepl_setup",
"http_client",
"http_client_ssl",
"http_server",
"http_server_ssl",
]
self.excluded = [
"webrepl",
"_webrepl",
"port_diag",
"example_sub_led.py",
"example_pub_button.py",
]
# there is no option to discover modules from micropython, list is read from an external file.
self.modules = []
def do_acess_point():
global ap_if
if uname().machine == 'ESP32 module with ESP32': # Wemos ESP-WROOM-32
import network
ap_if = network.WLAN(network.AP_IF)
ap_if.active(True)
ap_if.config(essid=access_point_name, authmode=network.AUTH_OPEN)
elif uname().machine == 'WiPy with ESP32': # Wipy 2.0
import pycom
from network import WLAN
pycom.heartbeat(False)
ap_if = WLAN(mode=WLAN.AP, ssid=access_point_name)
ap_if.ifconfig(
('192.168.4.1', '255.255.255.0', '192.168.4.1', '192.168.4.1'))
def get_fram():
if uos.uname().machine.split(' ')[0][:4] == 'PYBD':
Pin.board.EN_3V3.value(1)
time.sleep(0.1) # Allow decouplers to charge
fram = FRAM(I2C(2))
print('Instantiated FRAM')
return fram
def __init__(self, ledNumber=1, brightness=100, dataPin='P11'):
"""
Params:
* ledNumber = count of LEDs
* brightness = light brightness (integer : 0 to 100%)
* dataPin = pin to connect data channel (LoPy4 only)
"""
self.ledNumber = ledNumber
self.brightness = brightness
# Prepare SPI data buffer (8 bytes for each color)
self.buf_length = self.ledNumber * 3 * 8
self.buf = bytearray(self.buf_length)
# SPI init
# Bus 0, 8MHz => 125 ns by bit, 8 clock cycle when bit transfert+2 clock cycle between each transfert
# => 125*10=1.25 us required by WS2812
if uname().sysname == 'LoPy4':
self.spi = SPI(0, SPI.MASTER, baudrate=8000000, polarity=0, phase=1, pins=(None, dataPin, None))
# Enable pull down (not working for LoPy4)
# Pin(dataPin, mode=Pin.OUT, pull=Pin.PULL_DOWN)
else: #WiPy
self.spi = SPI(0, SPI.MASTER, baudrate=8000000, polarity=0, phase=1)
# Enable pull down
# Pin('P11', mode=Pin.OUT, pull=Pin.PULL_DOWN)
# Turn LEDs off
self.show([])
def get_fram():
if uos.uname().machine.split(' ')[0][:4] == 'PYBD':
Pin.board.EN_3V3.value(1)
time.sleep(0.1) # Allow decouplers to charge
fram = FRAM(SPI(2, baudrate=25_000_000), cspins, size=512) # Change size as required
print('Instantiated FRAM')
return fram
def welcome():
pre = '|\t '
print('\n' * 2)
print(' ', end='')
print('.-v-' * 19)
print('/' + pre)
print('\\' + pre, end='')
print('Welcome to %s %s @ %s.%s' %
(cfg.package, cfg.version, cfg.hostname, cfg.domainname))
print('/' + pre)
print('\\' + pre)
print('{' + pre, end='')
print('MicroPython %s (Python %s) on the %s platform' % \
('.'.join(map(str,sys.implementation.version)), sys.version, sys.platform))
print('/' + pre, end='')
print(' (%s)' % uos.uname().version)
print('\\' + pre)
print('/' + pre, end='')
try:
print('Local time is %s, enjoy.' % date())
except:
pass
print('\\' + pre)
print('/' + pre, end='')
print(' ' * 53, '~~`')
print('\\' + pre)
print('/' + pre, end='')
print(' ... there is but only one way to death - through life.')
print('\\' + pre)
print('+', ',..,,' * 15)
print('')
print('')
print('Loaded modules: %s' % ', '.join(sorted(list(sys.modules.keys()))))
def __init__(self, pin, num_leds, address="0.0.0.0", port=8000):
self.device_name = uos.uname()[0]
self.pin = machine.Pin(pin, machine.Pin.OUT) # configure pin for leds
self.np = neopixel.NeoPixel(self.pin,
num_leds) # configure neopixel library
self.address = address
self.port = port
self.animation_map = {
"rainbow": self.rainbow,
"rainbowChase": self.rainbowChase,
"bounce": self.bounce,
"chase": self.chase,
"rgbFade": self.rgbFade,
"altColors": self.altColors,
"randomFill": self.randomFill,
"fillFromMiddle": self.fillFromMiddle,
"fillFromSides": self.fillFromSides,
"fillStrip": self.fillStrip,
"wipe": self.wipe,
"sparkle": self.sparkle,
"setStrip": self.setStrip,
"setSegment": self.setSegment,
"clear": self.clear,
}
self.running_anim = None
self.statusLED = 5
uasyncio.run(self.startupAnimation())
def get_eep():
if uos.uname().machine.split(' ')[0][:4] == 'PYBD':
Pin.board.EN_3V3.value(1)
time.sleep(0.1) # Allow decouplers to charge
eep = EEPROM(I2C(2), T24C512)
print('Instantiated EEPROM')
return eep
def __init__(self, gp_pin, channel, frequency, full_range100, pulse_min, pulse_max):
"""
:param gp_pin: GPIO pin
:channel: PWM unit
:param frequency: in Hz
:param full_range100: in deg
:param pulse_min: in µs (WiPy3.0) in Duty (for ESP32, it should be - 30)
:param pulse_max: in µs (WiPy3.0) in Duty (for ESP32, it should be - 30)
:return:
"""
# Store object properties
self.PWM_frame = frequency # in Hz
self.full_range100 = full_range100
self.pulse_min = pulse_min
self.pulse_diff = pulse_max - pulse_min
self.min_position = 0
self.max_position = 180
if (uname().sysname == 'WiPy'):
# Configure PWM timer to pin flow
self.pwm = PWM(0, frequency=self.PWM_frame)
self.servo = self.pwm.channel(channel, pin=gp_pin, duty_cycle=0.077) # initial duty cycle of 7.5%
else:
self.pwm = PWM(gp_pin, freq=self.PWM_frame)
async def get_show(server, reader, writer, querystring, body):
from template import render
from rtc import get_dict_from_rtc
uname = uos.uname()
template_context = {
'rtc_memory': repr(get_dict_from_rtc()),
'sysname': uname.sysname,
'nodename': uname.nodename,
'id':
':'.join(['%02x' % char for char in reversed(machine.unique_id())]),
'machine': uname.machine,
'release': uname.release,
'mpy_version': uname.version,
'sys_modules': ', '.join(sorted(sys.modules.keys())),
'minimal_modules': ', '.join(server.context.minimal_modules)
}
for attr_name in dir(server.context):
if attr_name.startswith('_'):
continue
value = str(getattr(server.context, attr_name))
print(attr_name, value)
template_context[attr_name] = value
await server.send_html_page(
writer,
filename='webswitch.html',
content_iterator=render(filename='http_internals.html',
context=template_context,
content_iterator=None),
)
def _send_pulse_and_wait(self):
"""
Send the pulse to trigger and listen on echo pin.
We use the method `machine.time_pulse_us()` to get the microseconds until the echo is received.
"""
self.trigger.value(0) # Stabilize the sensor
time.sleep_us(5)
self.trigger.value(1)
# Send a 10us pulse.
time.sleep_us(10)
self.trigger.value(0)
try:
if (uname().sysname == 'WiPy'):
pulse_list = pulses_get(self.echo, self.echo_timeout_us)
if (len(pulse_list) == 0):
pulse_time = -1
else:
pulse_time = pulse_list[0][1]
else:
pulse_time = time_pulse_us(self.echo, 1, self.echo_timeout_us)
return pulse_time
except OSError as ex:
if ex.args[0] == 110: # 110 = ETIMEDOUT
raise OSError('Out of range')
raise ex
def get_sms(lte_comms):
if uos.uname().sysname == 'FiPy':
print("Starting to monitor for new SMS in 60 seconds")
_thread.start_new_thread(lte_comms.receive_and_forward_to_chat, ())
gc.collect()
else:
print("Not a fipy, not checking messages.")
def __init__(self, ledNumber=1, brightness=100, dataPin='P22'):
"""
Params:
* ledNumber = count of LEDs
* brightness = light brightness (integer : 0 to 100%)
* dataPin = pin to connect data channel (LoPy only)
"""
self.ledNumber = ledNumber
self.brightness = brightness
# Prepare SPI data buffer (8 bytes for each color)
self.buf_length = self.ledNumber * 3 * 8
self.buf = bytearray(self.buf_length)
# SPI init
# Bus 0, 8MHz => 125 ns by bit, 8 clock cycle when bit transfert+2 clock cycle between each transfert
# => 125*10=1.25 us required by WS2812
if uname().sysname == 'LoPy':
self.spi = SPI(0, SPI.MASTER, baudrate=8000000, polarity=0, phase=1, pins=(None, dataPin, None))
# Enable pull down
Pin(dataPin, mode=Pin.OUT, pull=Pin.PULL_DOWN)
else: #WiPy
self.spi = SPI(0, SPI.MASTER, baudrate=8000000, polarity=0, phase=1)
# Enable pull down
Pin('GP16', mode=Pin.ALT, pull=Pin.PULL_DOWN)
# Turn LEDs off
self.show([])
def get_device():
if uos.uname().machine.split(' ')[0][:4] == 'PYBD':
Pin.board.EN_3V3.value(1)
# Adjust to suit number of chips and their wiring.
cspins = (Pin(Pin.board.Y5, Pin.OUT,
value=1), Pin(Pin.board.Y4, Pin.OUT, value=1))
flash = FLASH(SPI(2, baudrate=20_000_000), cspins, size=32768)
print('Instantiated Flash')
return flash
def get_eep(stm):
if uos.uname().machine.split(' ')[0][:4] == 'PYBD':
Pin.board.EN_3V3.value(1)
if stm:
eep = EEPROM(SPI(2, baudrate=5_000_000), cspins, 256)
else:
eep = EEPROM(SPI(2, baudrate=20_000_000), cspins)
print('Instantiated EEPROM')
return eep
async def record_wav_to_sdcard(audio_in, wav):
sreader = asyncio.StreamReader(audio_in)
# create header for WAV file and write to SD card
wav_header = create_wav_header(
SAMPLE_RATE_IN_HZ,
WAV_SAMPLE_SIZE_IN_BITS,
NUM_CHANNELS,
SAMPLE_RATE_IN_HZ * RECORD_TIME_IN_SECONDS,
)
num_bytes_written = wav.write(wav_header)
# allocate sample array
# memoryview used to reduce heap allocation
mic_samples = bytearray(10000)
mic_samples_mv = memoryview(mic_samples)
num_sample_bytes_written_to_wav = 0
# continuously read audio samples from I2S hardware
# and write them to a WAV file stored on a SD card
print("Recording size: {} bytes".format(RECORDING_SIZE_IN_BYTES))
print("========== START RECORDING ==========")
while num_sample_bytes_written_to_wav < RECORDING_SIZE_IN_BYTES:
# read samples from the I2S peripheral
num_bytes_read_from_mic = await sreader.readinto(mic_samples_mv)
# write samples to WAV file
if num_bytes_read_from_mic > 0:
num_bytes_to_write = min(
num_bytes_read_from_mic,
RECORDING_SIZE_IN_BYTES - num_sample_bytes_written_to_wav)
num_bytes_written = wav.write(mic_samples_mv[:num_bytes_to_write])
num_sample_bytes_written_to_wav += num_bytes_written
print("========== DONE RECORDING ==========")
# cleanup
wav.close()
if uos.uname().machine.find("PYBD") == 0:
uos.umount("/sd")
if uos.uname().machine.find("ESP32") == 0:
uos.umount("/sd")
sd.deinit()
audio_in.deinit()
def i2s_callback_rx(arg):
global state
global num_sample_bytes_written_to_wav
global mic_samples_mv
global num_read
if state == RECORD:
num_bytes_written = wav.write(mic_samples_mv[:num_read])
num_sample_bytes_written_to_wav += num_bytes_written
# read samples from the I2S device. This callback function
# will be called after 'mic_samples_mv' has been completely filled
# with audio samples
num_read = audio_in.readinto(mic_samples_mv)
elif state == RESUME:
state = RECORD
num_read = audio_in.readinto(mic_samples_mv)
elif state == PAUSE:
# in the PAUSE state read audio samples from the I2S device
# but do not write the samples to SD card
num_read = audio_in.readinto(mic_samples_mv)
elif state == STOP:
# create header for WAV file and write to SD card
wav_header = create_wav_header(
SAMPLE_RATE_IN_HZ,
WAV_SAMPLE_SIZE_IN_BITS,
NUM_CHANNELS,
num_sample_bytes_written_to_wav //
(WAV_SAMPLE_SIZE_IN_BYTES * NUM_CHANNELS),
)
pos = wav.seek(
0) # advance to first byte of Header section in WAV file
num_bytes_written = wav.write(wav_header)
# cleanup
wav.close()
if uos.uname().machine.find("PYBD") == 0:
uos.umount("/sd")
if uos.uname().machine.find("ESP32") == 0:
uos.umount("/sd")
sd.deinit()
audio_in.deinit()
print("Done")
else:
print("Not a valid state. State ignored")
def main():
print('=' * 45)
print()
# Read the Temperature
if 'esp32' in uname().sysname:
field1 = round(tmp36.read_temp(int(ADC_PIN), 'F'), 1)
elif 'esp8266' in uname().sysname:
field1 = round(tmp36.read_temp(0, 'F'), 1) # Only one ADC on PIN 0
print('Temperature Reading: %sF' % field1)
# Send the Data to Server
response = iot_api(server, port, client_id, field1)
if response:
print('Upload: Success')
print()
else:
print('Upload: Failed')
sleep(sleep_interval)
reset()
def read_adc(gpio_pin_number):
'''Read the Raw ADC value one time'''
if 'esp32' in uname().sysname:
# Source: https://docs.micropython.org/en/latest/esp32/quickref.html#adc-analog-to-digital-conversion
from machine import Pin
adc = ADC(Pin(gpio_pin_number)) # Pins 32-39 are valid
adc.atten(ADC.ATTN_6DB
) # 0-2V since the TMP36 data pin is min 0.1V and max 1.75V
adc.width(ADC.WIDTH_12BIT) # 0-4095 values
# millivolts = average_adc * (2000/4095) # Example: 750mV = 1535.6 * (2000/4095)
elif 'esp8266' in uname().sysname:
adc = ADC(
0
) # gpio_pin_number is ignored since there is only one ADC on ESP8266
# ADC values from 0 to 1023
# millivolts = average_adc * (3300/1023) # Example: 750mV = 232.5 * (3300/1023)
else:
print('unknown hardware')
exit(1)
return adc.read()
def print_system_info():
os_info = uos.uname()
print("os info:")
print(" node: %s" % os_info.nodename)
print(" release: %s, version: %s" % (os_info.release, os_info.version))
print(" cpu freq: %d MHz" % int(machine.freq() / (1000**2)))
print("")
# print stack and heap info
machine.info()
def dev(self):
# Device
# Meta data object.
# HA will use this to group all components that belong to the same device and prevent duplicates.
return dict(
mf = self.MANUF,
sw = uname().release + '/' + VERSION,
mdl = self.dev_name,
ids = self.uid,
name = self.ful_dev_name(),
)
def main():
gc.collect() # Loop runs device out of memory without this
#print('Free Memory: %sKB' % int(gc.mem_free()/1024))
# Send the Data to Server
data = read_sensor()
print(data)
response = urequests.post(url, headers=headers, data=data)
if '204' in str(
response.status_code
): # HTTP Status 204 (No Content) indicates server fulfilled request
print('InfluxDB write: Success')
print()
if 'TinyPICO' in uname().machine:
led.blink(0, 255, 0, ms=1500, i=1) # Green
else:
print('InfluxDB write: Failed (%s)' % (response.status_code))
if 'TinyPICO' in uname().machine:
led.solid(255, 127, 0) # Orange
sleep(sleep_interval)
reset()
def angle(self, angle100):
"""
Set timer duty cycle to specified angle
:param angle100: angle in deg * 100
:return:
"""
angle_fraction = float(angle100) / float(self.full_range100)
pulse_width = float(self.pulse_min + angle_fraction * self.pulse_diff) # in µs
if (uname().sysname == 'WiPy'):
duty_cycle = pulse_width * 100 / (1000 / self.PWM_frame) / 100
self.servo.duty_cycle(duty_cycle)
else:
self.pwm.duty(int(pulse_width))
def send_health_info(self, mqttc,ipaddr,mask):
try:
os = uos.uname()
print (os)
message = {"value": "ok","version":os.version,"ipaddress":ipaddr,"ipmask":mask,"time":self.PrintTime(self.rtc.datetime())}
mqttc.publish(self.config["board"]["system"]["topic"]["publish"]+"/" + self.config["board"]
["id"], ujson.dumps(message))
print("health "+self.config["board"]["id"]+" ok")
except BaseException as e:
print("sensors:An exception occurred during health reading")
import sys
sys.print_exception(e)
def board_info():
import sys
import uos
import machine
sw_impl = sys.implementation[0]
sw_ver = sys.implementation[1]
uname = uos.uname()
freq = machine.freq() / 1000000
print('')
print('Software: {} {}'.format(sw_impl, sw_ver) )
print('Uname: {}'.format(uname) )
print('Frequency: {} Mhz'.format(freq) )
print('WAKE Reason:', machine.reset_cause())
print('')
def main():
gc.collect(
) # Free up Heap space after each loop to avoid urequests memory leak
# Uncomment to monitor RAM usage
#print('Free Memory: %sKB' % int(gc.mem_free()/1024))
# Read the TMP36 Sensor
if adc_min is '':
temperature = round(AnalogDevices_TMP36.read_temp(int(ADC_PIN)), 1)
else:
temperature = round(
AnalogDevices_TMP36.temp_calibrated(int(ADC_PIN), int(adc_min),
int(adc_max), float(temp_min),
float(temp_max)), 1)
#print('Fahrenheit: %.01f' % temperature)
# Send the Data to Server (Try to avoid '-' and '_' characters in InfluxDB Key names)
data = "%s,clientid=%s temperature=%.01f" % (measurement, client_id,
temperature)
print(data)
response = urequests.post(url, headers=headers, data=data)
#print('STATUS:', response.status_code)
if '204' in str(
response.status_code
): # HTTP Status 204 (No Content) indicates server successfull fulfilled request with no response content
print('InfluxDB write: Success')
print()
if 'TinyPICO' in uname().machine:
led.blink(0, 255, 0, ms=1500, i=1) # Green
else:
print('InfluxDB write: Failed')
if 'TinyPICO' in uname().machine:
led.solid(255, 127, 0) # Orange
sleep(sleep_interval)
reset()
