Ejemplo n.º 1
0
def lte_connect():
    lte = LTE()
    lte.init()
    #some carriers have special requirements, check print(lte.send_at_cmd("AT+SQNCTM=?")) to see if your carrier is listed.
    #when using verizon, use
    #lte.init(carrier=verizon)
    #when usint AT&T use,
    #lte.init(carrier=at&t)
    #some carriers do not require an APN
    #also, check the band settings with your carrier
    lte.attach(band=2, apn="vzwinternet")
    print("attaching..", end='')
    while not lte.isattached():
        time.delay(0.25)

        print('.', end='')
        print(lte.send_at_cmd('AT!="fsm"'))  # get the System FSM
    print("attached!")

    lte.connect()
    print("connecting [##", end='')
    while not lte.isconnected():
        time.sleep(0.25)
        print('#', end='')
        #print(lte.send_at_cmd('AT!="showphy"'))
        print(lte.send_at_cmd('AT!="fsm"'))
    print("] connected!")

    print(socket.getaddrinfo('pycom.io', 80))
    lte.deinit()
Ejemplo n.º 2
0
    def get_device_id(self):
        #TODO For Wifi, change this to something like the mac address instead of SIM ICCID
        """Get an identifier for the device used in server requests
        In this case, we return the SHA256 hash of the SIM ICCID prefixed with
        'ID:' and then prepend an 'IC' (for ICCID) so the result is e.g.
        devid = 'IC' + SHA256("ID:12345678901234567890")
              = IC27c6bb74efe9633181ae95bade7740969df13ef15bca1d72a92aa19fb66d24c9"""

        try:
            lte = LTE()
            iccid = lte.iccid()
        except Exception as e:
            print("Getting device ID failed:")
            print(e)
            return "ICERROR"

        hasher = None
        try:
            hasher = uhashlib.sha256("ID:" + iccid)
            hashvalue = hasher.digest()
        except Exception as e:
            if hasher is not None:
                hasher.digest(
                )  #make sure hasher is closed, as only one is allowed at a time by the hardware
            raise e

        devid = "IC" + ubinascii.hexlify(hashvalue).decode('utf-8')

        return devid
Ejemplo n.º 3
0
def whoami(verbose=False, veryverbose=False):
    import machine
    import binascii
    import os
    uid = binascii.hexlify(machine.unique_id())
    name = os.uname().sysname.lower() + '-' + uid.decode("utf-8")[-4:]
    print(name)
    print(os.uname())
    if verbose:
        print("type", fw_type())
        for attr in dir(os.uname()):
            if attr[0] != '_':
                # filter out __class__
                print(attr, getattr(os.uname(), attr))
    if veryverbose:
        if os.uname().nodename == 'GPy' or os.uname().nodename == 'FiPy':
            from network import LTE
            lte = LTE()
            ver = lte.send_at_cmd('ATI1').split('\r\n')[2]
            prot = 'unknown'
            import re
            if re.search('^LR5', ver):
                prot = 'CAT-M1'
            elif re.search('^LR6', ver):
                prot = 'NB-IoT'
            print('Sequans FW', ver, prot)
Ejemplo n.º 4
0
    def power_off_lte_modem(self):
        """
        We don't use LTE yet.

        https://community.hiveeyes.org/t/lte-modem-des-pycom-fipy-komplett-stilllegen/2161
        https://forum.pycom.io/topic/4877/deepsleep-on-batteries/10
        """

        import pycom
        """
        if not pycom.lte_modem_en_on_boot():
            log.info('Skip turning off LTE modem')
            return
        """

        log.info('Turning off LTE modem')
        try:
            from network import LTE

            # Invoking this will cause `LTE.deinit()` to take around 6(!) seconds.
            #log.info('Enabling LTE modem on boot')
            #pycom.lte_modem_en_on_boot(True)

            log.info('Turning off LTE modem on boot')
            pycom.lte_modem_en_on_boot(False)

            log.info('Invoking LTE.deinit()')
            lte = LTE()
            lte.deinit()

        except:
            log.exception('Shutting down LTE modem failed')
