初始化提交
This commit is contained in:
王立帮
282
arduino-cli/libraries/PCF8574_Soft/PCF8574_Soft.cpp
Normal file
282
arduino-cli/libraries/PCF8574_Soft/PCF8574_Soft.cpp
Normal file
@@ -0,0 +1,282 @@
|
||||
/*
|
||||
* See header file for details
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify\n
|
||||
* it under the terms of the GNU General Public License as published by\n
|
||||
* the Free Software Foundation, either version 3 of the License, or\n
|
||||
* (at your option) any later version.\n
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,\n
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of\n
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n
|
||||
* GNU General Public License for more details.\n
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License\n
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.\n
|
||||
*/
|
||||
|
||||
/* Dependencies */
|
||||
#include <SoftwareWire.h>
|
||||
#include "PCF8574_Soft.h"
|
||||
#ifdef PCF8574_Soft_INTERRUPT_SUPPORT
|
||||
#include "PCint.h"
|
||||
#endif
|
||||
|
||||
PCF8574_Soft::PCF8574_Soft() :
|
||||
_PORT(0), _PIN(0), _DDR(0), _address(0)
|
||||
#ifdef PCF8574_Soft_INTERRUPT_SUPPORT
|
||||
, _oldPIN(0), _isrIgnore(0), _pcintPin(0), _intMode(), _intCallback()
|
||||
#endif
|
||||
{
|
||||
}
|
||||
|
||||
void PCF8574_Soft::begin(uint8_t address, SoftwareWire *theWire) {
|
||||
|
||||
/* Store the I2C address and init the Wire library */
|
||||
_wire = theWire;
|
||||
_address = address;
|
||||
_wire->begin();
|
||||
readGPIO();
|
||||
}
|
||||
|
||||
void PCF8574_Soft::pinMode(uint8_t pin, uint8_t mode) {
|
||||
|
||||
/* Switch according mode */
|
||||
switch (mode) {
|
||||
case INPUT:
|
||||
_DDR &= ~(1 << pin);
|
||||
_PORT &= ~(1 << pin);
|
||||
break;
|
||||
|
||||
case INPUT_PULLUP:
|
||||
_DDR &= ~(1 << pin);
|
||||
_PORT |= (1 << pin);
|
||||
break;
|
||||
|
||||
case OUTPUT:
|
||||
_DDR |= (1 << pin);
|
||||
_PORT &= ~(1 << pin);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
/* Update GPIO values */
|
||||
updateGPIO();
|
||||
}
|
||||
|
||||
void PCF8574_Soft::digitalWrite(uint8_t pin, uint8_t value) {
|
||||
|
||||
/* Set PORT bit value */
|
||||
if (value)
|
||||
_PORT |= (1 << pin);
|
||||
else
|
||||
_PORT &= ~(1 << pin);
|
||||
|
||||
/* Update GPIO values */
|
||||
updateGPIO();
|
||||
}
|
||||
|
||||
uint8_t PCF8574_Soft::digitalRead(uint8_t pin) {
|
||||
|
||||
/* Read GPIO */
|
||||
readGPIO();
|
||||
|
||||
#ifdef PCF8574_Soft_INTERRUPT_SUPPORT
|
||||
/* Check for interrupt (manual detection) */
|
||||
//checkForInterrupt();
|
||||
#endif
|
||||
|
||||
/* Read and return the pin state */
|
||||
return (_PIN & (1 << pin)) ? HIGH : LOW;
|
||||
}
|
||||
|
||||
void PCF8574_Soft::write(uint8_t value) {
|
||||
|
||||
/* Store pins values and apply */
|
||||
_PORT = value;
|
||||
|
||||
/* Update GPIO values */
|
||||
updateGPIO();
|
||||
}
|
||||
|
||||
uint8_t PCF8574_Soft::read() {
|
||||
|
||||
/* Read GPIO */
|
||||
readGPIO();
|
||||
|
||||
#ifdef PCF8574_Soft_INTERRUPT_SUPPORT
|
||||
/* Check for interrupt (manual detection) */
|
||||
//checkForInterrupt();
|
||||
#endif
|
||||
|
||||
/* Return current pins values */
|
||||
return _PIN;
|
||||
}
|
||||
|
||||
void PCF8574_Soft::pullUp(uint8_t pin) {
|
||||
|
||||
/* Same as pinMode(INPUT_PULLUP) */
|
||||
pinMode(pin, INPUT_PULLUP); // /!\ pinMode form THE LIBRARY
|
||||
}
|
||||
|
||||
void PCF8574_Soft::pullDown(uint8_t pin) {
|
||||
|
||||
/* Same as pinMode(INPUT) */
|
||||
pinMode(pin, INPUT); // /!\ pinMode form THE LIBRARY
|
||||
}
|
||||
|
||||
void PCF8574_Soft::clear() {
|
||||
|
||||
/* User friendly wrapper for write() */
|
||||
write(0x00);
|
||||
}
|
||||
|
||||
void PCF8574_Soft::set() {
|
||||
|
||||
/* User friendly wrapper for write() */
|
||||
write(0xFF);
|
||||
}
|
||||
|
||||
void PCF8574_Soft::toggle(uint8_t pin) {
|
||||
|
||||
/* Toggle pin state */
|
||||
_PORT ^= (1 << pin);
|
||||
|
||||
/* Update GPIO values */
|
||||
updateGPIO();
|
||||
}
|
||||
|
||||
void PCF8574_Soft::blink(uint8_t pin, uint16_t count, uint32_t duration) {
|
||||
|
||||
/* Compute steps duration */
|
||||
duration /= count * 2;
|
||||
|
||||
/* Loop n times */
|
||||
while (count--) {
|
||||
|
||||
/* Toggle pin 2 times */
|
||||
toggle(pin);
|
||||
delay(duration);
|
||||
toggle(pin);
|
||||
delay(duration);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef PCF8574_Soft_INTERRUPT_SUPPORT
|
||||
void PCF8574_Soft::enableInterrupt(uint8_t pin, void (*selfCheckFunction)(void)) {
|
||||
|
||||
/* Store interrupt pin number */
|
||||
_pcintPin = pin;
|
||||
|
||||
/* Setup interrupt pin */
|
||||
#if ARDUINO >= 100
|
||||
::pinMode(pin, INPUT_PULLUP); // /!\ pinMode form THE ARDUINO CORE
|
||||
#else
|
||||
::pinMode(pin, INPUT); // /!\ pinMode form THE ARDUINO CORE
|
||||
::digitalWrite(pin, HIGH); // /!\ digitalWrite form THE ARDUINO CORE
|
||||
#endif
|
||||
|
||||
/* Attach interrupt handler */
|
||||
PCattachInterrupt(pin, selfCheckFunction, FALLING);
|
||||
}
|
||||
|
||||
void PCF8574_Soft::disableInterrupt() {
|
||||
|
||||
/* Detach interrupt handler */
|
||||
PCdetachInterrupt(_pcintPin);
|
||||
}
|
||||
|
||||
void PCF8574_Soft::checkForInterrupt() {
|
||||
|
||||
/* Avoid nested interrupt triggered by I2C read/write */
|
||||
if(_isrIgnore)
|
||||
return;
|
||||
else
|
||||
_isrIgnore = 1;
|
||||
|
||||
/* Re-enable interrupts to allow Wire library to work */
|
||||
sei();
|
||||
|
||||
/* Read current pins values */
|
||||
readGPIO();
|
||||
|
||||
/* Check all pins */
|
||||
for (uint8_t i = 0; i < 8; ++i) {
|
||||
|
||||
/* Check for interrupt handler */
|
||||
if (!_intCallback[i])
|
||||
continue;
|
||||
|
||||
/* Check for interrupt event */
|
||||
switch (_intMode[i]) {
|
||||
case CHANGE:
|
||||
if ((1 << i) & (_PIN ^ _oldPIN))
|
||||
_intCallback[i]();
|
||||
break;
|
||||
|
||||
case LOW:
|
||||
if (!(_PIN & (1 << i)))
|
||||
_intCallback[i]();
|
||||
break;
|
||||
|
||||
case FALLING:
|
||||
if ((_oldPIN & (1 << i)) && !(_PIN & (1 << i)))
|
||||
_intCallback[i]();
|
||||
break;
|
||||
|
||||
case RISING:
|
||||
if (!(_oldPIN & (1 << i)) && (_PIN & (1 << i)))
|
||||
_intCallback[i]();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Turn off ISR ignore flag */
|
||||
_isrIgnore = 0;
|
||||
}
|
||||
|
||||
void PCF8574_Soft::attachInterrupt(uint8_t pin, void (*userFunc)(void),
|
||||
uint8_t mode) {
|
||||
|
||||
/* Store interrupt mode and callback */
|
||||
_intMode[pin] = mode;
|
||||
_intCallback[pin] = userFunc;
|
||||
}
|
||||
|
||||
void PCF8574_Soft::detachInterrupt(uint8_t pin) {
|
||||
|
||||
/* Void interrupt handler */
|
||||
_intCallback[pin] = 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
void PCF8574_Soft::readGPIO() {
|
||||
|
||||
#ifdef PCF8574_Soft_INTERRUPT_SUPPORT
|
||||
/* Store old _PIN value */
|
||||
_oldPIN = _PIN;
|
||||
#endif
|
||||
|
||||
/* Start request, wait for data and receive GPIO values as byte */
|
||||
_wire->requestFrom(_address, (uint8_t) 0x01);
|
||||
while (_wire->available() < 1)
|
||||
;
|
||||
_PIN = _wire->read();
|
||||
}
|
||||
|
||||
void PCF8574_Soft::updateGPIO() {
|
||||
|
||||
/* Read current GPIO states */
|
||||
//readGPIO(); // Experimental
|
||||
|
||||
/* Compute new GPIO states */
|
||||
//uint8_t value = ((_PIN & ~_DDR) & ~(~_DDR & _PORT)) | _PORT; // Experimental
|
||||
uint8_t value = (_PIN & ~_DDR) | _PORT;
|
||||
|
||||
/* Start communication and send GPIO values as byte */
|
||||
_wire->beginTransmission(_address);
|
||||
_wire->write(value);
|
||||
_wire->endTransmission();
|
||||
}
|
||||
231
arduino-cli/libraries/PCF8574_Soft/PCF8574_Soft.h
Normal file
231
arduino-cli/libraries/PCF8574_Soft/PCF8574_Soft.h
Normal file
@@ -0,0 +1,231 @@
|
||||
/**
|
||||
* @brief PCF8574_Soft arduino library
|
||||
* @author SkyWodd <skywodd@gmail.com>
|
||||
* @version 2.0
|
||||
* @link http://skyduino.wordpress.com/
|
||||
*
|
||||
* @section intro_sec Introduction
|
||||
* This class is designed to allow user to use PCF8574_Soft gpio expander like any standard arduino pins.\n
|
||||
* This class provided standards arduino functions like pinMode, digitalWrite, digitalRead, ...\n
|
||||
* This new version is fully optimized and documented.\n
|
||||
* \n
|
||||
* Please report bug to <skywodd at gmail.com>
|
||||
*
|
||||
* @section license_sec License
|
||||
* This program is free software: you can redistribute it and/or modify\n
|
||||
* it under the terms of the GNU General Public License as published by\n
|
||||
* the Free Software Foundation, either version 3 of the License, or\n
|
||||
* (at your option) any later version.\n
|
||||
* \n
|
||||
* This program is distributed in the hope that it will be useful,\n
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of\n
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n
|
||||
* GNU General Public License for more details.\n
|
||||
* \n
|
||||
* You should have received a copy of the GNU General Public License\n
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.\n
|
||||
*
|
||||
* @section other_sec Others notes and compatibility warning
|
||||
* Compatible with arduino 1.0.x and >=0023\n
|
||||
* Retro-compatible with the previous library version
|
||||
*/
|
||||
#ifndef PCF8574_Soft_H
|
||||
#define PCF8574_Soft_H
|
||||
|
||||
/** Comment this define to disable interrupt support */
|
||||
#define PCF8574_Soft_INTERRUPT_SUPPORT
|
||||
|
||||
/* Retro-compatibility with arduino 0023 and previous version */
|
||||
#include "Arduino.h"
|
||||
#include <SoftwareWire.h>
|
||||
/**
|
||||
* @brief PCF8574_Soft Arduino class
|
||||
*/
|
||||
class PCF8574_Soft {
|
||||
public:
|
||||
/**
|
||||
* Create a new PCF8574_Soft instance
|
||||
*/
|
||||
PCF8574_Soft();
|
||||
|
||||
/**
|
||||
* Start the I2C controller and store the PCF8574_Soft chip address
|
||||
*/
|
||||
void begin(uint8_t address, SoftwareWire *theWire);
|
||||
|
||||
/**
|
||||
* Set the direction of a pin (OUTPUT, INPUT or INPUT_PULLUP)
|
||||
*
|
||||
* @param pin The pin to set
|
||||
* @param mode The new mode of the pin
|
||||
* @remarks INPUT_PULLUP does physicaly the same thing as INPUT (no software pull-up resistors available) but is REQUIRED if you use external pull-up resistor
|
||||
*/
|
||||
void pinMode(uint8_t pin, uint8_t mode);
|
||||
|
||||
/**
|
||||
* Set the state of a pin (HIGH or LOW)
|
||||
*
|
||||
* @param pin The pin to set
|
||||
* @param value The new state of the pin
|
||||
* @remarks Software pull-up resistors are not available on the PCF8574_Soft
|
||||
*/
|
||||
void digitalWrite(uint8_t pin, uint8_t value);
|
||||
|
||||
/**
|
||||
* Read the state of a pin
|
||||
*
|
||||
* @param pin The pin to read back
|
||||
* @return
|
||||
*/
|
||||
uint8_t digitalRead(uint8_t pin);
|
||||
|
||||
/**
|
||||
* Set the state of all pins in one go
|
||||
*
|
||||
* @param value The new value of all pins (1 bit = 1 pin, '1' = HIGH, '0' = LOW)
|
||||
*/
|
||||
void write(uint8_t value);
|
||||
|
||||
/**
|
||||
* Read the state of all pins in one go
|
||||
*
|
||||
* @return The current value of all pins (1 bit = 1 pin, '1' = HIGH, '0' = LOW)
|
||||
*/
|
||||
uint8_t read();
|
||||
|
||||
/**
|
||||
* Exactly like write(0x00), set all pins to LOW
|
||||
*/
|
||||
void clear();
|
||||
|
||||
/**
|
||||
* Exactly like write(0xFF), set all pins to HIGH
|
||||
*/
|
||||
void set();
|
||||
|
||||
/**
|
||||
* Toggle the state of a pin
|
||||
*/
|
||||
void toggle(uint8_t pin);
|
||||
|
||||
/**
|
||||
* Mark a pin as "pulled up"
|
||||
*
|
||||
* @warning DO NOTHING - FOR RETRO COMPATIBILITY PURPOSE ONLY
|
||||
* @deprecated
|
||||
* @param pin Pin the mark as "pulled up"
|
||||
*/
|
||||
void pullUp(uint8_t pin);
|
||||
|
||||
/**
|
||||
* Mark a pin as "pulled down"
|
||||
*
|
||||
* @warning DO NOTHING - FOR RETRO COMPATIBILITY PURPOSE ONLY
|
||||
* @deprecated
|
||||
* @param pin Pin the mark as "pulled down"
|
||||
*/
|
||||
void pullDown(uint8_t pin);
|
||||
|
||||
/**
|
||||
* Make a pin blink N times for T duration
|
||||
*
|
||||
* @warning Blocking function, not recommended for new code
|
||||
* @deprecated
|
||||
* @param pin The pin to blink
|
||||
* @param count The number of ON/OFF couples to execute
|
||||
* @param duration The duration of the whole blink action in milliseconds
|
||||
*/
|
||||
void blink(uint8_t pin, uint16_t count, uint32_t duration);
|
||||
|
||||
#ifdef PCF8574_Soft_INTERRUPT_SUPPORT
|
||||
/**
|
||||
* Enable interrupts support and setup interrupts handler
|
||||
*
|
||||
* @remarks Any pin can be used as "INT" pin, internally the library use PCINT to work.
|
||||
* @warning The check wrapping routine must be provided by user and define in the global scope space.
|
||||
* @param pin The pin OF YOUR ARDUINO (not the PCF8574_Soft) to use as "INT" pin for interrupts detection
|
||||
* @param selfCheckFunction The wrapping routine used to process interrupts events.
|
||||
* @remarks For best performances you should avoid this "user friendly" fonction and use the standard attachInterrupt() fonction ;)
|
||||
* @remarks If multiple PCF8574_Soft are wired on the same "INT" pin this function should be called only one time
|
||||
*/
|
||||
void enableInterrupt(uint8_t pin, void (*selfCheckFunction)(void));
|
||||
|
||||
/**
|
||||
* Disable interrupts support
|
||||
*/
|
||||
void disableInterrupt();
|
||||
|
||||
/**
|
||||
* Check for interrupt and process routine
|
||||
*
|
||||
* @remarks Call this routine from your wrapping routine to detect and process interrupts (if any) of this PCF8574_Soft instance.
|
||||
*/
|
||||
void checkForInterrupt();
|
||||
|
||||
/**
|
||||
* Attach a function to an interrupt event of a pin of the PCF8574_Soft
|
||||
*
|
||||
* @param pin The pin to attach the interrupt event on
|
||||
* @param userFunc The callback function to call when the interrupt event is triggered
|
||||
* @param mode The interrupt mode to check for, only interrupts events coming from the specified pin and with the specified mode will call the callback function.
|
||||
* @remarks 1 PCF8574_Soft pin = 1 interrupt, multiple interrupts on the same pin is not supported
|
||||
*/
|
||||
void attachInterrupt(uint8_t pin, void (*userFunc)(void), uint8_t mode);
|
||||
|
||||
/**
|
||||
* Detach any interrupt attached to the specified pin
|
||||
*
|
||||
* @param pin The pin to detach any interrupt from
|
||||
*/
|
||||
void detachInterrupt(uint8_t pin);
|
||||
#endif
|
||||
|
||||
protected:
|
||||
/** Output pins values */
|
||||
volatile uint8_t _PORT;
|
||||
|
||||
/** Current input pins values */
|
||||
volatile uint8_t _PIN;
|
||||
|
||||
/** Pins modes values (OUTPUT or INPUT) */
|
||||
volatile uint8_t _DDR;
|
||||
|
||||
/** PCF8574_Soft I2C address */
|
||||
uint8_t _address;
|
||||
|
||||
SoftwareWire *_wire;
|
||||
|
||||
#ifdef PCF8574_Soft_INTERRUPT_SUPPORT
|
||||
/** Old value of _PIN variable */
|
||||
volatile uint8_t _oldPIN;
|
||||
|
||||
/** ISR ignore flag */
|
||||
volatile uint8_t _isrIgnore;
|
||||
|
||||
/** PCINT pin used for "INT" pin handling */
|
||||
uint8_t _pcintPin;
|
||||
|
||||
/** Interrupts modes of pins ( LOW, CHANGE, FALLING, RISING) */
|
||||
uint8_t _intMode[8];
|
||||
|
||||
/** Interrupts callback functions */
|
||||
void (*_intCallback[8])(void);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Read GPIO states and store them in _PIN variable
|
||||
*
|
||||
* @remarks Before reading current GPIO states, current _PIN variable value is moved to _oldPIN variable
|
||||
*/
|
||||
void readGPIO();
|
||||
|
||||
/**
|
||||
* Write value of _PORT variable to the GPIO
|
||||
*
|
||||
* @remarks Only pin marked as OUTPUT are set, for INPUT pins their value are unchanged
|
||||
* @warning To work properly (and avoid any states conflicts) readGPIO() MUST be called before call this function !
|
||||
*/
|
||||
void updateGPIO();
|
||||
};
|
||||
|
||||
#endif
|
||||
112
arduino-cli/libraries/PCF8574_Soft/PCint.h
Normal file
112
arduino-cli/libraries/PCF8574_Soft/PCint.h
Normal file
@@ -0,0 +1,112 @@
|
||||
#include "pins_arduino.h"
|
||||
|
||||
volatile uint8_t *port_to_pcmask[] = { &PCMSK0, &PCMSK1, &PCMSK2 };
|
||||
|
||||
static int PCintMode[24];
|
||||
|
||||
typedef void (*voidFuncPtr)(void);
|
||||
|
||||
volatile static voidFuncPtr PCintFunc[24] = { NULL };
|
||||
|
||||
volatile static uint8_t PCintLast[3];
|
||||
|
||||
/*
|
||||
* attach an interrupt to a specific pin using pin change interrupts.
|
||||
*/
|
||||
void PCattachInterrupt(uint8_t pin, void (*userFunc)(void), int mode) {
|
||||
uint8_t bit = digitalPinToBitMask(pin);
|
||||
uint8_t port = digitalPinToPort(pin);
|
||||
uint8_t slot;
|
||||
volatile uint8_t *pcmask;
|
||||
|
||||
// map pin to PCIR register
|
||||
if (port == NOT_A_PORT) {
|
||||
return;
|
||||
} else {
|
||||
port -= 2;
|
||||
pcmask = port_to_pcmask[port];
|
||||
}
|
||||
|
||||
// -- Fix by Baziki. In the original sources it was a little bug, which cause analog ports to work incorrectly.
|
||||
if (port == 1) {
|
||||
slot = port * 8 + (pin - 14);
|
||||
} else {
|
||||
slot = port * 8 + (pin % 8);
|
||||
}
|
||||
// --Fix end
|
||||
PCintMode[slot] = mode;
|
||||
PCintFunc[slot] = userFunc;
|
||||
// set the mask
|
||||
*pcmask |= bit;
|
||||
// enable the interrupt
|
||||
PCICR |= 0x01 << port;
|
||||
|
||||
// Fix init by SkyWodd
|
||||
PCintLast[0] = *portInputRegister(2);
|
||||
PCintLast[1] = *portInputRegister(3);
|
||||
PCintLast[2] = *portInputRegister(4);
|
||||
}
|
||||
|
||||
void PCdetachInterrupt(uint8_t pin) {
|
||||
uint8_t bit = digitalPinToBitMask(pin);
|
||||
uint8_t port = digitalPinToPort(pin);
|
||||
volatile uint8_t *pcmask;
|
||||
|
||||
// map pin to PCIR register
|
||||
if (port == NOT_A_PORT) {
|
||||
return;
|
||||
} else {
|
||||
port -= 2;
|
||||
pcmask = port_to_pcmask[port];
|
||||
}
|
||||
|
||||
// disable the mask.
|
||||
*pcmask &= ~bit;
|
||||
// if that's the last one, disable the interrupt.
|
||||
if (*pcmask == 0) {
|
||||
PCICR &= ~(0x01 << port);
|
||||
}
|
||||
}
|
||||
|
||||
// common code for isr handler. "port" is the PCINT number.
|
||||
// there isn't really a good way to back-map ports and masks to pins.
|
||||
static void PCint(uint8_t port) {
|
||||
uint8_t bit;
|
||||
uint8_t curr;
|
||||
uint8_t mask;
|
||||
uint8_t pin;
|
||||
|
||||
// get the pin states for the indicated port.
|
||||
curr = *portInputRegister(port + 2);
|
||||
mask = curr ^ PCintLast[port];
|
||||
PCintLast[port] = curr;
|
||||
// mask is pins that have changed. screen out non pcint pins.
|
||||
if ((mask &= *port_to_pcmask[port]) == 0) {
|
||||
return;
|
||||
}
|
||||
// mask is pcint pins that have changed.
|
||||
for (uint8_t i = 0; i < 8; i++) {
|
||||
bit = 0x01 << i;
|
||||
if (bit & mask) {
|
||||
pin = port * 8 + i;
|
||||
// Trigger interrupt if mode is CHANGE, or if mode is RISING and
|
||||
// the bit is currently high, or if mode is FALLING and bit is low.
|
||||
if ((PCintMode[pin] == CHANGE
|
||||
|| ((PCintMode[pin] == RISING) && (curr & bit))
|
||||
|| ((PCintMode[pin] == FALLING) && !(curr & bit)))
|
||||
&& (PCintFunc[pin] != NULL)) {
|
||||
PCintFunc[pin]();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SIGNAL(PCINT0_vect) {
|
||||
PCint(0);
|
||||
}
|
||||
SIGNAL(PCINT1_vect) {
|
||||
PCint(1);
|
||||
}
|
||||
SIGNAL(PCINT2_vect) {
|
||||
PCint(2);
|
||||
}
|
||||
Reference in New Issue
Block a user