Exemple #1
0
class Car(object):
    def __init__(self, is_debug=False):
        '''
        Car构造器函数
        '''
        # 电池ADC采样
        self.battery_adc = BatteryVoltage(gpio_dict['BATTERY_ADC'],
                                          is_debug=False)

        # 用户按键
        self.user_button = Button(0,
                                  callback=lambda pin: self.stop_trigger(pin))

        try:
            # 创建一个I2C对象
            i2c = I2C(scl=Pin(gpio_dict['I2C_SCL']),
                      sda=Pin(gpio_dict['I2C_SDA']),
                      freq=car_property['I2C_FREQUENCY'])
            # 创建舵机云台对象
            self.cloud_platform = CloudPlatform(i2c)
        except:
            print('[ERROR]: pca9885舵机驱动模块初始化失败')
            print('[Hint]: 请检查接线')

        self.speed_percent = 70  # 小车默认速度

        # 左侧电机
        self.left_motor = Motor(0)
        self.left_motor.stop()  # 左侧电机停止

        # 右侧电机
        self.right_motor = Motor(1)
        self.right_motor.stop()  # 右侧电机停止

        # 小车停止标志位
        self.stop_flag = False
        self.is_debug = is_debug  # 是否开始调试模式

    def stop(self):
        '''停车'''
        self.left_motor.speed_percent = 0
        self.right_motor.speed_percent = 0

    def stop_trigger(self, pin):
        '''
        切换小车的停止位
        '''
        self.stop_flag = not self.stop_flag
        if self.stop_flag:
            self.stop()

        if self.is_debug:
            print('切换stopflag flag={}'.format(self.stop_flag))

    def go_forward(self, speed_percent=None, delay_ms=None):
        '''
        小车前进
        '''
        if speed_percent is None:
            speed_percent = self.speed_percent
        else:
            speed_percent = float(speed_percent)
        if delay_ms is not None:
            delay_ms = int(delay_ms)

        self.left_motor.speed_percent = speed_percent
        self.right_motor.speed_percent = speed_percent

        if delay_ms is not None:
            delay_ms = int(float(delay_ms))
            utime.sleep_ms(delay_ms)
            self.stop()

    def go_backward(self, speed_percent=None, delay_ms=None):
        '''
        小车后退
        '''
        if speed_percent is None:
            speed_percent = self.speed_percent
        else:
            speed_percent = float(speed_percent)
        if delay_ms is not None:
            delay_ms = int(delay_ms)

        self.left_motor.speed_percent = -1 * speed_percent
        self.right_motor.speed_percent = -1 * speed_percent

        if delay_ms is not None:
            delay_ms = int(float(delay_ms))
            utime.sleep_ms(delay_ms)
            self.stop()

    def turn_left(self, speed_percent=None, delay_ms=None):
        '''
        小车左转
        '''
        if speed_percent is None:
            speed_percent = self.speed_percent
        else:
            speed_percent = float(speed_percent)

        self.left_motor.speed_percent = -1 * speed_percent
        self.right_motor.speed_percent = speed_percent

        if delay_ms is not None:
            delay_ms = int(float(delay_ms))
            utime.sleep_ms(delay_ms)
            self.stop()

    def turn_right(self, speed_percent=None, delay_ms=None):
        '''
        小车右转
        '''
        if speed_percent is None:
            speed_percent = self.speed_percent
        else:
            speed_percent = float(speed_percent)

        self.left_motor.speed_percent = speed_percent
        self.right_motor.speed_percent = -1 * speed_percent

        if delay_ms is not None:
            delay_ms = int(float(delay_ms))
            utime.sleep_ms(delay_ms)
            self.stop()

    def move(self, left_speed_percent, right_speed_percent, delay_ms=None):
        left_speed_percent = float(left_speed_percent)
        right_speed_percent = float(right_speed_percent)

        self.left_motor.speed_percent = left_speed_percent
        self.right_motor.speed_percent = right_speed_percent

        if delay_ms is not None:
            delay_ms = int(float(delay_ms))
            utime.sleep_ms(delay_ms)
            self.stop()

    def deinit(self):
        '''
        释放资源
        '''
        self.battery_adc.deinit()
        self.user_button.deinit()
        self.left_motor.deinit()
        self.right_motor.deinit()

    def log(self):
        # 打印日志 TODO
        print('[INFO] battery voltage: {}'.format(
            self.battery_adc.battery_voltage))
        print('[INFO] default velocity (percent): {}'.format(
            self.speed_percent))
