LoraWAN AC Current Sensor

# main.py

import machine
import re
import time
import json
import sys
import struct
from hct21 import HCT21
import io
import os
from machine import ADC, Pin, RTC


# return number of days in a month
def days_in_month(month, year):
    if month == 2:
        if year % 4 == 0:
            return 29
        else:
            return 28
    elif month in [4,6,9,11]:
        return 30
    else:
        return 31
    
# RTC.datetime returns the following tuple
#(year, month, day, weekday, hours, minutes, seconds, subseconds)
# please convert to the number of seconds since 2000-01-01 00:00:00
def our_mktime_from_RTC(t):
    seconds = t[6] + t[5]*60 + t[4]*3600 + t[2]*86400
    for year in range(2000,t[0]):
        seconds += 31536000
        if year % 4 == 0:
            seconds += 86400
    for month in range(1,t[1]):
        seconds += days_in_month(month, t[0]) * 86400
    return seconds

def device_now():
    rtc = machine.RTC()
    t8 = rtc.datetime()
    return our_mktime_from_RTC(t8)

def device_bat_mv():
    p1 = Pin(3, Pin.IN)  # D1 / GPIO3
    adc_p1 = ADC(p1,atten=ADC.ATTN_11DB)  
    Vbat = adc_p1.read_uv() / (1000) * 4
    return int(Vbat)



class nvram:
    """NVRAM Class  - Store data in RTC memory"""
    def __init__(self, initial_state):
        self.inital_state = initial_state
        self.rtc = machine.RTC()

    def save(self, dat):
        """Save data to NVRAM"""
        self.rtc.memory(json.dumps(dat))

    def load(self):
        """Load data from NVRAM"""
        mem = self.rtc.memory()
        if mem == b'':
            return self.inital_state
        try:
            dat = json.loads(mem)
        except ValueError:
            return self.inital_state
        return dat
    
    def clear(self):
        """Clear NVRAM"""
        self.rtc.memory(json.dumps(self.inital_state))

class LorawanData:
    def __init__(self):
        self.dict = {}

    def get_lorawan_msg_hex(self):
        """Get binary hex"""
        bat_p = struct.pack('>H', self.dict['bat']) 
        temp_p = self.dict['temp']
        humid_p = self.dict['humid']
        count_p = struct.pack('>H', self.dict['count']) 
        hex = "{} {} {} {}".format(''.join('{:02x}'.format(x) for x in bat_p), ''.join('{:02x}'.format(x) for x in temp_p), ''.join('{:02x}'.format(x) for x in humid_p), ''.join('{:02x}'.format(x) for x in count_p))
        return hex
    

def bytes_to_hex(bytes):
    """Convert bytes to hex"""
    return ''.join('{:02x}'.format(x) for x in bytes)

def config_sensors():
    """Configre Sensors"""
    # configure sensors
    pass

def read_sensors():
    """Read Sensors"""
    # read sensors
    sht = SHT20(resolution=SHT20.TEMP_RES_14bit)
    temp = sht.read_temp_raw()
    humid = sht.read_humid_raw()
    bat = 3.3
    return {'temp': temp, 'humid': humid, 'bat': int(bat*1000)}


