pled.py

pled.py

import time
import serial
import contextlib

DEVICE = '/dev/tty.usbmodemFD131'

DELAY = 0.01

class Serial:

    device = None
    serial = None
    debug = False
    verbose = True

    def __init__(self, device):
        self.serial = serial.Serial(device, baudrate=57600)
        self.device = device

    def send(self, string, read=False):
        if self.debug or self.verbose:
            print('%s' % (string))
        if not self.debug:
            self.serial.write(bytes('%s\r' % (string), 'ascii'))
        if read:
            # Eat response
            self.read()

    def read(self):
        if not self.debug:
            response = self.serial.readline().decode().strip()
        else:
            response = 'OK'
        if self.verbose:
            print("-> %s" % (response))
        return response if not self.debug else 'OK'

    def readline(self):
        return self.serial.readline().decode().strip()

class PowerLed():

    serial = None
    DELAY = .3

    CMD_START   = 'start'
    CMD_STOP    = 'stop'
    CMD_DUMP    = 'dump'
    CMD_PWM     = 'pwm'

    def __init__(self, device):
        self.serial = Serial(device)

    #def send_(self, cmd, response=False):
    #    self.serial.send(cmd, response)
    #    self.delay()

    def delay(self):
        time.sleep(self.DELAY)

    @contextlib.contextmanager
    def save_verbose(self):
        self.serial.send("verbose get")
        verbose = self.serial.read()
        self.send("verbose set 0")
        try:
            yield
        finally:
            # Restore verbose
            self.delay()
            self.send("verbose set %s" % (verbose))

    def send(self, cmd):
        self.serial.send(cmd)
        read = self.serial.read()
        if read != 'OK':
            print("Error while sending cmd : %s, returned : %s" % (cmd, read))
        self.delay()

    def readline(self):
        return self.serial.readline()

    def start(self):
        self.send(self.CMD_START)

    def stop(self):
        self.send(self.CMD_STOP)

    def profileSet(self, index, profile):
        with self.save_verbose():
            self.send('set profile %i' % (index))
            for attr in dir(profile):
                if attr[0:2] != '__':
                    self.send('set %s %i' % (attr.replace('_', ''), getattr(profile, attr)))
        self.delay()

    def profilePlay(self, profile):
        with self.save_verbose():
            self.send('set profile %i' % (profile))
            self.send(self.CMD_START)

    def dump(self):
        with self.save_verbose():
            self.send(self.CMD_DUMP)
            while True:
                response = self.readline()
                if response == 'OK':
                    break
                print(response)

    def pwm(self, pwm):
        self.send('%s %i' % (self.CMD_PWM, pwm))

class Profile:

    # Settings for rising
    rising_delay = 0    # Time interval between each pwm value (ms)
    rising_sleep = 0    # Time interval between rising and falling
    rising_min = 0      # Minimal value for PWM
    rising_max = 100    # Maximal value for PWM

    # Settings for falling
    falling_delay = 0
    falling_sleep = 0
    falling_min = 0
    falling_max = 100

class Profile_HighSpeed(Profile):
    rising_delay = 0
    rising_sleep = 0
    rising_min = 0
    rising_max = 255

    falling_delay = 0
    falling_sleep = 0
    falling_min = 0
    falling_max = 255

class Profile_LowSpeed(Profile):
    rising_delay = 200
    rising_sleep = 100
    rising_min = 0
    rising_max = 255

    falling_delay = 200
    falling_sleep = 100
    falling_min = 0
    falling_max = 255

if __name__ == '__main__':
    try:
        pled = PowerLed(DEVICE)

        '''
        pled.profileSet(0, Profile_HighSpeed())
        pled.profileSet(1, Profile_LowSpeed())
        '''

        pled.profilePlay(1)
        time.sleep(2)
        pled.profilePlay(0)

        '''
        import sys
        sys.exit()

        pled.stop()
        '''

        with pled.serial.save_verbose():
            while True:
                for i in range(0, 100):
                    pled.pwm(i)
                    time.sleep(0.1)

                for i in range(100, 0, -1):
                    pled.pwm(i)
                    time.sleep(0.1)

    except KeyboardInterrupt:
        pass
    finally:
        print('flush and close !')

Voici ma version, j'ai essayé de simplifier un peu

Au final il suffit de lancer le script avec le nom du profil à jouer : python pled.py high

import sys
import time
import serial

#
# python pled.py [low|high]
#

DEVICE = '/dev/ttyACM0'


class Serial:
    ''' read/write serial commands to to arduino '''

    device = None
    serial = None
    debug = False
    verbose = False

    def __init__(self, device):
        self.serial = serial.Serial(device, baudrate=57600)
        self.device = device

    def send(self, string, read=False):
        if self.debug or self.verbose:
            print('%s' % (string))
        if not self.debug:
            self.serial.write(bytes('%s\r' % (string)))
        if read:
            # Eat response
            self.read()

    def read(self):
        if not self.debug:
            response = self.serial.readline().decode().strip()
        else:
            response = 'OK'
        if self.verbose:
            print("-> %s" % (response))
        return response if not self.debug else 'OK'

    def readline(self):
        return self.serial.readline().decode().strip()

class PowerLed():
    ''' PowerLED API '''

    serial = None

    DELAY = 0.01

    CMD_START   = 'start'
    CMD_STOP    = 'stop'
    CMD_PWM     = 'pwm'

    def __init__(self, device):
        self.serial = Serial(device)

    def send(self, cmd):
        self.serial.send(cmd)
        read = self.serial.read()
        if read != 'OK':
            print("Error while sending cmd : %s, returned : %s" % (cmd, read))

    def readline(self):
        return self.serial.readline()

    def start(self):
        self.send(self.CMD_START)

    def stop(self):
        self.send(self.CMD_STOP)

    def set(self, name, value):
        self.send('set %s %i' % (name, value))

    def pwm(self, pwm):
        self.send('%s %i' % (self.CMD_PWM, pwm))

PROFILES = {
    'high': {
        'risingdelay'  : 1,        # Time interval between each pwm value (ms)
        'risingsleep'  : 0,        # Time interval between rising and falling
        'risingmin'    : 0,        # Minimal value for PWM
        'risingmax'    : 255,      # Maximal value for PWM
        'fallingdelay' : 1,
        'fallingsleep' : 0,
        'fallingmin'   : 0,
        'fallingmax'   : 255
    },
    'low': {
        'risingdelay'  : 100,
        'risingsleep'  : 50,
        'risingmin'    : 0,
        'risingmax'    : 10,
        'fallingdelay' : 100,
        'fallingsleep' : 50,
        'fallingmin'   : 0,
        'fallingmax'   : 10,
    }
}

if __name__ == '__main__':
    # python pled.py [low|high]
    pled = PowerLed(DEVICE)
    profile = len(sys.argv) > 1 and sys.argv[1] or 'low'
    # stop the led, update values and start loop
    pled.stop()
    for key, value in PROFILES.get(profile).items():
        pled.set(key, value)
    pled.start()