Incidentally, the somewhat cumbersome designation MCP23x1y is not official. “MCP23x” would also have included the MCP23008 and MCP23S08 models, which I will not discuss in detail here. They only have 8 GPIOs. <\/p>\n
These are the topics I will discuss:<\/p>\n
- \n
- Overview of the MCP23x1y family<\/a><\/li>\n
- Use of the MCP23x1y port expanders in detail<\/a>\n
- \n
- MCP23017<\/a><\/li>\n
- MCP23S17<\/a><\/li>\n
- MCP23018<\/a><\/li>\n
- MCP23S18<\/a><\/li>\n
- MCP23016<\/a><\/li>\n<\/ul>\n<\/li>\n
- I2C vs. SPI \u2013 speed tests<\/a>\n
- \n
- I2C using the Arduino Nano<\/a><\/li>\n
- I2C using the ESP32<\/a><\/li>\n
- SPI using the Arduino Nano<\/a><\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n
Overview of the MCP23x1y family<\/h2>\n\n
The MCP23x1y family comprises five members:<\/p>\n
- \n
- the MCP230<\/strong>16<\/strong> (link to data sheet<\/a>)<\/li>\n
- MCP230<\/strong>17<\/strong> \/ MCP23S<\/strong>17<\/strong> (link to data sheet<\/a>)<\/li>\n
- and finally the two MCP230<\/strong>18<\/strong> \/ MCP23S<\/strong>18<\/strong> (link to data sheet<\/a>)<\/li>\n<\/ul>\n\n
![\"MCP23x1y](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/MCP23x1y_family-1024x414.jpg\")
<\/a>MCP23x1y family (PDIP version)<\/figcaption><\/figure>\n\n Here is an overview of the most important features of the MCP23x1y port expander:<\/p>\n\n
![\"Key](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/Vergleich_-23x1y_Familie-1024x474.png\")
<\/a>Key differences of the MCP23x1y port expanders at a glance<\/figcaption><\/figure>\n\n The most common representative is the MCP23017. Like the MCP23018, it is I2C-controlled. If you want to switch or read the GPIOs (General Purpose Input Output) at a higher speed, then use one of the SPI-controlled “S” variants. <\/p>\n
The maximum current that can flow through a pin is 25 mA for all members of the MCP23x1y family. However, this current may only flow simultaneously through all pins in the “18” variants. These variants also have a restriction regarding the direction of current flow. The GPIOs of the MCP23018 and MCP23S18 are “open drain” inputs\/outputs. This means that they behave like a simple transistor. You can open them (set to OUTPUT) and thus “allow current to flow to ground”, but you cannot use them as a current source. <\/p>\n
The MCP23016 is special. It is the only one with a different register structure. It also requires an external clock generator. Since it has been labelled “not recommended for new designs” by the manufacturer Microchip, I have not bothered to adapt my library for it. However, for the sake of completeness, I have included it in the list. <\/p>\n\n
Use of the MCP23x1y port expanders in detail<\/h2>\n\n
Below, I will discuss the following points for each member of the MCP23x1y family:<\/p>\n
- \n
- Pinout<\/li>\n
- Connection to the microcontroller<\/li>\n
- Simple input\/output operations with the MCP23017_WE<\/a> library<\/li>\n<\/ul>\n
As you can see, I have kept the name of the library. This is because I did not want to confuse those who already use the library. <\/p>\n\n
MCP23017<\/h3>\n\n
Pinout<\/h4>\n
\n![\"A](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/mcp23017_pinout-512x1024.png\")
<\/a><\/figure>\n<\/div>\nWe’ll start with the MCP23017. You supply it with 1.8 to 5.5 volts via VDD\/VSS. It is connected to the microcontroller’s I2C pins via SDA and SCL. The I2C connection often works without pull-up resistors, but I would recommend using them. We do not need the interrupt pins for the sketches used in this article. Connect the reset pin to an I\/O pin on your microcontroller. <\/p>\n
The I2C address is set using the following scheme: 0b00100-A2-A1-A0. If Ax is HIGH, replace it with a 1, otherwise replace it with a zero. So, for example, if you connect A0, A1 and A2 to LOW, the address is 0b00100000 = 0x20 = 32. <\/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.
<\/em><\/p>\n\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/06\/pinout_mcp23017_old_new-1024x341.png\")
<\/a>Pinout MCP23017 old vs. new (from 2022).<\/figcaption><\/figure>\n\n Example circuit <\/h4>\n\n
To try out the sample sketches, connect each GPIO to an LED. When selecting LEDs, keep in mind that the total current at VDD should not exceed 125 milliamps. This means that when all LEDs are lit, each individual LED may only consume an average of approximately 7.8 milliamps. The circuit on an Arduino Nano could look like this: <\/p>\n\n
![\"The](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/mcp23017_wiring_ard_nano-1024x643.png\")
<\/a>The MCP23017 connected to an Arduino Nano<\/figcaption><\/figure>\n\n If, like me, you don’t feel like wiring sixteen resistors and LEDs, then I recommend LED bars with integrated resistors, as shown below. They are available with a common anode or cathode: <\/p>\n
\n![\"LED](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/LED_bar_module-1024x403.jpg\")
<\/a>LED bars with common cathode (left) or common anode (right)<\/figcaption><\/figure>\n<\/div>\n I found the LED bars on AliExpress, by the way. This makes assembly quick and easy. And they only consume 2 to 3 milliamps per LED. This is what it looked like on my breadboard (without pull-ups): <\/p>\n
\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/Wiring_MCP23017_Test-1024x527.jpg\")
<\/a>Example circuit with LED bars connected to the MCP23017<\/figcaption><\/figure>\n<\/div>\n Example sketch for the MCP23017<\/h4>\n\n
The following example sketch shows how to create your MCP23017 object and control the LEDs with various functions.<\/p>\n<\/p>\n
\n#include <Wire.h>\n#include <MCP23017_WE.h>\n#define RESET_PIN 5 \n#define MCP_ADDRESS 0x20 \/\/ (A2\/A1\/A0 = LOW)\n\n\/* There are several ways to create your MCP23017 object:\n * MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS) -> uses Wire \/ no reset pin (if not needed)\n * MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS, RESET_PIN) -> uses Wire \/ RESET_PIN\n * MCP23017_WE myMCP = MCP23017_WE(&wire2, MCP_ADDRESS) -> uses the TwoWire object wire2 \/ no reset pin\n * MCP23017_WE myMCP = MCP23017_WE(&wire2, MCP_ADDRESS, RESET_PIN) -> all together\n *\/\n \ntypedef MCP23017_WE MCP;\nMCP myMCP = MCP(MCP_ADDRESS, RESET_PIN); \/\/ short version\n\/\/ MCP23017_WE myMCP = MCP23017_WE(MCP_ADDRESS, RESET_PIN); \/\/ long version\n\nint wT = 500; \/\/ wT = waiting time\n\nvoid setup(){ \n Wire.begin();\n myMCP.Init(); \n delay(wT);\n myMCP.setPortMode(0b11111111, MCP::A); \/\/ Port A: all pins are OUTPUT \n myMCP.setPortMode(0b11111111, MCP::B); \/\/ Port B: all pins are OUTPUT\n myMCP.setAllPins(MCP::A, MCP::ON); \/\/ Port A: all pins are HIGH\n myMCP.setAllPins(MCP::B, MCP::ON); \/\/ Port B: all Pins are HIGH\n delay(wT);\n myMCP.setAllPins(MCP::A, MCP::OFF); \/\/ Port A: all pins are LOW\n myMCP.setAllPins(MCP::B, MCP::OFF); \/\/ Port B: all pins are LOW \n delay(wT);\n byte portValue = 0;\n for(int i=0; i<8; i++){\n portValue += (1<<i); \/\/ 0b00000001, 0b00000011, 0b00000111, etc.\n myMCP.setPort(portValue, MCP::A);\n delay(wT);\n }\n portValue = 0;\n for(int i=0; i<8; i++){\n portValue += (1<<i); \/\/ 0b00000001, 0b00000011, 0b00000111, etc.\n myMCP.setPort(portValue, MCP::B);\n delay(wT);\n }\n myMCP.setAllPins(MCP::A, MCP::OFF); \/\/ Port A: all pins are LOW\n myMCP.setAllPins(MCP::B, MCP::OFF); \/\/ Port B: all pins are LOW \n delay(wT);\n myMCP.setPin(3, MCP::A, HIGH); \/\/ Pin 3 \/ PORT A is HIGH\n myMCP.setPin(1, MCP::B, HIGH); \/\/ Pin 1 \/ PORT B is HIGH\n delay(wT);\n myMCP.setAllPins(MCP::A, MCP::OFF); \/\/ Port A: all pins are LOW\n myMCP.setAllPins(MCP::B, MCP::OFF); \/\/ Port B: all pins are LOW \n myMCP.setPortMode(0, MCP::A); \/\/ Port A: all pins are INPUT \n myMCP.setPortMode(0, MCP::B); \/\/ Port B: all pins are INPUT\n myMCP.setPinX(1, MCP::A, OUTPUT, HIGH); \/\/ A1 HIGH \n delay(wT);\n myMCP.togglePin(1, MCP::A); \/\/ A1 LOW\n delay(wT);\n myMCP.togglePin(1, MCP::A); \/\/ A1 HIGH\n delay(wT); \n \/\/ the following two lines are similar to setPinX(2,MCP::B,OUTPUT,HIGH);\n myMCP.setPinMode(2, MCP::B, OUTPUT); \/\/ B2 is OUTPUT\n myMCP.setPin(2, MCP::B, HIGH); \/\/ B2 is HIGH\n delay(wT); \n myMCP.setPortX(0b00001111, 0b10001111, MCP::B); \/\/ B0-B4: OUTPUT\/HIGH, B7: INPUT, HIGH;\n}\n\nvoid loop(){ \n} <\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
This post is not intended to be a repeat of my first post about the MCP23017<\/a>, but a few explanations are certainly in order so that you don’t have to jump back and forth between posts.<\/p>\n
The GPIOs of the MCP23017 work in principle like those of an Arduino or other microcontrollers. You can set them as INPUT or OUTPUT, and you can switch them to HIGH or LOW. If you supply power to the LEDs via the GPIOs, the pins must be OUTPUT\/HIGH for the LEDs to light up. <\/p>\n
I have added a number of functions to the library that allow you to address individual pins or entire ports. “0” is always INPUT or LOW. “1” is OUTPUT or HIGH. Instead of HIGH or LOW, you can also use “ON” or “OFF”. These are all just synonyms for 0 or 1. <\/p>\n
- \n
setPinMode()<\/code>: determines the mode (INPUT \/ OUTPUT) for a pin.<\/li>\nsetPortMode()<\/code>: sets INPUT\/OUTPUT for an entire port, but individually for each pin.<\/li>\nsetPin()<\/code>: sets a pin to HIGH or LOW.<\/li>\nsetPort()<\/code>HIGH\/LOW for an entire port, but individually for each pin.<\/li>\nsetAllPins()<\/code>: sets all pins of a port uniformly to HIGH or LOW.<\/li>\nsetPinX()<\/code>: combinessetPinMode()<\/code> andsetPin()<\/code> in one function.<\/li>\nsetPortX()<\/code>: combinessetPortMode()<\/code> andsetPort()<\/code> in one function.<\/li>\ntogglePin()<\/code>: switches a pin from HIGH to LOW or vice versa.<\/li>\n<\/ul>\n\nMCP23S17<\/h3>\n\n
Pinout<\/h4>\n
\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/mcp23S17_pinout-510x1024.png\")
<\/a><\/figure>\n<\/div>\nUnlike the MCP23017, the MCP23S17 is controlled via SPI. Accordingly, it has an SCK (serial clock), SI (slave in), SO (slave out) and a CS (chip select) pin. <\/p>\n
At first, it is surprising that it also has the three address pins A0, A1 and A2. When you address the MCP23S17 via SPI, you must first pull the CS pin to LOW as usual. Then you send a control byte consisting of the address and the read\/write bit. This has the advantage that you can connect eight MCP23S17 ICs to one and the same CS line. This is followed by the register byte and then the data. Of course, you don’t have to worry about these things in detail, as the library takes care of them. <\/p>\n\n
Example circuit<\/h4>\n\n
The circuit for control via Arduino Nano is not particularly surprising:<\/p>\n\n
![\"The](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/mcp23s17_wiring_ard_nano-1024x640.png\")
<\/a>The MCP23S17 connected to an Arduino Nano<\/figcaption><\/figure>\n\n Example sketch<\/h4>\n\n
Since the MCP23S17 differs from the MCP23017 only in terms of SPI communication, the sample sketch is also only slightly different. One function has been added, namely
setSPIClockSpeed()<\/code>. This allows you to select the SPI clock rate within the capabilities of your microcontroller and the MCP23S17 (max. 10 MHz). The default setting for the library is 8 MHz. Otherwise, the sketch requires no further explanation. <\/p>\n<\/p>\n\n#include <SPI.h>\n#include <MCP23S17_WE.h>\n#define CS_PIN 7 \/\/ Chip Select Pin\n#define RESET_PIN 5 \n#define MCP_ADDRESS 0x20 \/\/ (A2\/A1\/A0 = LOW)\n\n\/* There are two ways to create your MCP23S17 object:\n * MCP23S17_WE myMCP = MCP23S17_WE(CS_PIN, RESET_PIN, MCP_ADDRESS);\n * MCP23S17_WE myMCP = MCP23S17_WE(&SPI, CS_PIN, RESET_PIN, MCP_ADDRESS);\n * The second option allows you to create your own SPI objects,\n * e.g. in order to use two SPI interfaces on the ESP32.\n *\/\ntypedef MCP23S17_WE MCP; \nMCP myMCP = MCP(CS_PIN, RESET_PIN, MCP_ADDRESS);\n\/\/MCP23S17_WE myMCP = MCP23S17_WE(CS_PIN, RESET_PIN, MCP_ADDRESS);\n\nint wT = 500; \/\/ wT = waiting time\n\nvoid setup(){ \n SPI.begin();\n myMCP.Init(); \n \/\/ myMCP.setSPIClockSpeed(8000000); \/\/ Choose SPI clock speed (after Init()!)\n delay(wT);\n myMCP.setPortMode(0b11111111, MCP::A); \/\/ Port A: all pins are OUTPUT \n myMCP.setPortMode(0b11111111, MCP::B); \/\/ Port B: all pins are OUTPUT\n myMCP.setAllPins(MCP::A, MCP::ON); \/\/ Port A: all pins are HIGH\n myMCP.setAllPins(MCP::B, MCP::ON); \/\/ Port B: all Pins are HIGH\n delay(wT);\n myMCP.setAllPins(MCP::A, MCP::OFF); \/\/ Port A: all pins are LOW\n myMCP.setAllPins(MCP::B, MCP::OFF); \/\/ Port B: all pins are LOW \n delay(wT);\n byte portValue = 0;\n for(int i=0; i<8; i++){\n portValue += (1<<i); \/\/ 0b00000001, 0b00000011, 0b00000111, etc.\n myMCP.setPort(portValue, MCP::A);\n delay(wT);\n }\n portValue = 0;\n for(int i=0; i<8; i++){\n portValue += (1<<i); \/\/ 0b00000001, 0b00000011, 0b00000111, etc.\n myMCP.setPort(portValue, MCP::B);\n delay(wT);\n }\n myMCP.setAllPins(MCP::A, MCP::OFF); \/\/ Port A: all pins are LOW\n myMCP.setAllPins(MCP::B, MCP::OFF); \/\/ Port B: all pins are LOW \n delay(wT);\n myMCP.setPin(3, MCP::A, HIGH); \/\/ Pin 3 \/ PORT A is HIGH\n myMCP.setPin(1, MCP::B, HIGH); \/\/ Pin 1 \/ PORT B is HIGH\n delay(wT);\n myMCP.setAllPins(MCP::A, MCP::OFF); \/\/ Port A: all pins are LOW\n myMCP.setAllPins(MCP::B, MCP::OFF); \/\/ Port B: all pins are LOW \n myMCP.setPortMode(0, MCP::A); \/\/ Port A: all pins are INPUT \n myMCP.setPortMode(0, MCP::B); \/\/ Port B: all pins are INPUT\n myMCP.setPinX(1, MCP::A, OUTPUT, HIGH); \/\/ A1 HIGH \n delay(wT);\n myMCP.togglePin(1, MCP::A); \/\/ A1 LOW\n delay(wT);\n myMCP.togglePin(1, MCP::A); \/\/ A1 HIGH\n delay(wT); \n \/\/ the following two lines are similar to setPinX(2,B,OUTPUT,HIGH);\n myMCP.setPinMode(2, MCP::B, OUTPUT); \/\/ B2 is OUTPUT\n myMCP.setPin(2, MCP::B, HIGH); \/\/ B2 is HIGH\n delay(wT); \n myMCP.setPortX(0b00001111, 0b10001111, MCP::B); \/\/ B0-B4: OUTPUT\/HIGH, B7: INPUT, HIGH;\n}\n\nvoid loop(){ \n} <\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
MCP23018<\/h3>\n\n
The MCP23018 is also I2C-controlled. However, there is a fundamental difference to the MCP23017. To light up an LED on the MCP23018, you have to use it as a current sink. This means that you do not supply the LED with current via the MCP23018, but rather allow the current to flow through the MCP23018. For this to happen, the respective pin must be in the OUTPUT\/LOW state. <\/p>\n\n
Pinout<\/h4>\n
\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/mcp23018_pinout-514x1024.png\")
<\/a><\/figure>\n<\/div>\nHowever, the MCP23018 has another special feature. In addition to the different assignment of the GPIOs, it has only a single address pin. The address is set via the voltage applied to the address pin. This is a rather unusual concept, the advantage of which I do not really understand. <\/p>\n
The scale for the “address voltage” is determined by the supply voltage VDD. If you apply 1\/16th of the supply voltage to the address pin, the address is 0x20. At 3\/16th, it is 0x21, at 5\/16th it is 0x22, at 7\/16th it is 0x23, etc. You set the highest address 0x27 by applying a voltage of 15\/16th VDD. You can also set 0x20 by going to VSS level (0\/16th) on the address pin and 0x27 by going to VDD level. The tolerances are lower for the other addresses. An overview of the tolerances and sample tables can be found in the data sheet<\/a> on page 11. <\/p>\n
If you want to operate eight MCP23018 ICs, a circuit (reduced to the I2C part) could look like this:<\/p>\n
\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/8_mcp23018_wiring-1024x626.png\")
<\/figure>\n<\/div>\nExample circuit<\/h4>\n\n
In my example circuit, the LEDs are powered via the Arduino Nano’s 5 volt output. The current flows through the MCP23018. I set the address using a voltage divider. Since I am only using a single MCP23018 here, I could have alternatively connected the address pin to GND or VDD. <\/p>\n\n
![\"The](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/mcp23018_wiring_ard_nano-1024x638.png\")
<\/a>The MCP23018 connected to an Arduino Nano<\/figcaption><\/figure>\n\n As before, I made life easy for myself and used LED bars with integrated resistors. In this case, of course, the version with a common anode: <\/p>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/Wiring_MCP23018_Test-1024x378.jpg\")
<\/a>Example circuit with LED bars attached to the MCP23018<\/figcaption><\/figure>\n\n I have also omitted the pull-ups for the I2C lines here (in case you are wondering where they are). However, I added them in the subsequent speed tests. <\/p>\n\n
Example sketch<\/h4>\n\n
At first glance, the sketch does not look very different from the previous ones. But if you take a closer look, you will see that I control the LEDs via OUTPUT\/INPUT and not via HIGH\/LOW. <\/p>\n<\/p>\n
\n#include <Wire.h>\n#include <MCP23018_WE.h>\n#define RESET_PIN 5 \n#define MCP_ADDRESS 0x20 \n\n\/* There are several ways to create your MCP23018 object:\n * MCP23018_WE myMCP = MCP23018_WE(MCP_ADDRESS) -> uses Wire \/ no reset pin (if not needed)\n * MCP23018_WE myMCP = MCP23018_WE(MCP_ADDRESS, RESET_PIN) -> uses Wire \/ RESET_PIN\n * MCP23018_WE myMCP = MCP23018_WE(&wire2, MCP_ADDRESS) -> uses the TwoWire object wire2 \/ no reset pin\n * MCP23018_WE myMCP = MCP23018_WE(&wire2, MCP_ADDRESS, RESET_PIN) -> all together\n * Successfully tested with two I2C busses on an ESP32\n *\/\ntypedef MCP23018_WE MCP;\nMCP myMCP = MCP(MCP_ADDRESS, RESET_PIN); \/\/ short version\n\/\/ MCP23018_WE myMCP = MCP23018_WE(MCP_ADDRESS, RESET_PIN); \/\/ long version\n\nint wT = 500; \/\/ wT = waiting time\n\nvoid setup(){ \n Wire.begin();\n myMCP.Init(); \n delay(wT);\n myMCP.setAllPins(MCP::A, MCP::OFF); \/\/ Port A: all pins are LOW\n myMCP.setAllPins(MCP::B, MCP::OFF); \/\/ Port B: all Pins are LOW\n myMCP.setPortMode(0b11111111, MCP::A); \/\/ Port A: all pins are OUTPUT = LEDs are on!\n myMCP.setPortMode(0b11111111, MCP::B); \/\/ Port B: all pins are OUTPUT\n delay(wT);\n myMCP.setPortMode(0b00000000, MCP::A); \/\/ Port A: all pins are INPUT = LEDs are off\n myMCP.setPortMode(0b00000000, MCP::B); \/\/ Port B: all pins are INPUT\n delay(wT);\n byte portModeValue = 0; \/\/ = 0b00000000\n for(int i=0; i<8; i++){\n portModeValue += (1<<i); \/\/ 0b00000001, 0b00000011, 0b00000111, etc.\n myMCP.setPortMode(portModeValue, MCP::A);\n delay(wT);\n }\n portModeValue = 0;\n for(int i=0; i<8; i++){\n portModeValue += (1<<i); \/\/ 0b00000001, 0b00000011, 0b00000111, etc.\n myMCP.setPortMode(portModeValue, MCP::B);\n delay(wT);\n }\n myMCP.setPortMode(0, MCP::A); \/\/ Port A: all pins are INPUT\n myMCP.setPortMode(0, MCP::B); \/\/ Port B: all pins are INPUT \n delay(wT);\n myMCP.setPinMode(3, MCP::A, OUTPUT); \/\/ Pin 3 \/ PORT A is OUTPUT\/LOW\n myMCP.setPinMode(1, MCP::B, OUTPUT); \/\/ Pin 1 \/ PORT B is OUTPUT\/LOW\n delay(wT);\n myMCP.setPortMode(0, MCP::A); \/\/ Port A: all pins are INPUT\n myMCP.setPortMode(0, MCP::B); \/\/ Port B: all pins are INPUT\n myMCP.setPinX(1, MCP::A, OUTPUT, LOW); \/\/ A1 HIGH \n delay(wT);\n myMCP.togglePin(1, MCP::A); \/\/ A1 LOW\n delay(wT);\n myMCP.togglePin(1, MCP::A); \/\/ A1 HIGH\n delay(wT); \n \/\/ the following two lines are similar to setPinX(2,B,OUTPUT,LOW);\n myMCP.setPinMode(2, MCP::B, OUTPUT); \/\/ B2 is OUTPUT\/LOW\n myMCP.setPin(2, MCP::B, LOW); \/\/ B2 is still OUTPUT\/LOW\n delay(wT); \n myMCP.setPortX(0b10001111, 0b10000000, MCP::B); \/\/ B0-B4: OUTPUT\/LOW, B7: OUTPUT, HIGH;\n}\n\nvoid loop(){ \n} <\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
If a pin is in the OUPUT\/LOW state, the connected LED lights up. Instead of switching it off by changing to INPUT\/LOW, you can achieve the same result by switching to OUTPUT\/HIGH. <\/p>\n\n
MCP23S18<\/h3>\n\n
Pinout<\/h4>\n
\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/mcp23S18_pinout-516x1024.png\")
<\/a><\/figure>\n<\/div>\nThe MCP23S18 offers no big surprises. It is simply the SPI version of the MCP23018. Unlike the MCP23S17, however, it does not have the option of being addressed with different addresses. Accordingly, you must connect each individual MCP23S18 to its own CS line. <\/p>\n
Nevertheless, the MCP23S18 expects a “device opcode” consisting of 0x20 and the read\/write bit as the first byte for write or read operations. The library takes care of this. However, when creating the MCP23S18 object, you must always pass 0x20 (MCP_SPI_CTRL_BYTE) as well. This is simply for compatibility reasons. <\/p>\n\n
Example circuit<\/h4>\n\n
For the sake of completeness, here is the example circuit:<\/p>\n\n
![\"The](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/mcp23s18_wiring_ard_nano-1024x636.png\")
<\/a>The MCP23S18 connected to an Arduino Nano<\/figcaption><\/figure>\n\n Example sketch<\/h4>\n\n
The example sketch is not surprising.<\/p>\n<\/p>\n
\n#include <SPI.h>\n#include <MCP23S18_WE.h>\n#define CS_PIN 7 \/\/ Chip Select Pin\n#define RESET_PIN 5 \n#define MCP_SPI_CTRL_BYTE 0x20 \/\/ Do not change\n\n\/* There are two ways to create your MCP23S18 object:\n * MCP23S18_WE myMCP = MCP23S18_WE(CS_PIN, RESET_PIN, MCP_CTRL_BYTE);\n * MCP23S18_WE myMCP = MCP23S18_WE(&SPI, CS_PIN, RESET_PIN, MCP_CTRL_BYTE);\n * The second option allows you to create your own SPI objects,\n * e.g. in order to use two SPI interfaces on the ESP32.\n *\/\ntypedef MCP23S18_WE MCP;\nMCP myMCP = MCP(CS_PIN, RESET_PIN, MCP_SPI_CTRL_BYTE); \/\/ short version\n\/\/ MCP23S18_WE myMCP = MCP23S18_WE(CS_PIN, RESET_PIN, MCP_SPI_CTRL_BYTE); \/\/ long version\n\nint wT = 500; \/\/ wT = waiting time\n\nvoid setup(){ \n SPI.begin();\n myMCP.Init(); \n \/\/ myMCP.setSPIClockSpeed(8000000); \/\/ Choose SPI clock speed (after Init()!)\n delay(wT);\n myMCP.setAllPins(MCP::A, MCP::OFF); \/\/ Port A: all pins are LOW\n myMCP.setAllPins(MCP::B, MCP::OFF); \/\/ Port B: all Pins are LOW\n myMCP.setPortMode(0b11111111, MCP::A); \/\/ Port A: all pins are OUTPUT = LEDs are on!\n myMCP.setPortMode(0b11111111, MCP::B); \/\/ Port B: all pins are OUTPUT\n delay(wT);\n myMCP.setPortMode(0b00000000, MCP::A); \/\/ Port A: all pins are INPUT = LEDs are off\n myMCP.setPortMode(0b00000000, MCP::B); \/\/ Port B: all pins are INPUT\n delay(wT);\n byte portModeValue = 0; \/\/ = 0b00000000\n for(int i=0; i<8; i++){\n portModeValue += (1<<i); \/\/ 0b00000001, 0b00000011, 0b00000111, etc.\n myMCP.setPortMode(portModeValue, MCP::A);\n delay(wT);\n }\n portModeValue = 0;\n for(int i=0; i<8; i++){\n portModeValue += (1<<i); \/\/ 0b00000001, 0b00000011, 0b00000111, etc.\n myMCP.setPortMode(portModeValue, MCP::B);\n delay(wT);\n }\n myMCP.setPortMode(0, MCP::A); \/\/ Port A: all pins are INPUT\n myMCP.setPortMode(0, MCP::B); \/\/ Port B: all pins are INPUT \n delay(wT);\n myMCP.setPinMode(3, MCP::A, OUTPUT); \/\/ Pin 3 \/ PORT A is OUTPUT\/LOW\n myMCP.setPinMode(1, MCP::B, OUTPUT); \/\/ Pin 1 \/ PORT B is OUTPUT\/LOW\n delay(wT);\n myMCP.setPortMode(0, MCP::A); \/\/ Port A: all pins are INPUT\n myMCP.setPortMode(0, MCP::B); \/\/ Port B: all pins are INPUT\n myMCP.setPinX(1, MCP::A, OUTPUT, LOW); \/\/ A1 HIGH \n delay(wT);\n myMCP.togglePin(1, MCP::A); \/\/ A1 LOW\n delay(wT); myMCP.togglePin(1, MCP::A);\/\/ A1 HIGH\n delay(wT); \n \/\/ the following two lines are similar to setPinX(2,MCP::B,OUTPUT,LOW);\n myMCP.setPinMode(2, MCP::B, OUTPUT); \/\/ B2 is OUTPUT\/LOW\n myMCP.setPin(2, MCP::B, LOW); \/\/ B2 is still OUTPUT\/LOW\n delay(wT); \n myMCP.setPortX(0b10001111, 0b10000000, MCP::B); \/\/ B0-B4: OUTPUT\/LOW, B7: OUTPUT, HIGH;\n}\n\nvoid loop(){ \n} <\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
MCP23016<\/h3>\n\n
Pinout<\/h4>\n
\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/mcp23016_pinout-514x1024.png\")
<\/a><\/figure>\n<\/div>\nAs you can see on the right, the MCP23016 stands out from the other members of the MCP23x1y family. The GPIOs are named differently, and there is no reset pin. There is also a CLK and TP pin. <\/p>\n
CLK must be connected to GND via a capacitor and to VDD via a resistor. This is used to set the clock speed. The data sheet recommends a combination of 33 pF \/ 3.9 k\u03a9. I also had success with 30 pF \/ 3.9 k\u03a9. You can check the clock signal at TP, otherwise leave it unconnected. <\/p>\n
The biggest difference to the other family members is its different register architecture. Since it is no longer recommended, I decided not to implement it in my library. Instead, I tried out the CyMCP23016 library, which you can find here<\/a> on GitHub. Overall, the selection of libraries for the MCP23016 is not huge. <\/p>\n\n
Example circuit with an Arduino Nano<\/h4>\n\n
The CyMCP23016 library comes with a sample sketch, which I tested with the following circuit. In the sketch, only one LED is connected to GPIO 0.0. However, this is sufficient to illustrate the principle. I will not display the sketch here. <\/p>\n\n
![\"The](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/MCP23016__I2C_test_wiring-1024x469.png\")
<\/a>The MCP23016 on an Arduino Nano<\/figcaption><\/figure>\n\n I2C vs. SPI \u2013 speed tests<\/h2>\n\n
When I personally have the choice between I2C and SPI, I tend to favour I2C because fewer wires are required. This is especially true when multiple devices need to be controlled. However, SPI has the edge in applications that require high transmission speeds. I conducted a few tests to investigate this. <\/p>\n\n
I2C using the Arduino Nano<\/h3>\n\n
The MCP23017 supports an I2C clock speed of 1.7 MHz, while the MCP23018 supports up to 3.4 MHz. The problem, however, is that most microcontrollers do not support these high clock speeds, including ATmega328P-based Arduinos such as the UNO, Nano or Pro Mini. I tested 100 kHz (standard) and 400 kHz (Fast I2C) on the Arduino Nano. To do this, I determined the time it takes to read a port 10,000 times (
digitalRead()<\/code> for an entire port, so to speak). <\/p>\nHere is the sketch:<\/p>\n<\/p>\n
\n#include <Wire.h>\n#include <MCP23017_WE.h>\n#define MCP_ADDRESS 0x20 \/\/ (A2\/A1\/A0 = LOW)\n#define RESET_PIN 5 \n\ntypedef MCP23017_WE MCP;\nMCP myMCP = MCP(MCP_ADDRESS, RESET_PIN);\n\nvoid setup(){ \n Serial.begin(115200);\n long startTime = 0;\n long readTime = 0;\n byte portStatus = 0;\n Wire.begin();\n myMCP.Init(); \n startTime = millis();\n for(long i=0; i<10000; i++){\n portStatus = myMCP.getPort(MCP::A);\n }\n readTime = millis() - startTime;\n Serial.print(\"Duration@100kHz [ms]: \");\n Serial.println(readTime);\n Serial.print(\"Duration@100kHz per Read [ms]: \");\n Serial.println(readTime\/10000.0);\n\n Wire.setClock(400000);\n startTime = millis();\n for(long i=0; i<10000; i++){\n portStatus = myMCP.getPort(MCP::A);\n }\n readTime = millis() - startTime;\n Serial.print(\"Duration@400kHz [ms]: \");\n Serial.println(readTime);\n Serial.print(\"Duration@400kHz per Read [ms]: \");\n Serial.println(readTime\/10000.0);\n}\n \nvoid loop(){ \n} <\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
And here’s the result:<\/p>\n
\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/speed_test_i2C_ardu_nano.png\")
<\/a>Output of I2C_speed_test_mcp23017_nano.ino<\/figcaption><\/figure>\n<\/div>\n I2C using the ESP32<\/h3>\n\n
Dann habe ich den Test mit dem ESP32 wiederholt und dabei versucht, 1.7 MHz einzustellen, da ich meinte, der ESP32 k\u00f6nne das.<\/p>\n<\/p>\n
\n#include <Wire.h>\n#include <MCP23017_WE.h>\n#define MCP_ADDRESS 0x20 \/\/ (A2\/A1\/A0 = LOW)\n#define RESET_PIN 18 \n\ntypedef MCP23017_WE MCP;\nMCP myMCP = MCP(MCP_ADDRESS, RESET_PIN);\n\nvoid setup(){ \n Serial.begin(115200);\n long startTime = 0;\n long readTime = 0;\n byte portStatus = 0;\n Wire.begin();\n myMCP.Init(); \n \n startTime = millis();\n for(long i=0; i<10000; i++){\n portStatus = myMCP.getPort(MCP::A);\n }\n readTime = millis() - startTime;\n Serial.print(\"Duration@100kHz [ms]: \");\n Serial.println(readTime);\n Serial.print(\"Duration@100kHz per Read [ms]: \");\n Serial.println(readTime\/10000.0);\n\n Wire.setClock(400000);\n startTime = millis();\n for(long i=0; i<10000; i++){\n portStatus = myMCP.getPort(MCP::A);\n }\n readTime = millis() - startTime;\n Serial.print(\"Duration@400kHz [ms]: \");\n Serial.println(readTime);\n Serial.print(\"Duration@400kHz per Read [ms]: \");\n Serial.println(readTime\/10000.0);\n\n Wire.setClock(1700000);\n startTime = millis();\n for(long i=0; i<10000; i++){\n portStatus = myMCP.getPort(MCP::A);\n }\n readTime = millis() - startTime;\n Serial.print(\"Duration@1.7MHz [ms]: \");\n Serial.println(readTime);\n Serial.print(\"Duration@1.7MHz per Read [ms]: \");\n Serial.println(readTime\/10000.0);\n}\n \nvoid loop(){ \n} <\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
Der magere Geschwindigkeitszuwachs bei 1.7 MHz wunderte mich zun\u00e4chst: <\/p>\n
\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/speed_test_i2C_esp32.png\")
Output of I2C_speed_test_mcp23017_esp32.ino<\/figcaption><\/figure>\n<\/div>\n However, measuring the actual clock rate with the logic analyzer<\/a> revealed that even the ESP32 cannot deliver the 1.7 MHz clock rate. It stopped at 655 kHz. This (roughly) corresponds to what I have found elsewhere on the subject, e.g. here<\/a> on GitHub. <\/p>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/max_I2C_speed_ESP32.png\")
<\/a>Actual I2C clock using the ESP32<\/figcaption><\/figure>\n\n SPI using Arduino Nano <\/h3>\n\n
The Arduino Nano and all other boards based on the ATmega328P can deliver an SPI clock rate of up to 16 MHz. The MCP23S17 can handle an SPI clock rate of 10 MHz. However, you cannot set 10 MHz on the Arduino Nano, only quotients of 16 MHz and integer divisors, i.e. 8 MHz, 4 MHz, 2 MHz, etc. 8 MHz is therefore the maximum. If you specify other values, the next possible lower frequency will be used. <\/p>\n\n
This is the sketch:<\/p>\n<\/p>\n
\n#include <SPI.h>\n#include <MCP23S17_WE.h>\n#define CS_PIN 7 \/\/ Chip Select Pin\n#define RESET_PIN 5 \n#define MCP_ADDRESS 0x20 \/\/ (A2\/A1\/A0 = LOW)\n\ntypedef MCP23S17_WE MCP;\nMCP myMCP = MCP(CS_PIN, RESET_PIN, MCP_ADDRESS);\n\nvoid setup(){ \n Serial.begin(115200);\n long startTime = 0;\n long readTime = 0;\n byte portStatus;\n SPI.begin();\n myMCP.Init(); \n \n myMCP.setSPIClockSpeed(2000000); \/\/ Choose SPI clock speed (after Init()!\n startTime = millis();\n for(long i=0; i<10000; i++){\n portStatus = myMCP.getPort(MCP::A);\n }\n readTime = millis() - startTime;\n Serial.print(\"Duration@2MHz [ms]: \");\n Serial.println(readTime);\n Serial.print(\"Duration@2MHz per Read [\u00b5s]: \");\n Serial.println(readTime\/10.0);\n \n myMCP.setSPIClockSpeed(4000000); \/\/ Choose SPI clock speed (after Init()!)\n startTime = millis();\n for(long i=0; i<10000; i++){\n portStatus = myMCP.getPort(MCP::A);\n }\n readTime = millis() - startTime;\n Serial.print(\"Duration@4MHz [ms]: \");\n Serial.println(readTime);\n Serial.print(\"Duration@4MHz per Read [\u00b5s]: \");\n Serial.println(readTime\/10.0);\n\n myMCP.setSPIClockSpeed(8000000);\n startTime = millis();\n for(long i=0; i<10000; i++){\n portStatus = myMCP.getPort(MCP::A);\n }\n readTime = millis() - startTime;\n Serial.print(\"Duration@8MHz [ms]: \");\n Serial.println(readTime);\n Serial.print(\"Duration@8MHz per Read [\u00b5s]: \");\n Serial.println(readTime\/10.0);\n}\n \nvoid loop(){} <\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
And here’s the result:<\/p>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/speed_test_spi_nano.png\")
<\/figure>\n\nWhen using an ATmega328P-based board, you can achieve almost ten times the read rate by switching from the MCP23017 to the MCP23S17.<\/p>\n
Reading out the Arduino’s own pins is still much faster. A
digitalRead()<\/code> only takes about 3.5 \u00b5s on the Arduino Nano. And reading out the PINB\/PIND registers directly is even faster. This only takes about 0.44 \u00b5s. For details, see my post on port manipulation<\/a>. <\/p>\n\nMaximum “toggle” speed <\/h4>\n\n
Last but not least, I tried to see how quickly a GPIO of the MCP23S17 can be switched back and forth between HIGH and LOW (“toggle”). I selected pin A1 and ran the following short sketch on the Arduino Nano: <\/p>\n<\/p>\n
#include <SPI.h>\n#include <MCP23S17_WE.h>\n#define CS_PIN 7 \/\/ Chip Select Pin\n#define RESET_PIN 5 \n#define MCP_ADDRESS 0x20 \/\/ (A2\/A1\/A0 = LOW)\n\ntypedef MCP23S17_WE MCP;\nMCP myMCP = MCP(CS_PIN, RESET_PIN, MCP_ADDRESS);\n\nvoid setup(){ \n Serial.begin(115200);\n SPI.begin();\n myMCP.Init();\n myMCP.setSPIClockSpeed(8000000);\n myMCP.setPinX(1, MCP::A, OUTPUT, LOW);\n}\n \nvoid loop(){ \n myMCP.setPort(0b00000010, MCP::A);\n myMCP.setPort(0, MCP::A);\n} <\/pre>\n\u00a0<\/p>\n
\n\n
The maximum frequency is approximately 16 kHz. By comparison, digitalRead() achieves 127 kHz, and port manipulation even achieves approximately 2.3 MHz. <\/p>\n
- MCP230<\/strong>17<\/strong> \/ MCP23S<\/strong>17<\/strong> (link to data sheet<\/a>)<\/li>\n
- I2C using the ESP32<\/a><\/li>\n
- MCP23S17<\/a><\/li>\n
- Use of the MCP23x1y port expanders in detail<\/a>\n
![\"Maximum](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/pin_toggle_mcp23S17_8mhz.png\")
<\/a>