class LoraWAN_E5(object):
    """Lorawan Class"""
    def __init__(self):
        pass

    def begin(self,baud):
        self.uart = machine.UART(1, baudrate=baud, tx=21, rx=20)

    def set_new_appkey(self, appkey=None):
        if appkey is None:
            appkey = os.urandom(16).hex()
            print("New AppKey: {}".format(appkey))
        s,_ = self.run('AT+KEY=APPKEY,"{}"'.format(appkey), '.*KEY: APPKEY.*', '.*ERROR.*',300)
        return s

    #AT+ID=DevEui // Read DevEui
    #AT+ID=AppEui
    def get_dev_eui(self):
        s,_ = self.run('AT+ID=DevEui', '.*ID: DevEui.*', '.*ERROR.*',300)
        return s
    
    def get_app_eui(self):
        s,_ = self.run('AT+ID=AppEui', '.*ID: AppEui.*', '.*ERROR.*',300)
        return s

    def config(self):
        """Configure LoRaWAN"""
        self.begin(115200)
        s,_=self.run('AT', '.*OK.*', '.*ERROR.*',100)
        while s is False:
            self.begin(9600)
            self.run('AT+UART=BR, 115200', '.*UART: BR.*', '.*ERROR.*',300)
            self.run('AT+RESET', '.* RESET.*', '.*ERROR.*',300)
            self.begin(115200)
            time.sleep_ms(2000)
            s,_ = self.run('AT', '.*OK.*', '.*ERROR.*',300)

        # Set to low power mode, turn on debugging info.
        self.run("AT+LOWPOWER=AUTOON", '.*LOWPOWER: AUTOON.*', '.*ERROR.*',300)
        self.run("AT+LOG=DEBUG", '.*LOG: DEBUG.*', '.*ERROR.*',300)
        self.run("AT+ID", '.*ID: AppEui.*', '.*ERROR.*',300)

        # Set up for US915.
        self.run("AT+DR=US915", '.*DR: US915.*', '.*ERROR.*',300)
        self.run("AT+CH=NUM,8-15", '.*CH: NUM,.*', '.*ERROR.*',300)
        self.run("AT+DR=1", '.*DR:.*', '.*ERROR.*',300)

        # OTA, ADR ON.
        self.run("AT+LW=LEN", '.*LW:.*', '.*ERROR.*',300)
        self.run("AT+MODE=LWOTAA", '.*MODE:.*', '.*ERROR.*',300)
        self.run("AT+ADR=ON", '.*ADR: ON.*', '.*ERROR.*',300)

    def join(self,force=False):
        """Connect to LoRaWAN"""
        if force:
            ok, _ = self.run("AT+JOIN=FORCE", '.*JOIN: Done', '.*JOIN: Join failed.*',20_000)
        else:
            ok, _ = self.run("AT+JOIN", '.*JOIN: Done', '.*JOIN: Join failed.*',20_000)

        return ok

    def send_data(self, port, byte_dat):
        assert port < 250
        assert port > 0
        msg_hex = ''.join('{:02x}'.format(x) for x in byte_dat)
        self.run("AT+PORT={}".format(port), '.*PORT.*', '.*ERROR.*',100)
        self.run("AT+DR", '.*DR:.*', '.*ERROR.*',100)
        msg = str("AT+MSGHEX=\"{}\"".format(msg_hex))
        ok, _ =self.run(msg, '.*MSGHEX: Done.*', '.*MSGHEX: Please join network first.*|.*ERROR.*',10_000)
        self.run("AT+DR", '.*DR:.*', '.*ERROR.*',100)

        return ok

    def send_status(self):
        self.run("AT+PORT=99", '.*PORT.*', '.*ERROR.*',300)
        self.run("AT+DR", '.*DR:.*', '.*ERROR.*',300)
        msg = str("AT+MSGHEX=\"{0:02x} {1:02x} {2:02x}\"".format(1,2,3))
        ok, _ = self.run(msg, '.*MSGHEX: Done.*', '.*MSGHEX: Please join network first.*|.*ERROR.*',10_000)
        self.run("AT+DR", '.*DR:.*', '.*ERROR.*',300)

        return ok

    def max_payload(self):
        """Get max payload"""
        ok, resp = self.run("AT+LW=LEN", '.*LW: LEN, (\d+)', '.*ERROR.*',100)
        if ok:
            return int(resp)
        else:
            return 0

    def connected(self):
        return True


    def send_command(self, command, ok_resp, error_resp, timeout=200):
        """Send AT Command"""
        self.uart.write('\xff\xff\xff\xff' + command + '\r\n')
        print(str(command))
        start = time.ticks_ms()
        ok_re = re.compile(ok_resp)
        error_re = re.compile(error_resp)
        while True:
            time.sleep_us(500)  
            if self.uart.any():
                resp = self.uart.readline()
                resp = resp.replace(b'\xff', b'')
                ok_m = ok_re.match(resp)
                error_m = error_re.match(resp)
                line = resp.strip()
                if ok_m:
                    print(str(line + " SUCCESS"))
                    try:
                        m_str = ok_m.group(1)
                    except :
                        m_str = ok_m.group(0)
                    return [True, m_str]
                elif error_m:
                    print(str(line + " ERROR"))
                    try:
                        m_str = error_m.group(1)
                    except :
                        m_str = error_m.group(0)
                    return [False, m_str]
                if time.ticks_ms() - start > timeout:
                    print(str(line + " TIMEOUT"))
                    return [False, None]
                elif line != b'':
                    print(str(line))
            if time.ticks_ms() - start > timeout:
                print(str("TIMEOUT"))
                return [False, None]

    def run(self, command, ok_resp, error_resp, timeout=200):
        # send command, and look for ok or error response
        extra_time = 2  # ms
        result = self.send_command(command, ok_resp, error_resp, timeout-extra_time)
        # slurp any extra lines after the response has been found
        start = time.ticks_ms()
        while True:
            time.sleep_us(500)
            if self.uart.any():
                line = self.uart.readline().strip()
                line = line.replace(b'\xff', b'')
                if line != b'':
                    print(line)
            if time.ticks_ms() - start > extra_time:
                return result
        