Ejemplo n.º 5
0
    def init_lte_modem(self):
        """ initialise the LTE modem """
        try:
            # check if self.lte is already initialised/initialise it
            if not self.lte:
                self.lte = LTE()
            if not self.modem:
                self.modem = Modem(self.lte)

            # reset the LTE modem (ensure that it is in a usable state)
            log.info("Resetting the LTE modem")
            self.modem.reset()
            log.info("Done resetting the LTE modem")

            # get/log the IMSI
            log.info("Reading the IMSI from the SIM")
            self.sim_imsi = self.modem.get_imsi()
            log.info("SIM IMSI: %s" % str(self.sim_imsi))
        except Exception as e:
            log.exception("Failed to set up the LTE Modem: %s" % str(e))

            # idle until the watchdog resets the system
            while True:
                machine.idle()

        return
Ejemplo n.º 6
0
def lte_init_psm_off():
    global l
    print("lte_init_psm_off")
    try:
        l = LTE(psm_period_value=1, psm_period_unit=LTE.PSM_PERIOD_DISABLED,
                  psm_active_value=5, psm_active_unit=LTE.PSM_ACTIVE_DISABLED, debug=lte_debug)
    except Exception as e:
        print("Exception:", e)
        print("try without psm args")
        try:
            l = LTE(debug=lte_debug)
        except Exception as e:
            print("Exception:", e)
            print("try without debug")
            l = LTE()
    return l
Ejemplo n.º 7
0
class LTEManager(CommManager):
    logger = logging.getLogger(__name__)
    lte = LTE()

    def isconnected(self):
        return self.lte.isconnected()

    def scan(self):
        return True

    def connect(self):
        attempts = 0

        if not self.lte_attach():
            print("LTE attach failed")
            return False

        while not self.lte.isconnected():
            print("Connecting to LTE, attempt " + str(attempts) + "/3")
            if self.lte_connect_attempt():
                break
            if attempts < 3:
                attempts += 1
            else:
                break
        if self.lte.isconnected():
            print("Connected to LTE\n")
            pycom.rgbled(0x0000FF)
            return True
        return False

    def lte_connect_attempt(self):
        counter = 0
        self.lte.connect()
        while not self.lte.isconnected():
            time.sleep(1)
            counter += 1
            if counter == 5:
                return False
        return True

    def lte_attach(self):
        counter = 0
        print("Attaching to LTE")
        self.lte.attach()
        while not self.lte.isattached():
            time.sleep(1)
            counter += 1
            if counter == 15:
                return False
        return True

    def disconnect(self):
        if self.lte.isconnected():
            self.lte.disconnect()
        if self.lte.isattached():
            self.lte.dettach()
        return True
Ejemplo n.º 8
0
def attachLte():
    global lte
    lte = LTE()
    lte.init()
    lte.attach(band=12, apn="soracom.io")
    while not lte.isattached():
        time.sleep(0.25)
        print('.',end='')
    print("attached!")
Ejemplo n.º 9
0
def lte_init_psm_on():
    global l
    print("lte_init_psm_on")
    l = LTE(psm_period_value=12,
            psm_period_unit=LTE.PSM_PERIOD_1H,
            psm_active_value=5,
            psm_active_unit=LTE.PSM_ACTIVE_2S,
            debug=lte_debug)
    return l
Ejemplo n.º 10
0
 def __init__(self):
     try:
         self.lte = LTE()
         time.sleep(4)
     except:
         print("initialize LTE object?")
     self.lte.reset()
     time.sleep(4)
     print("delay 4 secs")
