MCP23017 – an overview <\/h2>\n\n
The MCP23017 is a 16-bit I\/O port expander with convenient interrupt functions. The 16 I\/O pins are organized into two ports (A and B), which can be addressed separately (byte mode) or together (sequential mode). The supply voltage should be between 1.8 and 5.5 volts. The maximum current at the I\/O pins is 25 mA in both directions. In total, the input current to VDD should not exceed 125 mA and not more than 150 mA should flow into VSS (GND). The communication protocoll is I\u00b2C. A data sheet for the MCP23017 can be found here<\/a>.<\/p>\n In terms of its flexibility, the MCP23017 is the Swiss army knife among the common port expanders, if you compare it with the 74HC595 shift register or the PCF8574, for example. <\/p>\n\n Important notice!!! <\/strong> The data sheet for the MCP23017 changed in 2022. According to the new version, pins GPA7 and GPB7 have lost their input function. The pins are now pure OUTPUT pins. Microchip appears to have responded to reported problems with this change. The problems may or may not occur. You can find a statement from Microchip on this here<\/a>. Personally, I have not noticed any malfunctions so far. The 16 I\/O pins are named GPA0 to GPA7 or GPB0 to GPB7 according to the two ports. The power supply is via VDD and VSS. The connection of pins A0, A1 and A2 determines the I2C address according to the following scheme:<\/p>\n 1 0 0 A2 A1 A0 <\/p>\n For example, if A0 to A2 are LOW, then the address is 100000 (binary) = 32 (decimal) = 0x20 (hexadecimal). SDA and SCL are the two I\u00b2C pins. The reset pin is active-low. INTA and INTB are the interrupt pins for the two ports. You can set the polarity of the interrupt pins. You can also connect both interrupt pins together (mirror function). <\/p>\n\n I have developed a library that you can find and download here<\/a> on Github. You can also install the library directly from the Arduino IDE library manager. The library is designed so that the two ports, A and B, are addressed separately in byte mode. Perhaps I will expand the library to include sequential mode at some point. <\/p>\n\n The functionality of the I\/O pins is comparable to that of Arduino I\/O pins. The pins can be used as inputs or outputs; they are switched to HIGH or LOW, and they can act as both current sources and current sinks. If they are set as input, the pins can serve as interrupt pins. But in the first example, we start easy, and only 16 LEDs are controlled. <\/p>\n\n The address pins are set to LOW in my example circuit, so the I\u00b2C address is 0x20. The reset pin is connected to the Arduino pin 5. The pins of port A and B each control eight LEDs of an LED bar. The I\u00b2C lines SDA and SCL are equipped with pull-ups with 4.7 kOhm resistors. Without the pull-ups, however, it also worked well for me.<\/p>\n\n In this example, the following functions are used (the MCP23017 object is called myMCP here):<\/p>\n A complete list of all library functions can be found here<\/a>.<\/strong><\/p>\n\n Here is a sketch that plays with these functions and hopefully illustrates them:<\/p>\n<\/p>\n \u00a0<\/p>\n<\/div>\n \n\n In my example, the current (technical current direction) flows from the MCP23017 through the LEDs to GND. Instead, the MCP23017 could, of course, also be used as a current sink. Then an LED would light up if the corresponding pin is OUTPUT and LOW and voltage is supplied, comparable with how the Arduino works. <\/p>\n\n The following functions are used to read the pin status in the GPIO register:<\/p>\n Here is an example circuit for you:<\/p>\n\n And here is the corresponding example sketch:<\/p>\n<\/p>\n \u00a0<\/p>\n<\/div>\n \n\n I\/Os configured as INPUT can get an internal pull-up: <\/p>\n You must add pull-down resistors externally. <\/p>\n This is what the output of the example sketch looks like:<\/p>\n\n All 16 I\/O pins can be configured as interrupt pins. There are two modes, the interrupt-on-change and the interrupt-on-defval-deviation. I start with the interrupt-on-change function, where every switch from LOW to HIGH or HIGH to LOW triggers an interrupt. The interrupt induces a polarity change at the respective interrupt output INTA or INTB. Alternatively, you can merge INTA and INTB. You can also set the polarity of the interrupt outputs. <\/p>\n Only pins set as INPUT can act as interrupt pins, but this setting is done in the background by the library.<\/p>\n\n I have implemented the following functions for interrupt-on-change:<\/p>\n For testing, I have set up the following circuit:<\/p>\n\n The pins of port B are set up as interrupt pins and receive HIGH signals via the buttons. The LEDs connected to port A should indicate which pin the interrupt occurred on. <\/p>\n\n \u00a0<\/p>\n<\/div>\n \n\n Note 1: Pressing the button briefly (< 200 ms) triggers a LOW-HIGH interrupt; pressing and holding the button triggers first a LOW-HIGH interrupt and then a HIGH-LOW interrupt. Note 2: The interrupt remains active until a getIntCap or getPort query is performed. When things go bad because you query at the wrong time or the next interrupt comes at the wrong time, the interrupt will remain unintentional active. That is why I added an additional getIntCap query in line 67, which may seem redundant at first glance. This ensures that the MCP23017 is ready for the next interrupt. Here, the polarity of the interrupt pins is compared with the state defined in the so-called DEFVAL register. A deviation triggers an interrupt. If you read the interrupt capture or GPIO register, you delete the interrupt. However, if the interrupt condition is still met at this time, the next interrupt is triggered immediately.<\/p>\n For this interrupt method, I have implemented the following additional functions:<\/p>\n As an example, I have set up the following circuit:<\/p>\n\n The port B pins are defined as interrupt pins. B0 to B3 are set HIGH with internal pull-ups, while B4 to B7 get pull-down resistors. The polarity on the respective pin is reversed by pushing the button. As in the last example, port A is again used to display the pin responsible for the interrupt. <\/p>\n\n \u00a0<\/p>\n<\/div>\n \n\n The crucial difference to interrupt-on-change is that in this method the polarity change leads only in one direction to the interrupt. The output looks like this:<\/p>\n\n The MCP23S17 differs from the MCP23017 only in that it is controlled via SPI instead of I2C. This means that the connections are slightly different. All functions are identical. You can find a sample sketch and the corresponding wiring in my library. <\/p>\n\n Here, as announced, some additional detailed information about the MCP23017 for those who still want it. <\/p>\n The MCP23017 is only a representative of the larger MCP23XXX family, which differ from each other in the number of I\/O pins, the control (I2C vs SPI) and the external connection. The MCP23017 is probably the most popular representative. I have written a separate article about the others, which you can find here<\/a>. <\/p>\n\n First of all, you have to decide how to address the registers. For this, you can set the BANK bit in the IOCON Register. If this is set to 1, the port registers are in two separate banks. If, on the other hand, it is set to 0, the registers are located in the same bank, and the addresses are sequential. I opted for the latter and did not implement the alternative as an option. The registers are thus defined as follows:<\/p>\n\n The IODIR register determines whether the pins are INPUT or OUTPUT pins. It is the only register with a start or reset value of 0b11111111. “1” means INPUT, “0” means OUTPUT, which sounds illogical to me, but maybe I am just used to the different definition in the world of Arduino. But because this irritates me, I have turned the values in my library accordingly. With If you set the bits in this register, the inverted level of the pins is stored in the corresponding GPIO register. <\/p>\n\n This register controls which pins are used as interrupt pins. 0 = disable, 1 = enable. If you only want to implement interrupt-on-change, no further settings are necessary. However, in case you want to implement interrupt-on-defval-deviation, you have to make additional settings in the DEFVAL and INTCON registers. The GPINTEN register is accessed indirectly in my library via the This register is required to set up Interrupts-on-Defval-Deviation. If a value in the GPIO register differs from the DEFVAL register, an interrupt is triggered if the corresponding settings have been made in the GPINTEN and INTCON registers. <\/p>\n\n This register determines the conditions under which interrupts are triggered:<\/p>\nPinout of the MCP23017<\/h3>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/06\/pinout_mcp23017_old_new-1024x341.png\")
<\/a>
<\/em><\/p>\n\nControlling the MCP23017 with the library<\/h2>\n\n
Simple input\/output applications<\/h3>\n\n
![\"Circuit](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/10\/Mcp23017_basic_input_output_wiring-1024x792.png\")
<\/a>\n
typedef MCP23017_WE MCP;<\/code> is simply for convenience. Writing MCP instead of the class name MCP23017_WE requires less typing. I renamed the class with version 2.0.0 due to problems installing libraries with classes of the same name. <\/li>\nMCP myMCP = MCP(MCP_ADDRESS, RESET_PIN)<\/code> creates your MCP23017 object. You must pass the I\u00b2C address. You can also pass the reset pin and\/or a wire object. With the latter, you can use both I\u00b2C buses of an ESP32, for example. You can also connect the reset pin to VDD to save a pin. However, you should then pass a dummy reset pin with a value of >= 99. This triggers a software reset instead of a hardware reset in Init().<\/li>\nmyMCP.Init();<\/code> initializes the object with some default settings.<\/li>\nmyMCP.setPinMode( pin,port,direction );<\/code> corresponds to the Arduino pinMode function, with the port added as a parameter here. \n\n
MCP::A<\/code>). This is one more argument for the abbreviation “MCP”. <\/li>\nmyMCP.setPortMode( value,port );<\/code> sets the pinMode for an entire port; value is best specified as a binary number.<\/li>\nmyMCP.setPortMode( value,port,INPUT_PULLUP);<\/code> with this variant, all input pins get a pull-up; no effect on output pins. <\/li>\nmyMCP.setPin( pin,port,level );<\/code> similar to the digitalWrite function;\n\n
myMCP.setPort( value,port );<\/code> digitalWrite for the entire port; for me, binary numbers are more readable than decimal or hexadecimal numbers.<\/li>\nmyMCP.togglePin( pin,port );<\/code> switches a pin from LOW to HIGH or from HIGH to LOW.<\/li>\nmyMCP.setPinX( pin,port,direction,level );<\/code> “Extended version” of the setPin function or combination of setPinMode and setPin.<\/li>\nmyMCP.setPortModeX( direction,value,port );<\/code> “Extended version” of the setPort function.<\/li>\nmyMCP.setAllPins( port,level );<\/code> sets all pins of a port to LOW or HIGH.<\/li>\n<\/ul>\nSample sketch for simple output applications<\/h4>\n\n
#include <Wire.h>\n#include <MCP23017_WE.h>\n#define MCP_ADDRESS 0x20 \/\/ (A2\/A1\/A0 = LOW)\n\/* A hardware reset is performed during init(). If you want to save a pin you can define a dummy \n * reset pin >= 99 and connect the reset pin to HIGH. This will trigger a software reset instead \n * of a hardware reset. \n *\/\n#define RESET_PIN 5 \n\ntypedef MCP23017_WE MCP; \/\/ just for less typing!\n\n\/* There are several ways to create your MCP23017 object:\n * MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS) -> uses Wire \/ no reset pin \n * MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS, RESET_PIN) -> uses Wire \/ RESET_PIN\n * MCP23017_WE myMCP = MCP23017_WE(&Wire, MCP_ADDRESS) -> passing a TwoWire object \/ no reset pin\n * MCP23017_WE myMCP = MCP23017_WE(&Wire, MCP_ADDRESS, RESET_PIN) -> \"all together\"\n *\/\nMCP myMCP = MCP(MCP_ADDRESS, RESET_PIN); \/\/ short version\n\/\/ MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS, RESET_PIN); \/\/ long version\n\nint wT = 1000; \/\/ wT = waiting time\n\nvoid setup(){ \n Serial.begin(9600);\n Wire.begin();\n if(!myMCP.Init()){\n Serial.println(\"Not connected!\");\n while(1){} \n }\n myMCP.setPortMode(0b11111101, MCP::A); \/\/ Port A: all pins are OUTPUT except pin 1\n myMCP.setPortMode(0b11111111, MCP::B); \/\/ Port B: all pins are OUTPUT\n delay(wT);\n myMCP.setAllPins(MCP::A, HIGH); \/\/ alle LEDs switched on except A1\n delay(wT);\n myMCP.setPinX(1, MCP::A, OUTPUT, HIGH); \/\/ A1 switched on \n delay(wT); \n myMCP.setPort(0b11110000, MCP::B); \/\/ B4 - B7 switched on\n delay(wT);\n myMCP.setPort(0b01011110, MCP::A); \/\/ A0,A5,A7 switched off\n delay(wT);\n myMCP.setPinX(0, MCP::B, OUTPUT, HIGH); \/\/ B0 switched on\n delay(wT);\n myMCP.setPinX(4, MCP::B, OUTPUT, LOW); \/\/ B4 switched off\n delay(wT);\n myMCP.setAllPins(MCP::A, HIGH); \/\/ A0 - A7 all on\n delay(wT);\n myMCP.setPin(3, MCP::A, LOW); \/\/ A3 switched off\n delay(wT);\n myMCP.setPortX(0b11110000, 0b01101111, MCP::B); \/\/ at port B only B5,B6 are switched on\n delay(wT);\n myMCP.setPinMode(0, MCP::B, OUTPUT); \/\/ B0 --> OUTPUT\n for(int i=0; i<5; i++){ \/\/ B0 blinking\n myMCP.togglePin(0, MCP::B); \n delay(200);\n myMCP.togglePin(0, MCP::B);\n delay(200);\n }\n for(int i=0; i<5; i++){ \/\/ B7 blinking\n myMCP.togglePin(7, MCP::B);\n delay(200);\n myMCP.togglePin(7, MCP::B);\n delay(200);\n }\n}\n\nvoid loop(){ \n} <\/pre>\nRead pin status<\/h4>\n\n
\n
myMCP.getPin( pin,port );<\/code> returns the level of a pin (as a boolean).<\/li>\nmyMCP.getPort( port );<\/code> returns the status of an entire port (as uint8_t), i.e. the contents of the GPIO register.<\/li>\n<\/ul>\n![\"Circuit](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/07\/mcp23s17_gpio_reading_wiring-1024x744.png\")
<\/a>#include <Wire.h>\n#include <MCP23017_WE.h>\n#define MCP_ADDRESS 0x20 \/\/ (A2\/A1\/A0 = LOW)\n\n\/* A hardware reset is performed during init(). If you want to save a pin you can define a dummy \n * pin >= 99 and connect the reset pin to HIGH. This will trigger a software reset instead of a \n * hardware reset. \n *\/\n#define RESET_PIN 5\n\ntypedef MCP23017_WE MCP; \/\/ just for less typing!\n\n\/* There are several ways to create your MCP23017 object:\n * MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS) -> uses Wire \/ no reset pin \n * MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS, RESET_PIN) -> uses Wire \/ RESET_PIN\n * MCP23017_WE myMCP = MCP23017_WE(&Wire, MCP_ADDRESS) -> passing a TwoWire object \/ no reset pin\n * MCP23017_WE myMCP = MCP23017_WE(&Wire, MCP_ADDRESS, RESET_PIN) -> \"all together\"\n *\/\nMCP myMCP = MCP(MCP_ADDRESS, RESET_PIN); \/\/ short version\n\/\/ MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS, RESET_PIN); \/\/ long version\n\nint wT = 1000; \/\/ wT = waiting time\nbyte portStatus;\nbool pinStatus;\n\nvoid setup(){ \n Serial.begin(9600);\n Wire.begin();\n if(!myMCP.Init()){\n Serial.println(\"Not connected!\");\n while(1){} \n } \n myMCP.setPortMode(0b00000000, MCP::A); \/\/ Port A: all pins are INPUT\n myMCP.setPortPullUp(0b11110000, MCP::A); \/\/ Port A: Pin 4 - 7 are pulled up\n}\n\nvoid loop(){ \n \n portStatus = myMCP.getPort(MCP::A); \/\/ query the complete port status \n Serial.print(\"Status GPIO A: \");\n Serial.println(portStatus, BIN);\n \n pinStatus = myMCP.getPin(5, MCP::A); \/\/ query one pin status\n Serial.print(\"Status Port A, Pin 5: \");\n Serial.println(pinStatus, BIN);\n \n Serial.println(\"-------------------------------------\");\n delay(1000);\n} <\/pre>\n\n
myMCP.setPinPullUp( pin,port );<\/code> sets a pull-up with a 100 kOhm resistor<\/li>\nmyMCP.setPortPullUp( value,port );<\/code> is the equivalent for an entire port<\/li>\n<\/ul>\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/07\/output_mcp23017_gpio_reading.png\")
<\/a>Interrupt-on-Change<\/h3>\n\n
\n
myMCP.setInterruptOnChangePin( pin,port );<\/code> sets up a single pin as an interrupt-on-change pin.<\/li>\nmyMCP.setInterruptOnChangePort( value,port );<\/code> configures several or all pins of a port as interrupt-on-change pins. <\/li>\nmyMCP.setInterruptPinPol( level );<\/code> sets the level of the active interrupt output\n\n
myMCP.setIntOdr( value );<\/code> value = 1 or ON \u2192 Interrupt outputs go into open drain state, interrupt pin polarity is overwritten; value = 0 or OFF \u2192 active-low or active-high (both).<\/li>\nmyMCP.deleteAllInterruptsOnPort( port );<\/code> resets the configuration of the interrupt pins.<\/li>\nmyMCP.setIntMirror ( value );<\/code> value = 1 or ON \u2192 INTA \/ INTB are mirrored, value = 0 or OFF \u2192 INTA \/ INTB are responsible for their ports separately (default setting).<\/li>\nmyMCP.getIntFlag( port );<\/code> returns the value of the interrupt flag register as a byte (uint8_t). The bit representing the pin responsible for the last interrupt is set in the interrupt flag register. <\/li>\nmyMCPgetIntCap( port );<\/code> returns the value of the interrupt capture register. It contains the value of the GPIO register at the time of the interrupt. <\/li>\n<\/ul>\n\n![\"Circuit](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/06\/mcp23017_interrupt_on_change_wiring-1024x775.png\")
<\/a>Example sketch for interrupt-on-change<\/h4>\n<\/p>\n
#include <Wire.h>\n#include <MCP23017_WE.h>\n#define MCP_ADDRESS 0x20 \/\/ (A2\/A1\/A0 = LOW)\n\/* A hardware reset is performed during init(). If you want to save a pin you can define a dummy \n * reset pin >= 99 and connect the reset pin to HIGH. This will trigger a software reset instead \n * of a hardware reset. \n *\/\n#define RESET_PIN 5 \nint interruptPin = 3;\nvolatile bool event; \n\ntypedef MCP23017_WE MCP; \/\/ just for less typing!\n\n\/* There are several ways to create your MCP23017 object:\n * MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS) -> uses Wire \/ no reset pin \n * MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS, RESET_PIN) -> uses Wire \/ RESET_PIN\n * MCP23017_WE myMCP = MCP23017_WE(&Wire, MCP_ADDRESS) -> passing a TwoWire object \/ no reset pin\n * MCP23017_WE myMCP = MCP23017_WE(&Wire, MCP_ADDRESS, RESET_PIN) -> \"all together\"\n *\/\nMCP myMCP = MCP(MCP_ADDRESS, RESET_PIN); \/\/ short version\n\/\/ MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS, RESET_PIN); \/\/ long version\n\n\nvoid setup(){ \n pinMode(interruptPin, INPUT);\n attachInterrupt(digitalPinToInterrupt(interruptPin), eventHappened, RISING);\n Serial.begin(9600);\n Wire.begin();\n if(!myMCP.Init()){\n Serial.println(\"Not connected!\");\n while(1){} \n } \n myMCP.setPortMode(0b11111111, MCP::A);\n myMCP.setPort(0b11111111, MCP::A); \/\/ just an LED test\n delay(1000); \n myMCP.setAllPins(MCP::A, LOW);\n delay(1000);\n myMCP.setInterruptPinPol(HIGH); \/\/ set INTA and INTB active-high\n delay(10);\n myMCP.setInterruptOnChangePort(0b11111111, MCP::B); \/\/set all B pins as interrrupt Pins\n delay(10);\n myMCP.getIntCap(MCP::B); \/\/ ensures that existing interrupts are cleared\n event=false;\n} \n\nvoid loop(){ \n if(event){\n byte intFlagReg = myMCP.getIntFlag(MCP::B);\n byte eventPin = log(intFlagReg)\/log(2);\n byte intCapReg = myMCP.getIntCap(MCP::B);\n Serial.println(\"Interrupt!\");\n Serial.print(\"Interrupt Flag Register: \");\n Serial.println(intFlagReg, BIN); \n Serial.print(\"Interrupt Capture Register: \");\n Serial.println(intCapReg, BIN); \n Serial.print(\"Pin No.\");\n Serial.print(eventPin);\n Serial.print(\" went \");\n if((intFlagReg&intCapReg) == 0){ \/\/LOW-HIGH or HIGH-LOW interrupt?\n Serial.println(\"LOW\");\n }\n else{\n Serial.println(\"HIGH\");\n }\n myMCP.setPort(intFlagReg, MCP::A);\n delay(200);\n intCapReg = myMCP.getIntCap(MCP::B);\n event = false; \n }\n}\n\nvoid eventHappened(){\n event = true;\n}<\/pre>\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/05\/Interrupt_Output_Serial_Monitor.png\")
<\/a>
<\/em><\/p>\n\n
<\/em><\/p>\n\nInterrupt-on-DefVal-Deviation<\/h3>\n\n
\n
myMCP.setInterruptOnDefValDevPin( intpin,port,defvalstate );<\/code> intpin is the interruptpin, defvalstate is the default level and a deviation from it leads to the interrupt<\/li>\nmyMCP.setInterruptOnDefValDevPort( intpins,Port,defvalstate );<\/code>\n\n
![\"Circuit](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/06\/mcp23017_interrupt_on_defval_def_wiring-1024x778.png\")
<\/a>Example sketch for interrupt-on-defval-deviation<\/h4>\n<\/p>\n
#include <Wire.h>\n#include <MCP23017_WE.h>\n#define MCP_ADDRESS 0x20 \/\/ (A2\/A1\/A0 = LOW)\n\/* A hardware reset is performed during init(). If you want to save a pin you can define a dummy \n * reset pin >= 99 and connect the reset pin to HIGH. This will trigger a software reset instead \n * of a hardware reset. \n *\/\n#define RESET_PIN 5 \nint interruptPin = 3;\nvolatile bool event = false;\nuint8_t defValB = 0b00001111; \/\/ if port B deviates, an interrupt is triggered\n\ntypedef MCP23017_WE MCP; \/\/ just for less typing!\n\n\/* There are several ways to create your MCP23017 object:\n * MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS) -> uses Wire \/ no reset pin \n * MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS, RESET_PIN) -> uses Wire \/ RESET_PIN\n * MCP23017_WE myMCP = MCP23017_WE(&Wire, MCP_ADDRESS) -> passing a TwoWire object \/ no reset pin\n * MCP23017_WE myMCP = MCP23017_WE(&Wire, MCP_ADDRESS, RESET_PIN) -> \"all together\"\n *\/\nMCP myMCP = MCP(MCP_ADDRESS, RESET_PIN); \/\/ short version\n\/\/ MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS, RESET_PIN); \/\/ long version\n\nvoid setup(){ \n pinMode(interruptPin, INPUT);\n attachInterrupt(digitalPinToInterrupt(interruptPin), eventHappened, RISING);\n Serial.begin(9600);\n Wire.begin();\n if(!myMCP.Init()){\n Serial.println(\"Not connected!\");\n while(1){} \n }\n myMCP.setPortMode(0b11111111, MCP::A);\n myMCP.setPort(0b11111111, MCP::A); \/\/ just an LED test \n delay(1000); \n myMCP.setAllPins(MCP::A, LOW);\n delay(1000);\n myMCP.setInterruptPinPol(HIGH);\n delay(10);\n myMCP.setInterruptOnDefValDevPort(0b11111111, MCP::B, defValB); \/\/ interrupt pins, port, DEFVALB\n myMCP.setPortPullUp(0b00001111, MCP::B); \/\/ pull-up for B0-B3\n delay(10);\n myMCP.getIntCap(MCP::B); \/\/ deletes all interrupts\n event = false;\n} \n\nvoid loop(){ \n if(event){\n byte intFlagReg = myMCP.getIntFlag(MCP::B);\n byte eventPin = log(intFlagReg)\/log(2);\n byte intCapReg = myMCP.getIntCap(MCP::B);\n Serial.println(\"Interrupt!\");\n Serial.print(\"Interrupt Flag Register: \");\n Serial.println(intFlagReg, BIN); \n Serial.print(\"Interrupt Capture Register: \");\n Serial.println(intCapReg, BIN); \n Serial.print(\"Pin No.\");\n Serial.print(eventPin);\n Serial.print(\" went \");\n if((intFlagReg&intCapReg) == 0){ \/\/ HIGH\/LOW or LOW\/HIGH change?\n Serial.println(\"LOW\");\n }\n else{\n Serial.println(\"HIGH\");\n }\n myMCP.setPort(intFlagReg, MCP::A);\n delay(400);\n \/* if you use a pushbutton to trigger the interrupt, uncomment the \n following line. *\/\n \/\/ while(myMCP.getPort(MCP::B) != defValB) {} \/\/ while key is pressed\n intCapReg = myMCP.getIntCap(MCP::B);\n event = false;\n }\n}\n\nvoid eventHappened(){\n event = true;\n}<\/pre>\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/05\/Interrupt_OnDefVal_Output_Serial_Monitor.png\")
<\/a>The MCP23S17<\/h2>\n\n
MCP23017 \/ MCP23S17 internal<\/h2>\n\n
The registers of the MCP23017<\/h3>\n\n
![\"Register](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/05\/Registertabelle-1024x601.png\")
IODIR – I\/O direction register<\/h4>\n\n
myMCP.setPortMode()<\/code> and myMCP.setPinMode()<\/code> the IODIR register is addressed directly. For example, myMCP.setPortMode(B11111111, A)<\/code> means that all pins of the port are OUTPUT pins. <\/p>\n\nIPOL – input polarity register<\/h4>\n\n
GPINTEN – Interrupt-on-Change control register<\/h4>\n\n
setInterruptOnChangePin()<\/code> and setInterruptOnDefValDevPin()<\/code> functions or their counterparts for entire ports. <\/p>\n\nDEFVAL – default value register<\/h4>\n\n
INTCON – interrupt control register<\/h4>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/05\/IOCON_REG-1024x75.png\")
<\/a><\/figure>\n\n