diff options
Diffstat (limited to 'circuitpython/frozen/Adafruit_CircuitPython_SimpleIO/simpleio.py')
| -rw-r--r-- | circuitpython/frozen/Adafruit_CircuitPython_SimpleIO/simpleio.py | 252 |
1 files changed, 252 insertions, 0 deletions
diff --git a/circuitpython/frozen/Adafruit_CircuitPython_SimpleIO/simpleio.py b/circuitpython/frozen/Adafruit_CircuitPython_SimpleIO/simpleio.py new file mode 100644 index 0000000..5aa014c --- /dev/null +++ b/circuitpython/frozen/Adafruit_CircuitPython_SimpleIO/simpleio.py @@ -0,0 +1,252 @@ +# SPDX-FileCopyrightText: 2017 Scott Shawcroft for Adafruit Industries +# +# SPDX-License-Identifier: MIT + +""" +`simpleio` - Simple, beginner friendly IO. +================================================= + +The `simpleio` module contains classes to provide simple access to IO. + +* Author(s): Scott Shawcroft +""" +import time +import sys +import array +import digitalio +import pwmio + +try: + # RawSample was moved in CircuitPython 5.x. + if sys.implementation.version[0] >= 5: + import audiocore + else: + import audioio as audiocore + # Some boards have AudioOut (true DAC), others have PWMAudioOut. + try: + from audioio import AudioOut + except ImportError: + from audiopwmio import PWMAudioOut as AudioOut +except ImportError: + pass # not always supported by every board! + +__version__ = "0.0.0-auto.0" +__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_SimpleIO.git" + + +def tone(pin, frequency, duration=1, length=100): + """ + Generates a square wave of the specified frequency on a pin + + :param ~microcontroller.Pin pin: Pin on which to output the tone + :param float frequency: Frequency of tone in Hz + :param int length: Variable size buffer (optional) + :param int duration: Duration of tone in seconds (optional) + """ + if length * frequency > 350000: + length = 350000 // frequency + try: + # pin with PWM + # pylint: disable=no-member + with pwmio.PWMOut( + pin, frequency=int(frequency), variable_frequency=False + ) as pwm: + pwm.duty_cycle = 0x8000 + time.sleep(duration) + # pylint: enable=no-member + except ValueError: + # pin without PWM + sample_length = length + square_wave = array.array("H", [0] * sample_length) + for i in range(sample_length / 2): + square_wave[i] = 0xFFFF + square_wave_sample = audiocore.RawSample(square_wave) + square_wave_sample.sample_rate = int(len(square_wave) * frequency) + with AudioOut(pin) as dac: + if not dac.playing: + dac.play(square_wave_sample, loop=True) + time.sleep(duration) + dac.stop() + + +def bitWrite(x, n, b): # pylint: disable-msg=invalid-name + """ + Based on the Arduino bitWrite function, changes a specific bit of a value to 0 or 1. + The return value is the original value with the changed bit. + This function is written for use with 8-bit shift registers + + :param x: numeric value + :param n: position to change starting with least-significant (right-most) bit as 0 + :param b: value to write (0 or 1) + """ + if b == 1: + x |= 1 << n & 255 + else: + x &= ~(1 << n) & 255 + return x + + +def shift_in(data_pin, clock, msb_first=True): + """ + Shifts in a byte of data one bit at a time. Starts from either the LSB or + MSB. + + .. warning:: Data and clock are swapped compared to other CircuitPython libraries + in order to match Arduino. + + :param ~digitalio.DigitalInOut data_pin: pin on which to input each bit + :param ~digitalio.DigitalInOut clock: toggles to signal data_pin reads + :param bool msb_first: True when the first bit is most significant + :return: returns the value read + :rtype: int + """ + + value = 0 + i = 0 + + for i in range(0, 8): + if msb_first: + value |= (data_pin.value) << (7 - i) + else: + value |= (data_pin.value) << i + # toggle clock True/False + clock.value = True + clock.value = False + i += 1 + return value + + +def shift_out(data_pin, clock, value, msb_first=True, bitcount=8): + """ + Shifts out a byte of data one bit at a time. Data gets written to a data + pin. Then, the clock pulses hi then low + + .. warning:: Data and clock are swapped compared to other CircuitPython libraries + in order to match Arduino. + + :param ~digitalio.DigitalInOut data_pin: value bits get output on this pin + :param ~digitalio.DigitalInOut clock: toggled once the data pin is set + :param bool msb_first: True when the first bit is most significant + :param int value: byte to be shifted + :param unsigned bitcount: number of bits to shift + + Example for Metro M0 Express: + + .. code-block:: python + + import digitalio + import simpleio + from board import * + clock = digitalio.DigitalInOut(D12) + data_pin = digitalio.DigitalInOut(D11) + latchPin = digitalio.DigitalInOut(D10) + clock.direction = digitalio.Direction.OUTPUT + data_pin.direction = digitalio.Direction.OUTPUT + latchPin.direction = digitalio.Direction.OUTPUT + + while True: + valueSend = 500 + # shifting out least significant bits + # must toggle latchPin.value before and after shift_out to push to IC chip + # this sample code was tested using + latchPin.value = False + simpleio.shift_out(data_pin, clock, (valueSend>>8), msb_first = False) + latchPin.value = True + time.sleep(1.0) + latchPin.value = False + simpleio.shift_out(data_pin, clock, valueSend, msb_first = False) + latchPin.value = True + time.sleep(1.0) + + # shifting out most significant bits + latchPin.value = False + simpleio.shift_out(data_pin, clock, (valueSend>>8)) + latchPin.value = True + time.sleep(1.0) + latchpin.value = False + simpleio.shift_out(data_pin, clock, valueSend) + latchpin.value = True + time.sleep(1.0) + """ + if bitcount < 0 or bitcount > 32: + raise ValueError("bitcount must be in range 0..32 inclusive") + + if msb_first: + bitsequence = lambda: range(bitcount - 1, -1, -1) + else: + bitsequence = lambda: range(0, bitcount) + + for i in bitsequence(): + tmpval = bool(value & (1 << i)) + data_pin.value = tmpval + # toggle clock pin True/False + clock.value = True + clock.value = False + + +class DigitalOut: + """ + Simple digital output that is valid until reload. + + :param pin microcontroller.Pin: output pin + :param value bool: default value + :param drive_mode digitalio.DriveMode: drive mode for the output + """ + + def __init__(self, pin, **kwargs): + self.iopin = digitalio.DigitalInOut(pin) + self.iopin.switch_to_output(**kwargs) + + @property + def value(self): + """The digital logic level of the output pin.""" + return self.iopin.value + + @value.setter + def value(self, value): + self.iopin.value = value + + +class DigitalIn: + """ + Simple digital input that is valid until reload. + + :param pin microcontroller.Pin: input pin + :param pull digitalio.Pull: pull configuration for the input + """ + + def __init__(self, pin, **kwargs): + self.iopin = digitalio.DigitalInOut(pin) + self.iopin.switch_to_input(**kwargs) + + @property + def value(self): + """The digital logic level of the input pin.""" + return self.iopin.value + + @value.setter + def value(self, value): # pylint: disable-msg=no-self-use, unused-argument + raise AttributeError("Cannot set the value on a digital input.") + + +def map_range(x, in_min, in_max, out_min, out_max): + """ + Maps a number from one range to another. + Note: This implementation handles values < in_min differently than arduino's map function does. + + :return: Returns value mapped to new range + :rtype: float + """ + in_range = in_max - in_min + in_delta = x - in_min + if in_range != 0: + mapped = in_delta / in_range + elif in_delta != 0: + mapped = in_delta + else: + mapped = 0.5 + mapped *= out_max - out_min + mapped += out_min + if out_min <= out_max: + return max(min(mapped, out_max), out_min) + return min(max(mapped, out_max), out_min) |