Ejemplo n.º 11
0
def check_OTA_update():
    # Configuration (if you are looking for the server pubkey: it's in the OTA class)
    #TODO: Change server URL and Pubkey to non-testing versions
    SERVER_URL = "ota.iot.wheelmap.pro"
    SERVER_PORT = 80
    NBIOT_APN = "iot.1nce.net"
    NBIOT_BAND = None  #None = autoscan
    NBIOT_ATTACH_TIMEOUT = 15 * 60  #seconds
    NBIOT_CONNECT_TIMEOUT = 15 * 60  #seconds
    WATCHDOG_TIMEOUT = 15 * 60 * 1000  #milliseconds

    #setup watchdog
    wdt = machine.WDT(timeout=WATCHDOG_TIMEOUT)
    wdt.feed()

    #initialize ota object variable for proper exception handling
    ota = None

    try:
        # # Setup Wifi OTA
        # from ota_wifi_secrets import WIFI_SSID, WIFI_PW
        # ota = WiFiOTA(WIFI_SSID,
        #         WIFI_PW)

        # Setup NB-IoT OTA
        print("Initializing LTE")
        lte = LTE()
        lte.reset()
        lte.init()

        ota = NBIoTOTA(lte, NBIOT_APN, NBIOT_BAND, NBIOT_ATTACH_TIMEOUT,
                       NBIOT_CONNECT_TIMEOUT)

        #start the update itself
        print("Current version: ", ota.get_current_version())
        ota.connect(url=SERVER_URL, port=SERVER_PORT)
        ota.update()

        # the update did not fail, proceed to check file integrity
        n = ota.check_stored_files()

        if n > 0:
            print("%d corrupted files detected and reloaded! Rebooting ..." %
                  n)

            time.sleep(0.5)
            machine.reset()
    except Exception as e:
        raise (e)  #let top level loop handle exception
    finally:
        if ota is not None:
            ota.clean_up()
        # before leaving, set watchdog to large value, so we don't interfere
        # with code in main.py (wdt can never be disabled after use)
        wdt = machine.WDT(timeout=10 * 24 * 60 * 60 * 1000)
        wdt.feed()
Ejemplo n.º 12
0
def sendData(dataList, deviceKey):
    # ******************** Hologram endpoint Definition
    HOST = "cloudsocket.hologram.io"
    PORT = 9999
    TOPIC = "SENSOR_DATA"

    blink(1, 0xffffff)  # blink white
    # Set up LTE connection
    lte = LTE()
    lte.init()
    print("Resetting LTE modem ... ", end="")
    lte.send_at_cmd('AT^RESET')
    print("Reset OK")
    time.sleep(1)
    # While the configuration of the CGDCONT register survives resets,
    # the other configurations don't. So just set them all up every time.
    print("Configuring LTE ", end='')
    # Changed this from origninal
    lte.send_at_cmd('AT+CGDCONT=1,"IP","hologram"')
    print(".", end='')
    # changed band from 28 to 4. I dont know what earfcn=9410 is;
    lte.send_at_cmd('AT!="RRC::addscanfreq band=4 dl-earfcn=9410"')
    print(".", end='')
    # lte.send_at_cmd

    # Do the attach (Enable radio functionality and attach to the LTE network authorized by the inserted SIM card)
    lte.attach()
    print("attaching..", end='')
    while not lte.isattached():
        blink(1, 0x0000ff)  # blue
        print('.', end='')
    # print(lte.send_at_cmd('AT!="fsm"'))         # get the System FSM
    print("attached!")

    # Do the connect (Start a data session and obtain and IP address)
    lte.connect()
    print("connecting [##", end='')
    while not lte.isconnected():
        time.sleep(1)
        print('#', end='')
    print("] connected!")
    blink(1, 0x00ff00)  # Green

    # **** Send data to hologram
    bodyData = buildData(dataList)
    lteSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    lteSocket.connect(socket.getaddrinfo(HOST, PORT)[0][-1])
    data = '{"k": "%s", "d": "{%s}", "t": "%s"}' % (deviceKey, bodyData, TOPIC)
    print("Send Data:", data)
    lteSocket.send(data)

    # Clean up and close connection
    lteSocket.close()
    lte.deinit()
    print("Disconnected")
    blink(1, 0xff0000)  # red