Exemple #2
0
class ShadeController(BaseThing):
    def __init__(self):
        import machine
        if getattr(machine, "reset_cause", None) != None:
            reset_names = [
                '0', 'PWRON', 'HARD', 'Watchdog', 'DEEPSLEEP', 'SOFT'
            ]
            cause = machine.reset_cause()
            if cause < machine.PWRON_RESET or cause > machine.SOFT_RESET:
                logger.warning("Unknown reset cause: %d", cause)
            else:
                logger.debug("Reset cause: %s", reset_names[cause])

        self.rtc = machine.RTC()

        super().__init__()
        # if a parameter is not restored from persistence, then add it with a default value
        if 'position' not in self._current_state['params']:
            self._current_state['params']['position'] = "unknown"
        self._operations['position'] = self._position
        # add tests to dictionary of available test operations
        self._test_operations['current'] = self._test_current_sensor
        self._test_operations['motor'] = self._test_motor
        self._test_operations['motor2'] = self._test_motor2
        self._test_operations['set-position'] = self._set_position

        self._conditions['temperature'] = {
            'get': self.get_temperature,
            'threshold': 2
        }  # report on 2 degree changes
        # report batteryVoltage on changes of 200 mV or 20 minutes
        self._conditions['batteryVoltage'] = {
            'get': self.get_battery_voltage,
            'threshold': 200,
            'interval': 1200
        }

        self._start_ticks = None

        PCB_version = 3
        if PCB_version == 0:
            # the following are the GPIO numbers
            self.PIN_LED = 2
            self.PIN_POWER_ENABLE = 14  # D5 on the nodeMCU board
            # self.PIN_MOTOR_ENABLE1 = 12     #D6
            # self.PIN_MOTOR_ENABLE2 = 13     #D7
            self.PIN_MOTOR_ENABLE1 = 15  #D8
            self.PIN_MOTOR_ENABLE2 = 2  #D4
            # self.PIN_MOTOR_EN1 = [12, 15]
            # self.PIN_MOTOR_EN2 = [13, 2]
            self.PIN_CHARGING_DISABLE = 0  #D3
            self.PIN_WAKEUP = 16  #D0
            self.PIN_SCL = 5  #D1
            self.PIN_SDA = 4  #D2
        elif PCB_version == 3:
            self.PIN_LED = 16
            self.PIN_POWER_ENABLE = 16
            self.PIN_MOTOR1_ENABLES = (5, 17)
            self.PIN_MOTOR2_ENABLES = (18, 19)
            self.PIN_CHARGING_DISABLE = 21
            self.PIN_SCL = 22
            self.PIN_SDA = 23
            self.LM75B_ADDR = 0x4F  # 79 decimal
            self.ATECC508_ADDR = 0x60  # 96 decimal
        else:
            import sys
            logger.error("Unknown PCB_rev: %d", PCB_rev)
            sys.exit(1)

        self.I2C_FREQ = 100000
        # self.INA219_ADDR = 0x40 #64 on the adafruit module
        self.INA219_ADDR = 0x45  #69 decimal

        self.ppin_led = None
        self.ppin_power_enable = machine.Pin(self.PIN_POWER_ENABLE,
                                             machine.Pin.OUT,
                                             value=0)
        self.ppin_charging_disable = machine.Pin(self.PIN_CHARGING_DISABLE,
                                                 machine.Pin.OUT,
                                                 value=1)
        self.i2c = machine.I2C(scl=machine.Pin(self.PIN_SCL),
                               sda=machine.Pin(self.PIN_SDA),
                               freq=self.I2C_FREQ)
        # the following is commented out to save power
        # i2c_devices = None
        # try:
        #     i2c_devices = self.i2c.scan()
        # except:
        #     print("Exception i2c bus scan")
        # if (len(i2c_devices) < 1):
        #     print("No i2c devices detected")
        self.current_sensor = None

        # the following are shade direction constants that make it easier to understand motor direction
        self.LOWER = 0
        self.RAISE = 1
        self.MOTOR_START_SPEED = 30  # speed is in percentage
        self.MOTOR_SPEED_RAMP = 5  # increments to speed up the motor, in percentage
        self.MOTOR_SENSOR_SAMPLE_INTERVAL = 10  # 10 milliSeconds between current samples when the motor is on
        self.MOTOR_AVERAGING_SAMPLES = 4  # the current is sampled this many times because it may be noisy due to the motor

        import array
        # pre-allocate current sample arrays - used by the position routine to threshold motor currents
        self.STARTING_CURRENT_SAMPLE_COUNT = 16
        self.starting_currents = array.array(
            'i', (0 for _ in range(self.STARTING_CURRENT_SAMPLE_COUNT)))
        self.starting_current_next = 0
        self.STOPPING_CURRENT_SAMPLE_COUNT = 16
        self.stopping_currents = array.array(
            'i', (0 for _ in range(self.STOPPING_CURRENT_SAMPLE_COUNT)))
        self.stopping_current_next = 0
        #the following are used by _activate_motor to detect current threshold crossing
        self.averaging_sum = 0
        self.average_current_threshold = 0

    def connect(self):
        """ activates the wlan and polls to see if connected
            returns a tuple:
              - a boolean to indicate successful connection or not
              - a msg to display if connection failed
        """
        import esp, network
        from sys import platform
        from utime import sleep_ms
        from setwifi import setwifi as setwifi

        wlan = network.WLAN(network.STA_IF)
        wlan.active(True)
        if platform == 'esp32':
            cfg_info = self._get_cfg_info("wifi_info.txt")
            # cfg_info = {"SSID": "xx", "password": "******"}
            if not cfg_info:
                setwifi()
            # setwifi should write the wifi_info file, so read it
            cfg_info = self._get_cfg_info("wifi_info.txt")
            if not cfg_info:
                return False, "Error: could not obtain wifi configuration"
            wlan.connect(cfg_info['SSID'], cfg_info['password'])

        connected = False
        for _ in range(180):
            connected = wlan.isconnected()
            if connected:
                return True, None
            else:
                sleep_ms(33)
        if not connected:
            setwifi()
            return False, "Warning: unable to connect to WiFi; setWiFi run to get new credentials"

    @property
    def id(self):
        from machine import unique_id
        id_reversed = unique_id()
        id_binary = [
            id_reversed[n] for n in range(len(id_reversed) - 1, -1, -1)
        ]
        return "ESP-" + "".join("{:02x}".format(x) for x in id_binary)

    def time(self):
        from ntptime import time as get_ntp_time
        import utime

        # The shadow timestamp is from 1970-01-01 vs micropython is from 2000-01-01
        SECONDS_BETWEEN_1970_2000 = 946684800
        time_tuple = None
        last_exception = None
        if self._start_ticks is None:
            for i in range(11):
                utime.sleep_ms(333)
                try:
                    self._timestamp = get_ntp_time()
                    break
                except Exception as e:
                    last_exception = str(e)
                    logger.debug("Exception in get NTP: %s", last_exception)
                # the 1st NTP request after a hard reset and then an IP connect always fails, so retry quickly
                if i < 2:
                    utime.sleep_ms(33)
                else:
                    utime.sleep_ms(666)

            if self._timestamp is None:
                logger.error(
                    "Failed to get time from NTP after %d attempts; Last exception was '%s'.",
                    i + 1, last_exception)
            elif type(self._timestamp).__name__ == 'int':
                logger.debug("Recieved NTP timestamp after %d attempts", i + 1)
                try:
                    time_tuple = utime.localtime(self._timestamp)
                    # adjust the stored timestamp used for reporting conditions based on an interval
                    self._start_ticks = utime.ticks_ms()
                    self._timestamp += SECONDS_BETWEEN_1970_2000
                except Exception as e:
                    logger.error(
                        "Exception '%s' on timestamp conversion; timestamp: %d",
                        str(e), self._timestamp)
            else:
                logger.error("NTP timestamp not an int: %s", self._timestamp)
        else:
            # get updated time by adding elapsed time to existing timestamp
            #     - shift right 10 is approx equal to divide by 1000 in order to get seconds
            elapsed_secs = utime.ticks_diff(utime.ticks_ms(),
                                            self._start_ticks) >> 10
            time_tuple = utime.localtime(self._timestamp -
                                         SECONDS_BETWEEN_1970_2000 +
                                         elapsed_secs)
        return time_tuple

    def sleep(self, msg=None):
        import machine
        from sys import platform
        from utime import sleep_ms
        try:
            import webrepl
        except:
            webrepl = None

        LOG_FILENAME = "./log.txt"
        if msg is not None:
            logger.warning(msg)
            with open(LOG_FILENAME, 'a') as log_file:
                log_file.write(msg + "\n")

        if self.current_sensor is not None:
            self.current_sensor.stop()

        if self._current_state['params']['sleep'] < 1:
            # exit: stop the infinite loop of main & deep-sleep
            from sys import exit
            logger.info("Staying awake due to sleep parameter < 1.")
            if webrepl is not None:
                webrepl.start()
            # configure timer to issue reset, so the device will reboot and fetch a new shadow state
            TIME_BEFORE_RESET = 120000  # 3 minutes in milliseconds
            tim = machine.Timer(-1)
            # tim.init throws an OSError 261 after a soft reset; this is a work-around:
            try:
                tim.init(period=TIME_BEFORE_RESET,
                         mode=machine.Timer.ONE_SHOT,
                         callback=lambda t: machine.reset())
            except Exception as e:
                logger.warning(
                    "Exception '%s' on tim.init; No reset after a timer expiry.",
                    e)
            exit(0)

        if webrepl is not None:
            webrepl.stop()

        logger.info("Going to sleep for %s seconds.",
                    self._current_state['params']['sleep'])
        if platform == 'esp32':
            # multiply sleep time by approx 1000 (left shift by 10)
            machine.deepsleep(self._current_state['params']['sleep'] << 10)
        else:
            self.rtc.irq(trigger=self.rtc.ALARM0, wake=machine.DEEPSLEEP)
            self.rtc.alarm(self.rtc.ALARM0,
                           self._current_state['params']['sleep'] << 10)
            machine.deepsleep()

    def _reported_state_get(self):
        # add current arrays as strings to report
        if self.starting_currents[0] != 0:
            report_conditions_time_based = True  #update conditions report after operating the motor
            currents = ""
            for i in self.starting_currents:
                currents = currents + str(i) + " "
            # remove trailing space
            self._reported_state['starting_currents'] = currents[:-1]

            # stopping currents start at next and loop around
            currents = ""
            idx = self.stopping_current_next
            for _ in range(self.STOPPING_CURRENT_SAMPLE_COUNT):
                currents = currents + str(self.stopping_currents[idx]) + " "
                idx = idx + 1
                if idx > (self.STOPPING_CURRENT_SAMPLE_COUNT - 1):
                    idx = 0
            self._reported_state['stopping_currents'] = currents[:-1]
        return super()._reported_state_get()

    reported_state = property(_reported_state_get)

    def _shadow_state_get(self):
        return super()._shadow_state_get()

    def _shadow_state_set(self, shadow_state):
        if self._has_history and self._restored_state['history'][0][
                'done'] != 1:
            # The operation didn't finished, so update the status to be reflected in an updated report
            failed_operation = self._restored_state['history'][0]['op']
            self._current_state['params'][failed_operation] = "unknown"
        super()._shadow_state_set(shadow_state)

    shadow_state = property(_shadow_state_get, _shadow_state_set)

    def blink_led(self, t=50):
        import machine
        from utime import sleep_ms
        if self.ppin_led is None:
            self.ppin_led = machine.Pin(self.PIN_LED, machine.Pin.OUT, value=0)
        else:
            self.ppin_led.init(machine.Pin.OUT)
        sleep_ms(t)
        # leave the pin as an input to not mess up any pin state in reset requirements
        self.ppin_led.init(machine.Pin.IN)

    def _persist_state(self):
        """ the ESP can use RTC memory for a persistent store instead of the flash filesystem"""
        import ujson
        self.rtc.memory(ujson.dumps(self._current_state))

    def _restore_state(self):
        import ujson
        try:
            tmp = ujson.loads(self.rtc.memory())
            logger.debug("restored state: %s", tmp)
            if type(tmp) is not dict or 'params' not in tmp:
                logger.warning(
                    "_restore_state: RTC memory did not have parameters")
                tmp = {}
        except:
            logger.warning("_restore_state: RTC memory was not JSON")
            tmp = {}
        return tmp

    def _position(self):
        """ validates shadow state variables: position, duration, reverse -- and then calls _activate_motor
            Inputs: shadow_state
            Returns: status string
        """
        status = self._instance_current_sensor()
        if status is not None:
            return "Fail (position): " + status

        MAX_DURATION = 59
        POSITIONS = ['open', 'closed', 'half']

        class Positions:
            OPEN = 0
            CLOSED = 1
            HALF = 2

        if self._shadow_state['state']['desired']['position'] not in POSITIONS:
            return "Error: unrecognized position: {0}".format(
                self._shadow_state['state']['desired']['position'])
        if self._shadow_state['state']['desired']['duration'] > MAX_DURATION:
            return "Error: duration: {0} is longer than max value: {1}".format(
                self._shadow_state['state']['desired']['duration'],
                MAX_DURATION)
        if self._shadow_state['state']['desired']['duration'] < 1:
            return "Error: duration: {0} is zero or negative".format(
                self._shadow_state['state']['desired']['duration'])

        # if POST fails, then AWS-IOT state could mismatch persisted/real state
        if self._current_state['params']['position'] == self._shadow_state[
                'state']['desired']['position']:
            return "Already in position: " + self._shadow_state['state'][
                'desired']['position']

        duration = self._shadow_state['state']['desired'][
            'duration'] * 1000  #convert to millisecond

        direction = self.LOWER
        if self._shadow_state['state']['desired']['position'] == POSITIONS[
                Positions.OPEN]:
            direction = self.RAISE
        # halve the duration if currently in the half position or going to the half position
        if self._shadow_state['state']['desired']['position'] == POSITIONS[
                Positions.HALF]:
            duration = duration >> 1
            if self._current_state['params']['position'] == POSITIONS[
                    Positions.CLOSED]:
                direction = self.RAISE
        # if the current position is unknown, the direction will be to lower, and the current position will stay unknown.
        if self._current_state['params']['position'] == POSITIONS[
                Positions.HALF]:
            duration = duration >> 1

        # invert direction if shade is of type 'top_down', as indicated by bit 1: 0x0010
        if (self._shadow_state['state']['desired']['reverse'] & 2) != 0:
            direction = direction ^ 1

        # dont move much when lowering if position is unknown since the current sensor can't be used to figure the stopping position
        if self._current_state['params'][
                'position'] not in POSITIONS and direction == self.LOWER:
            duration = 200

        # it takes longer to go the same distance when raising, so increase the duration by ??30%
        if direction == self.RAISE:
            duration = duration + (duration >> 2)  # + (duration >> 4)

        measured_duration = self._activate_motor(duration, direction,
                                                 self.PIN_MOTOR1_ENABLES)
        if measured_duration > 1:
            if direction == self.RAISE or measured_duration >= duration:
                self._current_state['params']['position'] = self._shadow_state[
                    'state']['desired']['position']
            else:
                self._current_state['params']['position'] = 'unknown'

            status = "Done: new position: {0}; motor on for: {1} msec".format(
                self._current_state['params']['position'], measured_duration)
            if self.averaging_sum > self.average_current_threshold:
                status = status + "; Current: {0} over Threshold: {1}".format(
                    self.averaging_sum, self.average_current_threshold)
        else:
            status = "Error on position; I2C error: {0}".format(
                measured_duration)
        return status

    def _set_position(self):
        """ Used to set the persisted 'position' to the current desired position.
            Normally used to transition out of the position==unknown state
            """
        self._current_state['params']['position'] = self._shadow_state[
            'state']['desired']['position']
        return "position set to: " + self._current_state['params']['position']

    def _test_current_sensor(self):
        status = self._instance_current_sensor()
        if self.current_sensor is None:
            status = "Fail (current test): " + status
        else:
            self.current_sensor.start()
            mAmps = self.current_sensor.get_current_ma()
            mVolts = self.current_sensor.get_bus_mv()
            status = "Pass: Current: {0:d}  BusVolts: {1:d}".format(
                mAmps, mVolts)
        return status

    def _test_motor(self):
        return self._test_motor_base(self.PIN_MOTOR1_ENABLES)

    def _test_motor2(self):
        return self._test_motor_base(self.PIN_MOTOR2_ENABLES)

    def _test_motor_base(self, pins):
        """ Operates the motor for the number of milliseconds specified in test_param
            A negative test_param operates the motor in the reverse direction
            """
        if not self._has_history:
            status = "Skipping first motor test after initialization"
        else:
            status = self._instance_current_sensor()
            if status is not None:
                status = "Fail (motor test): " + status
            else:
                duration = self._shadow_state['state']['desired']['test_param']
                if duration < 0:
                    direction = self.LOWER
                else:
                    direction = self.RAISE
                duration = abs(duration)
                if duration < 55000:
                    measured_duration = self._activate_motor(
                        duration, direction, pins)
                    if measured_duration >= duration:
                        status = "Pass: motor on for " + str(
                            measured_duration) + " msec."
                    else:
                        status = "Fail: motor on for " + str(
                            measured_duration) + " msec."
                else:
                    status = "Fail: test_param too large for motor test: " + str(
                        duration)
        return status

    def _instance_current_sensor(self):
        from ina219 import INA219
        status = None
        if self.current_sensor is None:
            if self.i2c is None:
                status = "I2C not initialized when creating current sensor"
            else:
                try:
                    self.current_sensor = INA219(i2c=self.i2c,
                                                 i2c_addr=self.INA219_ADDR)
                    if not self.current_sensor.in_standby_when_initialized:
                        logger.warning("Current sensor not in standby.")
                except:
                    status = "I2C access to current sensor failed"
        return status

    def _activate_motor(self, duration, direction, pins):
        """Instantiates a motor and turns on the motor driver for the duration (expressed in milliseconds)
           self.current_sensor should have been instantiated before calling
            """
        from motor import Motor
        import machine, utime

        elapsed_time = 0
        self.average_current_threshold = self._shadow_state['state'][
            'desired']['threshold'] * self.MOTOR_AVERAGING_SAMPLES

        #invert direction if reverse bit is set
        motor_direction = direction ^ (
            self._shadow_state['state']['desired']['reverse'] & 1)
        # self.motor = Motor(self.PIN_MOTOR_ENABLE1, self.PIN_MOTOR_ENABLE2)
        self.motor = Motor(pins)

        #enable 12V and disable charging
        if self.ppin_power_enable is None:
            self.ppin_power_enable = machine.Pin(self.PIN_POWER_ENABLE,
                                                 machine.Pin.OUT,
                                                 value=1)
        else:
            self.ppin_power_enable.value(1)

        if self.ppin_charging_disable is None:
            self.ppin_charging_disable = machine.Pin(self.PIN_CHARGING_DISABLE,
                                                     machine.Pin.OUT,
                                                     value=0)
        else:
            self.ppin_charging_disable.value(0)
        utime.sleep_ms(50)  # wait for power to stabilize

        self.current_sensor.start()
        start_ticks = utime.ticks_ms()
        self.motor.start(direction=motor_direction,
                         speed=self.MOTOR_START_SPEED)

        while elapsed_time < duration:
            sample_ticks_begin = utime.ticks_ms()
            current_sample = self._update_current_arrays()

            # !! TODO: stop calling adjustSpeed after calling it N times
            if (current_sample <
                    self._shadow_state['state']['desired']['threshold']):
                self.motor.adjust_speed(self.MOTOR_SPEED_RAMP)

            # check the avg of the last N samples don't exceed the threshold
            self.averaging_sum = 0
            for averaging_offset in range(-self.MOTOR_AVERAGING_SAMPLES, 0):
                averaging_index = self.stopping_current_next + averaging_offset
                if (averaging_index < 0):
                    averaging_index += self.STOPPING_CURRENT_SAMPLE_COUNT
                self.averaging_sum += self.stopping_currents[averaging_index]
                # print("Index: {0} -- Value: {1} -- Sum: {2}".format(averaging_index, self.stopping_currents[averaging_index], self.averaging_sum))

            # stop the motor if over the threshold
            if self.averaging_sum > self.average_current_threshold:
                break

            delay_time = self.MOTOR_SENSOR_SAMPLE_INTERVAL - (
                utime.ticks_ms() - sample_ticks_begin)
            utime.sleep_ms(delay_time)
            elapsed_time = utime.ticks_ms() - start_ticks

        self.motor.stop()
        self.ppin_power_enable.value(0)
        self.ppin_charging_disable.value(1)
        # re-init pins so they are tri-state
        self.ppin_power_enable.init(machine.Pin.IN)
        self.ppin_charging_disable.init(machine.Pin.IN)
        self.motor.deinit()
        del self.motor
        return elapsed_time

    def _update_current_arrays(self):
        import utime
        #assumes caller has already instanced & checked & started the sensor

        current_sample = self.current_sensor.get_current_ma()
        for samples in range(3):
            utime.sleep_ms(5)
            current_sample += self.current_sensor.get_current_ma()
        current_sample = current_sample >> 2  #take average of 4 samples

        if (self.starting_current_next < self.STARTING_CURRENT_SAMPLE_COUNT):
            self.starting_currents[self.starting_current_next] = current_sample
            self.starting_current_next += 1

        # continuously update stopping array; when at end, loop back to the beginning
        self.stopping_currents[self.stopping_current_next] = current_sample
        self.stopping_current_next += 1
        if (self.stopping_current_next >
                self.STOPPING_CURRENT_SAMPLE_COUNT - 1):
            self.stopping_current_next = 0
        return current_sample

    def get_battery_voltage(self):
        mVolts = -1
        status = self._instance_current_sensor()
        if status is None:
            self.current_sensor.start()
            mVolts = self.current_sensor.get_bus_mv()
        return mVolts

    def get_temperature(self):
        from utime import sleep_ms
        cfg = self.i2c.readfrom(self.LM75B_ADDR, 1)
        if not (cfg[0] & 0x01):
            logger.warning("Temperature sensor not shutdown.")
            self.i2c.writeto_mem(
                self.LM75B_ADDR, 1,
                b'\x00')  # write cfg register to take out of shutdown state
            sleep_ms(105)  # wait for a conversion period
        value = bytearray(2)
        self.i2c.readfrom_mem_into(self.LM75B_ADDR, 0, value)
        rounding = (value[1] &
                    0x80) >> 7  #if between 0.5 and 0.875 then round up or down
        if (value[0] & 0x80):
            # negative temp
            t = value[0] - 0x100 - rounding
        else:
            t = value[0] + rounding
        self.i2c.writeto_mem(
            self.LM75B_ADDR, 1,
            b'\x01')  # write cfg register to put into shutdown state
        return t

    def get_pwr_in_voltage(self):
        from machine import ADC, Pin
        adc_35 = ADC(Pin(35))
        adc_35.atten(ADC.ATTN_11DB)
        DIVIDER_COEFF = 2.1  # why is this 2.1 instead of 2 ?
        return DIVIDER_COEFF * adc_35.read() * 3.3 / 4096