class Device_LCT(object):
    """Device LCT Class"""
    def __init__(self,lorawan,hct):
        self.lorawan = lorawan
        self.hct = hct
        self.nvram = nvram({'count':0, 'uptime_ms':0})
        self.state = self.nvram.load()
        self.hct_bytes = None
        self.v_bytes1 = None
        self.b_bytes1 = None
        pass

    def sample_channel(self):
        hct.start_channel_sampling()  # takes 90ms
        hct_bytes = hct.read_channel_data()
        i = 0
        while hct_bytes is None and i < 10:
            hct_bytes = hct.read_channel_data()
            i += 1
        hct_dict = None
        if hct_bytes is not None:
            self.hct_bytes = hct_bytes
            hct_dict = hct.decode_channel_data(hct_bytes)
        return hct_dict

    def sample_all(self):
        hct.device_reset()
        self.sample_channel()
        if self.hct_bytes is not None:
            v_series1, v_bytes1 = hct.get_series("V")
            print(v_series1)
            print(v_bytes1)
            b_series1, b_bytes1 = hct.get_series("B")
            print(b_series1)
            print(b_bytes1)
        self.v_bytes1 = v_bytes1
        self.b_bytes1 = b_bytes1

    def send_uplink(self):
        hct_bytes = self.hct_bytes
        v_bytes1 = self.v_bytes1
        b_bytes1 = self.b_bytes1
        lorawan = self.lorawan
        maxb = lorawan.max_payload()
        if hct_bytes is None:
            return
        ok = lorawan.send_data(10, hct_bytes)
        while not ok:
            lorawan.join()
            lorawan.send_status()
            ok = lorawan.send_data(10, hct_bytes)
        if v_bytes1 and (len(v_bytes1) <= maxb):
            ok = lorawan.send_data(11, v_bytes1)
        if b_bytes1 and (len(b_bytes1) <= maxb):
            ok = lorawan.send_data(11, b_bytes1)
        return ok

    def status_message(self):
        return { 'uptime_ms': self.state['uptime_ms'] + time.ticks_diff(time.ticks_ms(), self.start_ms), 
                'Vbat': device_bat_mv()}
    
    def send_status_message(self,msg):
        self.status_message_bin = struct.pack('>IH', msg['uptime_ms'],msg['Vbat'])  # 32bit uptime_ms, 16 bit voltage_mv
        ok = self.lorawan.send_data(99, self.status_message_bin)
        while not ok:
            self.lorawan.join()
            ok = self.lorawan.send_data(99, self.status_message_bin)
        return ok

    def run_awake(self):
        """Run Awake function - should last 50ms or less"""
        self.start_ms = time.ticks_ms()
        time.sleep(3) # wait for the USB serial port to become ready
        lorawan = self.lorawan
        lorawan.begin(115200)
        hct = self.hct
        nvm = self.nvram
        if machine.reset_cause() != machine.DEEPSLEEP_RESET:  # == 5
            # FIRST BOOT
            print('first boot')
            lorawan.config()
            hct.device_reset()
            nvm.clear()
        else:
            # WAKE FROM DEEP SLEEP
            print('awake')

        self.sample_all()

        if self.state['count'] % (12*600) == 0:  # every 600 minutes
            i = 0
            ok = lorawan.join(True) # force join
            while not ok and i < 10:
                ok = lorawan.join(True)

        if self.state['count'] % (12*5) == 0:  # every 5 minutes
            #lorawan.join(True) # force join
            msg = device.status_message()
            print(msg)
            device.send_status_message(msg)

        if self.state['count'] % 6 == 0:  # every 30 seconds
            self.send_uplink()

        self.state['count'] += 1
        self.state['uptime_ms'] += time.ticks_diff(time.ticks_ms(), self.start_ms) + 50
        if self.state['uptime_ms'] > 2^31:
            self.state['uptime_ms'] = 0
        print(self.state)
        nvm.save(self.state)
        

    def main(self):
        """Main function"""
        # run main and deep sleep
        led = machine.Pin(10, machine.Pin.OUT, drive=machine.Pin.DRIVE_0)  # 5mA 130R
        boot_button = machine.Pin(9, machine.Pin.IN) # BOOT button - right button - hold to keep from sleeping.
        led.on()
        self.run_awake()
        if boot_button.value() == 1:
            print("going to sleep")
            led.off()
            return True
        else:
            print("BOOT button pressed, staying awake")
            return False


if __name__ == '__main__':
    try:
        lorawan = LoraWAN_E5()
        hct = HCT21()
        device = Device_LCT(lorawan,hct)
        if device.main():
            machine.deepsleep(5000)  # 6 seconds
            #machine.reset()
            #micropython.schedule(machine.deepsleep,1)
    except Exception as e:
        e_file = io.open("exceptionFile.txt", "wt")
        ex_str = e.__class__.__name__
        e_file.write(ex_str+'\n')
        sys.print_exception(e, e_file)
        e_file.close()
        print(e.__class__.__name__)
        raise e