Ejemplo n.º 13
0
 def __init__(self):
     self._lte = LTE()
     self._lte.attach()
     while not self._lte.isattached():
         time.sleep(1)
     self._lte.connect()
     while not self._lte.isconnected():
         time.sleep(1)
     print(self._lte.isattached())
     print(self._lte.isconnected())
Ejemplo n.º 14
0
    def __init__(self, network_manager, settings):
        self.network_manager = network_manager
        self.settings = settings

        from network import LTE
        self.lte = LTE()

        import machine
        self.chrono = machine.Timer.Chrono()
        self.chrono.start()
 def __init__(self):
     self.message_storage = 'AT+CPMS="SM", "SM", "SM"'
     gc.collect()
     try:
         self.lte = LTE()
         time.sleep(4)
     except:
         print("initialize LTE object?")
     self.lte.reset()
     time.sleep(4)
     print("delay 4 secs")
Ejemplo n.º 16
0
  def __init__(self, network=LTE_M):
    self._network = network
    self.lte = LTE()
    try:
      self.lte.deinit()
      self.lte.reset()
    except:
      pass
    sleep(5)

    self.lte.init()
    sleep(5)

    self._assure_modem_fw()
Ejemplo n.º 17
0
def get_LTE():
    global lte
    if lte == None:
        lte = LTE()
    if lte.isconnected():
        return True
    # lte.reset()
    # lte.send_at_cmd('AT+CGDCONT=1,"IP","nbiot.iot"')
    if (not lte.isattached()):
        lte.attach(band=20, apn="nbiot.iot")
    while not lte.isattached():
        debugprint('Attaching...')
        time.sleep(1)
    debugprint('LTE is attached')
    return True
Ejemplo n.º 18
0
    def connect_lte(self, reconnect=True, check_interval=0.5):
        self.__initialise_watchdog()

        lte_cfg = self.__conf.get('lte')
        if lte_cfg is not None:
            if (os.uname()[0] not in ['FiPy', 'GPy']):
                print("You need a device with FiPy or GPy firmware to connect via LTE")
                return False
            try:
                from network import LTE
                time.sleep(3)
                print_debug(1, 'LTE init(carrier={}, cid={})'.format(lte_cfg.get('carrier'), lte_cfg.get('cid', 1)))
                self.lte = LTE(carrier=lte_cfg.get('carrier'))         # instantiate the LTE object
                print_debug(1, 'LTE attach(band={}, apn={}, type={})'.format(lte_cfg.get('band'), lte_cfg.get('apn'), lte_cfg.get('type')))
                self.lte.attach(band=lte_cfg.get('band'), apn=lte_cfg.get('apn'), type=lte_cfg.get('type'))        # attach the cellular modem to a base station
                while not self.lte.isattached():
                    time.sleep(0.25)
                time.sleep(1)
                print_debug(1, 'LTE connect()')
                self.lte.connect()       # start a data session and obtain an IP address
                print_debug(1, 'LTE is_connected()')
                while not self.lte.isconnected():
                    time.sleep(0.25)
                print("LTE connection established")
                self.__network_type = constants.__NETWORK_TYPE_LTE
                self.__mqtt_check_interval = check_interval
                try:
                    self.__connection = MQTTClient(self.__device_id, self.__host, self.__mqtt_download_topic, user=self.__user_name,
                                                   password=self.__device_id, reconnect=reconnect, ssl=self.__ssl, ssl_params = self.__ssl_params)
                    self.__connection.connect()
                    self.__connection_status = constants.__CONNECTION_STATUS_CONNECTED_MQTT_LTE
                    self.__pybytes_protocol.start_MQTT(self, check_interval, constants.__NETWORK_TYPE_WIFI)
                    print("Connected to MQTT {}".format(self.__host))
                    return True
                except Exception as ex:
                    if '{}'.format(ex) == '4':
                        print('MQTT ERROR! Bad credentials when connecting to server: "{}"'.format(self.__host))
                    else:
                        print("MQTT ERROR! {}".format(ex))
                    return False
            except Exception as ex:
                print("Exception connect_lte: {}".format(ex))
                return False
        else:
            print("Error... missing configuration!")
            return False
