def __setPowerOn(self):
     gpio.add_interrupt_callback(self.gpioFaultA,
                                 self.gpioCallback,
                                 threaded_callback=True,
                                 debounce_timeout_ms=100)
     gpio.add_interrupt_callback(self.gpioFaultB,
                                 self.gpioCallback,
                                 threaded_callback=True,
                                 debounce_timeout_ms=100)
     msgText = 'Power is ON for module ' + self.descr + '. Error monitor is now ON'
     print(msgText)
     sendAlertEmail(msgText, self)
Exemple #2
0
    def init_boundary_sensors(self, pins=None):
        if pins is not None:
            self.config.boundary_gpio_pins = pins

        # Init boundary pins
        for i in range(2):
            GPIO.setup(self.boundary_gpio_pins[i][0],
                       GPIO.IN,
                       pull_up_down=GPIO.PUD_UP)
            GPIO.setup(self.boundary_gpio_pins[i][1],
                       GPIO.IN,
                       pull_up_down=GPIO.PUD_UP)

        # Init callbacks
        bbt = self.boundary_bounce_timeout
        GPIO.add_interrupt_callback(self.boundary_gpio_pins[0][0],
                                    callback=self.on_hit_bound_min_x,
                                    debounce_timeout_ms=bbt)
        GPIO.add_interrupt_callback(self.boundary_gpio_pins[0][1],
                                    callback=self.on_hit_bound_max_x,
                                    debounce_timeout_ms=bbt)
        GPIO.add_interrupt_callback(self.boundary_gpio_pins[1][0],
                                    callback=self.on_hit_bound_min_y,
                                    debounce_timeout_ms=bbt)
        GPIO.add_interrupt_callback(self.boundary_gpio_pins[1][1],
                                    callback=self.on_hit_bound_max_y,
                                    debounce_timeout_ms=bbt)
Exemple #3
0
    def init_boundary_sensors(self, pins=None):
        if pins is not None:
            self.config.boundary_gpio_pins = pins

        # Init boundary pins
        for i in range(2):
            GPIO.setup(self.boundary_gpio_pins[i][0], GPIO.IN,
                       pull_up_down=GPIO.PUD_UP)
            GPIO.setup(self.boundary_gpio_pins[i][1], GPIO.IN,
                       pull_up_down=GPIO.PUD_UP)

        # Init callbacks
        bbt = self.boundary_bounce_timeout
        GPIO.add_interrupt_callback(self.boundary_gpio_pins[0][0],
                                    callback=self.on_hit_bound_min_x,
                                    debounce_timeout_ms=bbt)
        GPIO.add_interrupt_callback(self.boundary_gpio_pins[0][1],
                                    callback=self.on_hit_bound_max_x,
                                    debounce_timeout_ms=bbt)
        GPIO.add_interrupt_callback(self.boundary_gpio_pins[1][0],
                                    callback=self.on_hit_bound_min_y,
                                    debounce_timeout_ms=bbt)
        GPIO.add_interrupt_callback(self.boundary_gpio_pins[1][1],
                                    callback=self.on_hit_bound_max_y,
                                    debounce_timeout_ms=bbt)
Exemple #4
0
 def start(self):
     debug('debugGPIO', self.name, "using GPIO library", gpioLibrary)
     gpio.setwarnings(False)
     if self.interface:
         gpio.setmode(gpio.BCM)
         # configure the MCP23017
         self.interface.write(
             (self.addr, MCP23017Interface.IODIR + self.bank),
             self.inOut)  # I/O direction
         self.interface.write(
             (self.addr, MCP23017Interface.GPINTEN + self.bank),
             self.inOut)  # enable interrupts for inputs
         self.interface.write(
             (self.addr, MCP23017Interface.GPPU + self.bank),
             self.inOut)  # pull up resistors on inputs
         self.interface.write((self.addr, MCP23017Interface.IOCON),
                              0x04)  # interrupt pins are open drain
         # additional configuration
         for config in self.config:
             reg = config[0] + self.bank  # offset register with bank
             debug('debugGPIO', self.name, "start",
                   "addr: 0x%02x" % self.addr, "reg: 0x%02x" % reg,
                   "value: 0x%02x" % config[1])
             self.interface.write((self.addr, reg), config[1])
         # get the current state
         self.readState()
         # set up the interrupt handling
         if gpioLibrary == "RPIO":
             gpio.add_interrupt_callback(self.interruptPin,
                                         interruptCallback,
                                         edge="falling",
                                         pull_up_down=gpio.PUD_UP)
             gpio.wait_for_interrupts(threaded=True)
         elif gpioLibrary == "RPi.GPIO":
             gpio.setup(self.interruptPin,
                        gpio.IN,
                        pull_up_down=gpio.PUD_UP)
             gpio.add_event_detect(self.interruptPin,
                                   gpio.FALLING,
                                   callback=interruptCallback)
     else:  # direct only supports output - FIXME
         gpio.setmode(gpio.BOARD)
         for pin in MCP23017Interface.gpioPins:
             debug('debugGPIO', self.name, "setup", pin, gpio.OUT)
             gpio.setup(pin, gpio.OUT)
             debug('debugGPIO', self.name, "write", pin, 0)
             gpio.output(pin, 0)
    def __initializeGPIO(self):
        msgText = 'Initializing error monitor for module ' + self.descr
        print(msgText)

        import RPi.GPIO as gpio
        gpio.setmode(gpio.BCM)
        gpio.setup(self.gpioPowerUp, gpio.IN, pull_up_down=gpio.PUD_OFF)
        gpio.setup(self.gpioFaultA, gpio.IN, pull_up_down=gpio.PUD_UP)
        gpio.setup(self.gpioFaultB, gpio.IN, pull_up_down=gpio.PUD_UP)

        self.gpioPowerStatus = gpio.input(self.gpioPowerUp)
        gpio.add_interrupt_callback(self.gpioPowerUp,
                                    self.gpioCallback,
                                    threaded_callback=True,
                                    debounce_timeout_ms=100)

        self.__newStatus('initialized', self.gpioPowerUp)
        if self.gpioPowerStatus == self.gpioPowerAlertStatus:
            __setPowerOn()
        else:
            __setPowerOff()
        return
Exemple #6
0
backwardRight = 11
backwardLeft = 13
sleepSeconds = 1

GPIO.setmode(GPIO.BOARD)

GPIO.setup(forwardRight,GPIO.OUT)
GPIO.setup(backwardRight,GPIO.OUT)
GPIO.setup(backwardLeft,GPIO.OUT)
GPIO.setup(forwardLeft,GPIO.OUT)


def gpio_callback(gpio_id, val):
    print("gpio %s: %s" % (gpio_id, val))

GPIO.add_interrupt_callback(forwardRight, gpio_callback)


def goForward():
 #Go fordward for one second
 GPIO.output(forwardRight,True)
 GPIO.output(forwardLeft,True)
 time.sleep(sleepSeconds)
 GPIO.output(forwardRight,False)
 GPIO.output(forwardLeft,False)

def goBackward():
 #go backward for one second

 
 GPIO.output(backwardRight,True)