Beispiel #1
0
    def __init__(self, serialDev):
        self.logger = logging.getLogger('BleuettePi')

        self.serial = Serial()
        self.serial.connect(serialDev)

        self.mcp = MCP230XX(self.MCP_ADDRESS, 16)

        self.Servo = Servo.Servo(self.serial, fakemode=Config.FAKE_MODE)
        self.Servo.init()

        Servo.Servo_Trim.values = Data.Instance().get(['servo', 'trims'])
        Servo.Servo_Limit.values = Data.Instance().get(['servo', 'limits'])

        self.Analog = Analog(self.serial)

        self.Compass = BleuettePi_Compass()
        self.Accelerometer = BleuettePi_Accelerometer()
        self.GroundSensor = BleuettePi_GroundSensor(self.mcp)

        # Init mode
        GPIO.setmode(GPIO.BOARD)

        GPIO.setup(self.INTA, GPIO.IN)
        GPIO.setup(self.INTB, GPIO.IN)
        GPIO.setup(self.INTC, GPIO.IN)
        GPIO.setup(self.INTD, GPIO.IN)

        GPIO.add_event_detect(self.INTA,
                              GPIO.RISING,
                              callback=self.interrupt,
                              bouncetime=300)
        GPIO.add_event_detect(self.INTB,
                              GPIO.RISING,
                              callback=self.interrupt,
                              bouncetime=300)
        GPIO.add_event_detect(self.INTC,
                              GPIO.RISING,
                              callback=self.interrupt,
                              bouncetime=300)
        GPIO.add_event_detect(self.INTD,
                              GPIO.RISING,
                              callback=self.interrupt,
                              bouncetime=300)

        self.mcp.config(self.RESET_PIN, MCP230XX.OUTPUT)
        #self.mcp.pullup(self.RESET_PIN, True)
        self.mcp.output(self.RESET_PIN, 1)
Beispiel #2
0
    def on_message(self, message):
        global logger
        logger.info("Message : %s" % message)

        data = json.loads(message)

        CMD_SET = 'set'
        CMD_DRIVE = 'drive'
        CMD_CONFIG = 'config'
        CMD_CONTROL = 'control'
        CMD_SEQUENCE = 'sequence'
        CMD_SERVO = 'servo'

        try:
            if data['cmd'] == CMD_SET:
                if data['type'] == 'livemode':
                    if data['status']:
                        B.Sequencer.Servo.setCallback(self.livemode)
                    else:
                        B.Sequencer.Servo.removeCallback()
                elif data['type'] == 'loglevel':

                    if data['which'] == 'js':
                        _logger = jsHandler
                        #Data.Instance().set(['log', 'js'], data['level'])
                    else:
                        _logger = rainbowHandler
                        #Data.Instance().set(['log', 'default'], data['level'])
                    print(data)
                    #Data.Instance().save()

                    if data['level'] == 'debug':
                        _logger.setLevel(logging.DEBUG)
                    elif data['level'] == 'info':
                        _logger.setLevel(logging.INFO)
                    elif data['level'] == 'warning':
                        _logger.setLevel(logging.WARNING)
                    elif data['level'] == 'error':
                        _logger.setLevel(logging.ERROR)
                    elif data['level'] == 'warning':
                        _logger.setLevel(logging.CRITICAL)

                #print logger.getEffectiveLevel()

            elif data['cmd'] == CMD_DRIVE:

                if data['status'] == 'begin':
                    if data['direction'] == 'forward':
                        B.Drive.forward()
                    elif data['direction'] == 'reverse':
                        B.Drive.reverse()
                    elif data['direction'] == 'left':
                        B.Drive.left()
                    elif data['direction'] == 'right':
                        B.Drive.right()
                elif data['status'] == 'end':
                    B.Drive.end()

            elif data['cmd'] == CMD_CONFIG:
                pass
            elif data['cmd'] == CMD_CONTROL:

                if data['action'] == 'reset':
                    B.BPi.reset()

            elif data['cmd'] == CMD_SEQUENCE:

                if data['name'] == 'middle':
                    B.Sequencer.forward(Sequences['middle'], 1)
                elif data['name'] == 'pushup':
                    B.Sequencer.forward(Sequences['pushup'], 1)
                elif data['name'] == 'standby':
                    B.Sequencer.forward(Sequences['standby'], 1)
                elif data['name'] == 'release':
                    B.Sequencer.forward(Sequences['release'], 1)

            elif data['cmd'] == CMD_SERVO:

                if data['action'] == 'init':
                    B.Sequencer.Servo.init()
                elif data['action'] == 'pause':
                    B.Sequencer.Servo.pause()
                elif data['action'] == 'resume':
                    B.Sequencer.Servo.resume()
                elif data['action'] == 'save':
                    Data.Instance().set(['servo', 'trims'],
                                        Servo.Servo_Trim.values)
                    Data.Instance().set(['servo', 'limits'],
                                        Servo.Servo_Limit.values)
                    Data.Instance().save()
                elif data['action'] == 'trim':
                    with B.Sequencer.ServoSeq:
                        Servo.Servo_Trim.values[data['servo']] = data['value']
                elif data['action'] == 'limit':
                    with B.Sequencer.ServoSeq:
                        Servo.Servo_Limit.values[data['servo']] = [
                            data['min'], data['max']
                        ]
                elif data['action'] == 'position':
                    with B.Sequencer.ServoSeq:
                        B.Sequencer.ServoSeq.setPosition(
                            data['servo'], data['value'])
                elif data['action'] == 'speed':
                    global speed
                    speed = data['value']
                elif data['action'] == 'get':
                    config = {
                        'type': CMD_SERVO,
                        'data': {
                            'trims': Data.Instance().get(['servo', 'trims']),
                            'limits': Data.Instance().get(['servo', 'limits'])
                        }
                    }
                    self.write(json.dumps(config))

            else:
                logger.warning("Message : %s" % message)

        except Exception, e:
            logger.critical("Exception ! " + str(e))