Ejemplo n.º 19
0
    def __init__(self, pytrack=None, debug=False):
        if pytrack is not None:
            self.pytrack = pytrack
        else:
            self.pytrack = Pytrack()

        self.debug = debug
        # Instantiate and hold state for sensors (accelerometer, lte, gps, etc)
        self.accel = LIS2HH12()
        self.lte = LTE()
        self.gps = None
        # Holds the mqtt client to send messages to
        self.mqttClient = None
        # If after wakeup, we are in continuous GPS logging state
        self.continueGPSRead = False
        # Flag for handling wakeup and logging logic differently if owner is nearby
        self.checkOwnerNearby = True
        self.wlan = WLAN()  #TODO remove
Ejemplo n.º 20
0
def lte_connect():
    print("init")
    t = time.time()
    try:
        # try to detach, in case the script was Ctrl-C-ed and is rerun
        detach(lte)
        print("detached")
    except:
        pass

    lte = LTE()  # debug=True) # carrier=None, cid=1)
    # print("imei", lte.imei())
    attach(lte)
    # lte.init(debug=True)
    connect(lte)
    # host = 'google.com'
    # print(host, socket.getaddrinfo(host,80))
    return True
Ejemplo n.º 21
0
    def power_off_lte_modem(self):
        """
        We don't use LTE yet.

        Important
        =========
        Once the LTE radio is initialized, it must be de-initialized
        before going to deepsleep in order to ensure minimum power consumption.
        This is required due to the LTE radio being powered independently and
        allowing use cases which require the system to be taken out from
        deepsleep by an event from the LTE network (data or SMS received for
        instance).

        Note
        ====
        When using the expansion board and the FiPy together, the RTS/CTS
        jumpers MUST be removed as those pins are being used by the LTE radio.
        Keeping those jumpers in place will lead to erratic operation and
        higher current consumption specially while in deepsleep.

        -- https://forum.pycom.io/topic/3090/fipy-current-consumption-analysis/17

        See also
        ========
        - https://community.hiveeyes.org/t/lte-modem-des-pycom-fipy-komplett-stilllegen/2161
        - https://forum.pycom.io/topic/4877/deepsleep-on-batteries/10
        """

        log.info('Turning off LTE modem')
        try:
            import pycom
            from network import LTE

            log.info('Turning off LTE modem on boot')
            pycom.lte_modem_en_on_boot(False)

            # Disables LTE modem completely. This presumably reduces the power
            # consumption to the minimum. Call this before entering deepsleep.
            log.info('Invoking LTE.deinit()')
            lte = LTE()
            lte.deinit(detach=False, reset=True)

        except Exception as ex:
            log.exc(ex, 'Shutting down LTE modem failed')
Ejemplo n.º 22
0
def sleep():
    global client
    client.disconnect()  # Disconnects from Ubidots server.
    client = None
    print("Disconnected from Ubidots.")

    lte = LTE()
    lte.deinit(
    )  # Disables the LTE modem to lower the power consumption during deepsleep.

    global chrono
    time = 300 - chrono.read(
    )  # Calculates the time in seconds for how long the deepsleep will be active.
    print("Going to sleep for %s seconds." % (time))
    sleepTime = int(
        time *
        1000)  # Converts the time to milliseconds and the data type to int.
    machine.deepsleep(
        sleepTime
    )  # Turns deepsleep on. When time has passed the FipY will reboot and read the code from the top of the file.
Ejemplo n.º 23
0
def connect(timeout=30, lte=None):
    if lte is None:
        lte = LTE()  # instantiate the LTE object

    lte.attach()  # attach the cellular modem to a base station
    cycles = 0
    while not lte.isattached():
        sleep(1)
        cycles += 1
        if cycles > timeout:
            raise Exception("Failed to attach cellular modem to base station")

    lte.connect()  # start a data session and obtain an IP address
    cycles = 0
    while not lte.isconnected():
        sleep(1)
        cycles += 1
        if cycles > timeout:
            raise Exception("Failed to obtain cellular data session")

    return lte
Ejemplo n.º 24
0
def connect():
    global lte
    lte = LTE()  # instantiate the LTE object

    # Change this if you are using the M1 network (comment out the next 6 lines)
    lte.send_at_cmd('AT+CFUN=0')
    lte.send_at_cmd('AT+CEMODE=0')
    lte.send_at_cmd('AT+CEMODE?')
    lte.send_at_cmd('AT!="clearscanconfig"')
    lte.send_at_cmd('AT!="addscanfreq band=20 dl-earfcn=6352"')
    lte.send_at_cmd('AT+CFUN=1')
    # End change this ....

    lte.attach()  # attach the cellular modem to a base station
    while not lte.isattached():
        time.sleep(0.25)
    print("attatched")
    lte.connect()  # start a data session and obtain an IP address
    while not lte.isconnected():
        time.sleep(0.25)
    print("connected")
    def __init__(self):

        print("Init: Initialization of Gateway class...")

        # Machine
        machine.callback(
            trigger=(machine.PYGATE_START_EVT | machine.PYGATE_STOP_EVT
                     | machine.PYGATE_ERROR_EVT),
            handler=self.machine_callback)
        self.machine_state = 0

        # LTE
        self.lte = LTE()
        self.lte_connection_state = 0

        # RTC
        self.rtc = RTC()

        # Gateway
        # Read the GW config file from Filesystem
        self.gateway_config_file = None

        # Timers
        self.rgb_breathe_timer = Timer.Chrono()
Ejemplo n.º 26
0
 def __init__(self):
     self.logger = logging.get_logger(__name__)
     self.lte = LTE()
Ejemplo n.º 27
0
from network import LTE


def send_at_cmd_pretty(cmd):
    response = lte.send_at_cmd(cmd).split('\r\n')
    for line in response:
        if (len(line) > 0):
            print(line)


lte = LTE()
print("imei", lte.imei())
print("is_connected", lte.isconnected())
print("ue_coverage", lte.ue_coverage())
print("iccid", lte.iccid())
print("time", lte.time())

send_at_cmd_pretty('AT+CGMI')
# PYCOM
send_at_cmd_pretty('AT+CGMM')
# FiPy
send_at_cmd_pretty('AT+CGMR')
# UE5.0.0.0d
send_at_cmd_pretty('AT+CGSN=0')

send_at_cmd_pretty('AT+CGSN=1')

send_at_cmd_pretty('AT+CGSN=2')

send_at_cmd_pretty('AT+CGSN=3')
# +CGSN: "00"
    def connect_lte(self, activation_info=False, start_mqtt=True):
        if activation_info:
            lte_cfg = activation_info
        else:
            lte_cfg = self.__conf.get('lte')
            self.__initialise_watchdog()

        if lte_cfg is not None:
            if (os.uname()[0] not in ['FiPy', 'GPy']):
                print("You need a device with FiPy or GPy firmware to connect via LTE") # noqa
                return False
            try:
                from network import LTE
                time.sleep(3)
                if lte_cfg.get('carrier', 'standard') == 'standard':
                    carrier = None
                else:
                    carrier = lte_cfg.get('carrier')
                print_debug(1, 'LTE init(carrier={}, cid={})'.format(carrier, lte_cfg.get('cid', 1))) # noqa
                # instantiate the LTE object
                self.lte = LTE(carrier=carrier, cid=lte_cfg.get('cid', 1))
                try:
                    lte_type = lte_cfg.get('type') if len(lte_cfg.get('type')) > 0 else None
                except:
                    lte_type = None
                try:
                    lte_apn = lte_cfg.get('apn') if len(lte_cfg.get('type')) > 0 else None
                except:
                    lte_apn = None
                try:
                    lte_band = int(lte_cfg.get('band'))
                except:
                    lte_band = None
                print_debug(
                    1,
                    'LTE attach(band={}, apn={}, type={})'.format(
                        lte_band,
                        lte_apn,
                        lte_type
                    )
                )

                self.lte.attach(band=lte_band, apn=lte_apn, type=lte_type)  # noqa   # attach the cellular modem to a base station
                while not self.lte.isattached():
                    time.sleep(0.25)
                time.sleep(1)
                print_debug(1, 'LTE connect()')
                # start a data session and obtain an IP address
                self.lte.connect()
                print_debug(1, 'LTE is_connected()')
                while not self.lte.isconnected():
                    time.sleep(0.25)
                print("LTE connection established")
                self.__network_type = constants.__NETWORK_TYPE_LTE

                if start_mqtt:
                    try:
                        self.__connection = MQTTClient(
                            self.__device_id,
                            self.__host,
                            self.__mqtt_download_topic,
                            self.__pybytes_protocol,
                            user=self.__user_name,
                            password=self.__device_id
                        )
                        self.__connection.connect()
                        self.__connection_status = constants.__CONNECTION_STATUS_CONNECTED_MQTT_LTE # noqa
                        self.__pybytes_protocol.start_MQTT(
                            self,
                            constants.__NETWORK_TYPE_LTE
                        )
                        print("Connected to MQTT {}".format(self.__host))
                        return True
                    except Exception as ex:
                        if '{}'.format(ex) == '4':
                            print('MQTT ERROR! Bad credentials when connecting to server: "{}"'.format(self.__host)) # noqa
                        else:
                            print("MQTT ERROR! {}".format(ex))
                        return False
            except Exception as ex:
                print("Exception connect_lte: {}".format(ex))
                sys.print_exception(ex)
            return False
        else:
            print("Error... missing configuration!")
            return False
Ejemplo n.º 29
0
from io_control import set_io_i2c, init_io, led_rd_on, measure_vbatt
from io_control import pmic_ce, get_charger_status
from network import LTE
​
pycom.heartbeat(False)
​
while False:
    pycom.rgbled(0xFF0000)  # Red
    time.sleep(1)
    pycom.rgbled(0x00FF00)  # Green
    time.sleep(1)
    pycom.rgbled(0x0000FF)  # Blue
    time.sleep(1)

if False:
    lte = LTE(carrier="verizon")
    imei = lte.imei()
    print(imei)

if False:
    adc = machine.ADC()             # create an ADC object
    apin = adc.channel(pin='P13',attn=machine.ADC.ATTN_0DB)   # create an analog pin on P13
    val = apin()                    # read an analog value
    print(val)
    volt = apin.voltage()
    print(volt)

if False:
    #i2c = I2C(0, pins=('P9','P10'))     # create and use non-default PIN assignments (P9=SDA, P10=SCL)
    #i2c.init(I2C.MASTER, baudrate=1000) # init as a master
    i2c = I2C(0)
Ejemplo n.º 30
0
import time
from network import LoRa
from certification import Compliance
import pycom
import machine
import os

# disable WiFi
if pycom.wifi_on_boot():
    pycom.wifi_on_boot(False)

# disable LTE
try:
    if 'FiPy' in os.uname().machine:
        from network import LTE
        LTE().deinit()
except:
    pass

time.sleep(5)

regions_str = ['EU868', 'AS923', 'US915', 'AU915']
activations_str = ['OTAA', 'ABP']

region = None
activation = None

region_in = -1
activation_in = -1

print('<<< Device ready for LoRaWAN certification testing >>>')