# Adafruit AirLift FeatherWing - ESP32 WiFi Co-Processor ## Overview ![](https://cdn-learn.adafruit.com/assets/assets/000/141/898/medium800/adafruit_products_4264-07.jpg?1768487478 ) Give your Feather project a _lift_ with the Adafruit AirLift FeatherWing - a FeatherWing that lets you use the powerful ESP32 as a WiFi or BLE co-processor. You probably have your favorite Feather ([like the Feather M4](https://www.adafruit.com/product/3857)) that comes with its own set of awesome peripherals and lots of libraries. But it doesn't have WiFi built in! So lets give that chip a best friend, the ESP32. This chip can handle all the heavy lifting of connecting to a WiFi network and transferring data from a site, even if its using the latest TLS/SSL encryption (it has root certificates pre-burned in). Having WiFi managed by a separate chip means your code is simpler, you don't have to cache socket data, or compile in & debug an SSL library. Send basic but powerful socket-based commands over 8MHz SPI for high speed data transfer. You can use 3V or 5V Arduino, any chip from the ATmega328 or up, although the '328 will not be able to do very complex tasks or buffer a lot of data. It also works great with CircuitPython, a SAMD51/Cortex M4 minimum required since we need a bunch of RAM. All you need is an SPI bus and 2 control pins plus a power supply that can provide up to 250mA during WiFi usage. The ESP32 also supports BLE (Bluetooth Low Energy), though not simultaneously with WiFi. Many of our CircuitPython builds include native support for ESP32 BLE. You use a few control pins and the RXI and TXO pins to talk to the ESP32 when it's in BLE mode.  ![](https://cdn-learn.adafruit.com/assets/assets/000/076/178/medium800/adafruit_products_4264_kit_ORIG_2019_05.jpg?1559138167) We placed an ESP32 module on a FeatherWing with a separate 3.3V regulator, and a tri-state chip for MOSI so you can share the SPI bus with other 'Wing. Comes fully assembled and tested, pre-programmed with ESP32 SPI WiFi co-processor firmware that [you can use in CircuitPython to use this into  WiFi co-processsor over SPI + 2 pins](https://github.com/adafruit/Adafruit_CircuitPython_ESP32SPI). We also toss in some header so you can solder it in and plug into a doubler, but you can also pick up a set of stacking headers to stack above/below your Feather. We've tested this with all our Feathers and it should work just fine with them except the ESP8266 & ESP32 Feathers (cause they already have WiFi!).  **For use in Arduino** , the '328 and '32u4 you can do basic connectivity and data transfer but they do not have a lot of RAM so we don't recommend them - use the M0, M4 or similar, for best results!  **For CircuitPython use** , a Feather M4 or nRF52840 works best - the M0 series does not have enough RAM in CircuitPython. [The firmware on board is a slight variant of the Arduino WiFiNINA core, which works great!](https://github.com/adafruit/nina-fw)  ![](https://cdn-learn.adafruit.com/assets/assets/000/076/180/medium800/adafruit_products_4264_quarter_ORIG_2019_05.jpg?1559138221) **Revision History:** - **As of April 24, 2023**  - we've updated this PCB with [Adafruit Pinguin](https://github.com/adafruit/Adafruit_Pinguin) to make a lovely and legible silkscreen, also has a smaller ESP32-Mini module and now comes with STEMMA QT connector. It is otherwise functionally identical and all code/firmware/libraries will work the same. ![](https://cdn-learn.adafruit.com/assets/assets/000/141/899/medium800/adafruit_products_4264-10.jpg?1768487501 ) # Adafruit AirLift FeatherWing - ESP32 WiFi Co-Processor ## Pinouts There are two revisions of this board, denoted by letters in a circle on the back. Rev B does not have a STEMMA QT connector on the front, Rev C does. **Rev B** (no STEMMA QT connector opposite the ESP32 module) ![](https://cdn-learn.adafruit.com/assets/assets/000/141/930/medium800/adafruit_products_a1.png?1769027539) **Rev C** (STEMMA QT connector on left, opposite the ESP32 module) ![](https://cdn-learn.adafruit.com/assets/assets/000/141/931/medium800/adafruit_products_b.png?1769027614) **Revision History:** **As of April 24, 2023**  - we've updated this PCB with [Adafruit Pinguin](https://github.com/adafruit/Adafruit_Pinguin) to make a lovely and legible silkscreen. It also has a smaller ESP32-Mini module and now comes with STEMMA QT connector. **It is otherwise functionally identical and all code/firmware/libraries will work the same.** Primary: Rev B and Rev C Airlift FeatherWing Coprocessors are functionally identical and all code/firmware/libraries will work the same. ## Power Pins - **GND ** - Common power/logic ground. - **BAT**  - Positive voltage from JST on Feather for an _optional_ LiPo battery. - **USB ** - Positive voltage to/from the Micro USB jack if connected. - **EN**  - 3.3V regulator's enable pin. It's pulled up, so connect to ground to disable the 3.3V regulator - **3V**  - this is the output from the 3.3V regulator. The regulator can supply 500mA peak but half of that is drawn by the ESP32, and it's a fairly power-hungry chip. So if you need a ton of power for stuff like LEDs, motors, etc. Use the  **USB**  or  **BAT**  pins, and an additional regulator ![](https://cdn-learn.adafruit.com/assets/assets/000/076/202/medium800/adafruit_products_4264_power_pins.png?1559156061) ## SPI and Control Pins To keep transfers speedy, we use SPI _not UART Serial. _UART is too slow and hard to synchronize. This uses more pins but the experience is much better! ![](https://cdn-learn.adafruit.com/assets/assets/000/076/206/medium800/adafruit_products_4264_spi_and_control_pins.png?1559156755) ![](https://cdn-learn.adafruit.com/assets/assets/000/076/207/medium800/adafruit_products_4264_back_spi_control_pins.png?1559156965) Classic SPI Pins: - **SCK**  - SPI Clock from your microcontroller, level shifted so can be 3-5V logic - **MISO**  - SPI Data _from_ the AirLift _to_ the microcontroller, this is 3.3V logic out, can be read by 3-5V logic. This is tri-stated when not selected, so you can share the SPI bus with other devices. - **MOSI** - SPI Data _to _the AirLift _from_ the microcontroller, level shifted so can be 3-5V logic - **ESPCS ** - SPI Chip Select from the microcontroller to start sending commands to the AirLift, level shifted so can be 3-5V logic Required Control Pins: - **ESPBUSY ** - this pin is an input from the AirLift, it will let us know when its ready for more commands to be sent. This is 3.3V logic out, can be read by 3-5V logic. This pin _must_ be connected. - **ESPRST** - this pin is an output to the AirLift. Set low to put the AirLift into reset. You should use this pin, even though you might be able to run for a short while without it, it's essential to 'kick' the chip if it ever gets into a locked up state. Level shifted so can be 3-5V logic Optional Control Pins: - **ESPGPIO0**  - this is the ESP32  **GPIO0 ** pin, which is used to put it into bootloading mode. It is also used if you like when the ESP32 is acting as a server, to let you know data is ready for reading. It's not required for WiFi, but you'll need to connect it to use BLE mode. Solder the pad on the bottom of the FeatherWing to connect it. - **ESPRX ** &  **ESPTX** - Serial data in and Serial data out, used for bootloading new firmware, and for communication when in BLE mode. Leave disconnected if not using BLE or when not uploading new WiFi firmware to the AirLift (which is a rare occurrence). You'll need to solder the two pads on the bottom of the FeatherWing to use these pins. ## RGB LED There is a small RGB LED to the left of the ESP32. These RGB LEDs are available in the Arduino and CircuitPython libraries if you'd like to PWM them for a visual alert. They're connected to the ESP32's pins 26 ( **Red** ), 25 ( **Green** ), and 27 ( **Blue** ). ## I2C The AirLift FeatherWing does not use the I2C pins (SCL, SDA) of the Feather its connected to - these pins are free to be used by external I2C sensors. **Rev C (released April 24, 2023)** now comes with a STEMMA QT port for easily connecting I2C devices with a STEMMA QT cable. ![](https://cdn-learn.adafruit.com/assets/assets/000/141/900/medium800/adafruit_products_4264-10.jpg?1768487570 ) # Adafruit AirLift FeatherWing - ESP32 WiFi Co-Processor ## Assembly ![](https://cdn-learn.adafruit.com/assets/assets/000/076/182/medium800/adafruit_products_4264_kit_ORIG_2019_05.jpg?1559138355) ## Prepare the header strip:   Cut the strip to length if necessary. It will be easier to solder if you insert it into a breadboard -  **long pins down** ![adafruit_products_feather_1-headers.jpg](https://cdn-learn.adafruit.com/assets/assets/000/076/183/medium640/adafruit_products_feather_1-headers.jpg?1559139312) ## Add the FeatherWing: Place the FeatherWing over the pins so that the short pins poke through the two rows of breakout pads ![adafruit_products_feather_2-placement.jpg](https://cdn-learn.adafruit.com/assets/assets/000/076/184/medium640/adafruit_products_feather_2-placement.jpg?1559139325) ## And Solder! Be sure to solder all pins for reliable electrical contact. _(For tips on soldering, be sure to check out our_[_Guide to Excellent Soldering_](http://learn.adafruit.com/adafruit-guide-excellent-soldering)_)._ Start by soldering the first row of headers ![adafruit_products_feather_3-solder1.jpg](https://cdn-learn.adafruit.com/assets/assets/000/076/185/medium640/adafruit_products_feather_3-solder1.jpg?1559139415) ![adafruit_products_feather_3-solder2.jpg](https://cdn-learn.adafruit.com/assets/assets/000/076/186/medium640/adafruit_products_feather_3-solder2.jpg?1559139427) ![adafruit_products_feather_3-solder3.jpg](https://cdn-learn.adafruit.com/assets/assets/000/076/187/medium640/adafruit_products_feather_3-solder3.jpg?1559139433) ![adafruit_products_feather_3-solderfinished.jpg](https://cdn-learn.adafruit.com/assets/assets/000/076/188/medium640/adafruit_products_feather_3-solderfinished.jpg?1559139438) Now flip around and solder the other row completely ![adafruit_products_feather_4-solder1.jpg](https://cdn-learn.adafruit.com/assets/assets/000/076/189/medium640/adafruit_products_feather_4-solder1.jpg?1559139476) ![adafruit_products_feather_4-solder2.jpg](https://cdn-learn.adafruit.com/assets/assets/000/076/190/medium640/adafruit_products_feather_4-solder2.jpg?1559139481) ![adafruit_products_feather_4-solder3.jpg](https://cdn-learn.adafruit.com/assets/assets/000/076/191/medium640/adafruit_products_feather_4-solder3.jpg?1559139488) ![adafruit_products_feather_4-solder4.jpg](https://cdn-learn.adafruit.com/assets/assets/000/076/192/medium640/adafruit_products_feather_4-solder4.jpg?1559139501) You're done! # Adafruit AirLift FeatherWing - ESP32 WiFi Co-Processor ## Internet Connect! # Connect to WiFi OK, now that you have your  **settings.toml** file set up - you can connect to the Internet. To do this, you need to first install a few libraries, into the lib folder on your **CIRCUITPY** drive. Then you need to update **code.py** with the example script. Thankfully, we can do this in one go. In the example below, click the **Download Project Bundle** button below to download the necessary libraries and the **code.py** file in a zip file. Extract the contents of the zip file, open the directory **examples/** and then click on the directory that matches the version of CircuitPython you're using and copy the contents of that directory to your **CIRCUITPY** drive. Your **CIRCUITPY** drive should now look similar to the following image: ![CIRCUITPY](https://adafruit.github.io/Adafruit_CircuitPython_Bundle/esp32spi_esp32spi_simpletest.py.png ) Info: Update to CircuitPython 9.2.x or later to use this example. https://github.com/adafruit/Adafruit_CircuitPython_ESP32SPI/blob/main/examples/esp32spi_simpletest.py And save it to your board, with the name **code.py**. Don't forget you'll also need to create the **settings.toml** file as seen above, with your WiFi ssid and password. In a serial console, you should see something like the following. For more information about connecting with a serial console, view the guide [Connecting to the Serial Console](https://learn.adafruit.com/welcome-to-circuitpython/kattni-connecting-to-the-serial-console). ```terminal >>> import wifitest ESP32 SPI webclient test ESP32 found and in idle mode Firmware vers. 1.7.5 MAC addr: 24:C9:DC:BD:0F:3F HomeNetwork RSSI: -46 HomeNetwork RSSI: -76 Fios-12345 RSSI: -92 FiOS-AB123 RSSI: -92 NETGEAR53 RSSI: -93 Connecting to AP... Connected to HomeNetwork RSSI: -45 My IP address is 192.168.1.245 IP lookup adafruit.com: 104.20.39.240 Ping google.com: 30 ms Fetching text from http://wifitest.adafruit.com/testwifi/index.html ---------------------------------------- This is a test of Adafruit WiFi! If you can read this, its working :) ---------------------------------------- Fetching json from http://wifitest.adafruit.com/testwifi/sample.json ---------------------------------------- {'fun': True, 'company': 'Adafruit', 'founded': 2005, 'primes': [2, 3, 5], 'pi': 3.14, 'mixed': [False, None, 3, True, 2.7, 'cheese']} ---------------------------------------- Done! ``` Going over the example above, here's a breakdown of what the program is doing: - Initialize the ESP32 over SPI using the SPI port and 3 control pins: ```python esp32_cs = DigitalInOut(board.ESP_CS) esp32_ready = DigitalInOut(board.ESP_BUSY) esp32_reset = DigitalInOut(board.ESP_RESET) #... else: spi = busio.SPI(board.SCK, board.MOSI, board.MISO) esp = adafruit_esp32spi.ESP_SPIcontrol(spi, esp32_cs, esp32_ready, esp32_reset) ``` - Get the socket pool and the SSL context, and then tell the `adafruit_requests` library about them. ```python pool = adafruit_connection_manager.get_radio_socketpool(esp) ssl_context = adafruit_connection_manager.get_radio_ssl_context(esp) requests = adafruit_requests.Session(pool, ssl_context) ``` - Verify an ESP32 is found, checks the firmware and MAC address ```auto if esp.status == adafruit_esp32spi.WL_IDLE_STATUS: print("ESP32 found and in idle mode") print("Firmware vers.", esp.firmware_version) print("MAC addr:", ":".join("%02X" % byte for byte in esp.MAC_address)) ``` - Perform a scan of all access points it can see and print out the name and signal strength. ```python for ap in esp.scan_networks(): print("\t%-23s RSSI: %d" % (ap.ssid, ap.rssi)) ``` - Connect to the AP we've defined here, then print out the local IP address. Then attempt to do a domain name lookup and ping google.com to check network connectivity. (Note sometimes the ping fails or takes a while; this isn't a big deal.) ```python print("Connecting to AP...") while not esp.is_connected: try: esp.connect_AP(ssid, password) except OSError as e: print("could not connect to AP, retrying: ", e) continue print("Connected to", esp.ap_info.ssid, "\tRSSI:", esp.ap_info.rssi) print("My IP address is", esp.ipv4_address) print( "IP lookup adafruit.com: %s" % esp.pretty_ip(esp.get_host_by_name("adafruit.com")) ) ``` Now we're getting to the really interesting part of the example program. We've written a library for web fetching web data, named [adafruit\_requests](https://github.com/adafruit/Adafruit_CircuitPython_Requests). It is a lot like the regular Python library named [requests](https://requests.readthedocs.io/en/latest/). This library allows you to send HTTP and HTTPS requests easily and provides helpful methods for parsing the response from the server. - Here is the part of the example program is fetching text data from a URL. ```python TEXT_URL = "http://wifitest.adafruit.com/testwifi/index.html" # Further up in the program # ... print("Fetching text from", TEXT_URL) r = requests.get(TEXT_URL) print('-' * 40) print(r.text) print('-' * 40) r.close() ``` - Finally, here the program is fetching some JSON data. The `adafruit_requests` library will parse the JSON into a Python dictionary whose structure is the same as the structure of the JSON. ```auto JSON_URL = "http://wifitest.adafruit.com/testwifi/sample.json" # Further up in the program # ... print("Fetching json from", JSON_URL) r = requests.get(JSON_URL) print('-' * 40) print(r.json()) print('-' * 40) r.close() ``` # Advanced Requests Usage Want to send custom HTTP headers, parse the response as raw bytes, or handle a response's http status code in your CircuitPython code? We've written an example to show advanced usage of the requests module below. To use with CircuitPython, you need to first install a few libraries, into the lib folder on your **CIRCUITPY** drive. Then you need to update **code.py** with the example script. Thankfully, we can do this in one go. In the example below, click the **Download Project Bundle** button below to download the necessary libraries and the **code.py** file in a zip file. Extract the contents of the zip file, open the directory **examples/** and then click on the directory that matches the version of CircuitPython you're using and copy the contents of that directory to your **CIRCUITPY** drive. https://github.com/adafruit/Adafruit_CircuitPython_Requests/blob/main/examples/esp32spi/requests_esp32spi_advanced.py Your **CIRCUITPY** drive should now look similar to the following image: ![CIRCUITPY](https://adafruit.github.io/Adafruit_CircuitPython_Bundle/requests_esp32spi_requests_esp32spi_advanced.py.png ) # WiFi Manager The way the examples above connect to WiFi works but it's a little finicky. Since WiFi is not necessarily so reliable, you may have disconnects and need to reconnect. For more advanced uses, we recommend using the `WiFiManager` class. It will wrap the connection/status/requests loop for you - reconnecting if WiFi drops, resetting the ESP32 if it gets into a bad state, etc. Here's a more advanced example that shows using the `WiFiManager` and also how to fetch the current time from a web source. https://github.com/adafruit/Adafruit_CircuitPython_ESP32SPI/blob/main/examples/esp32spi_localtime.py # Further Information For more information on the basics of doing networking in CircuitPython, see this guide: ### Networking in CircuitPython [Networking in CircuitPython](https://learn.adafruit.com/networking-in-circuitpython) # Adafruit AirLift FeatherWing - ESP32 WiFi Co-Processor ## CircuitPython BLE ## CircuitPython BLE UART Example It's easy to use Adafruit AirLift ESP32 co-processor boards for Bluetooth Low Energy (BLE) with CircuitPython. When you reset the ESP32, you can put it in WiFi mode (the default), or in BLE mode; you cannot use both modes simultaneously. Here's a simple example of using BLE to connect CircuitPython with the Bluefruit Connect app. Use CircuitPython 6.0.0 or later. **Note:** Don't confuse the **ESP32** with the **ESP32-S2** , which is a different module with a similar name. The ESP32-S2 does not support BLE. Warning: Currently, AirLift BLE support is not currently available on boards with Espressif chips. If the Espressif board provides `_bleio`, it is for native BLE support (e.g. ESP32-S3), not AirLift. Info: # Adafruit AirLift ESP32 FeatherWing Wiring If you have an  **Adafruit Airlift ESP32 FeatherWing** , you will need to solder three jumpers closed on the bottom side of the board to enable BLE. The rest of the ESP32 pins you need are already jumpered to certain Feather pins. ## Update the AirLift Firmware You will need to update the AirLift's firmware to at least version 1.7.1. **Previous versions of the AirLift firmware do not support BLE. ** Follow the instructions in the guide below, and come back to this page when you've upgraded the AirLift's firmware: [Upgrade External AirLift Firmware](https://learn.adafruit.com/upgrading-esp32-firmware) Warning: ## Install CircuitPython Libraries First make sure you are running the [latest version of Adafruit CircuitPython](https://learn.adafruit.com/welcome-to-circuitpython/installing-circuitpython) for your board. Next you'll need to install the necessary libraries to use the hardware. Thankfully, we can do this in one go. In the example below, click the **Download Project Bundle** button below to download the necessary libraries and the **code.py** file in a zip file. Extract the contents of the zip file, and copy the **entire lib folder** and the **code.py** file to your **CIRCUITPY** drive. Your **CIRCUITPY/lib** folder should contain the following folders and files: - **/adafruit\_airlift** - **/adafruit\_ble** - **/adafruit\_bus\_device** - **/adafruit\_esp32spi** - **adafruit\_requests.mpy** ![CIRCUITPY](https://adafruit.github.io/Adafruit_Learning_System_Guides/CircuitPython_Templates_airlift_ble_example.png ) ## Install the Adafruit Bluefruit LE Connect App The Adafruit Bluefruit LE Connect iOS and Android apps allow you to connect to BLE peripherals that provide a over-the-air "UART" service. Follow the instructions in the [Bluefruit LE Connect Guide](https://learn.adafruit.com/bluefruit-le-connect/) to download and install the app on your phone or tablet. ## BLE Example Warning: https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Templates/airlift_ble_example/code.py ## Talk to the AirLift via the Bluefruit LE Connect App Start the Bluefruit LE Connect App on your phone or tablet. You should see a CIRCUITPY device available to connect to. Tap the Connect button (1): ![](https://cdn-learn.adafruit.com/assets/assets/000/096/566/medium800/adafruit_products_airlift-connect.png?1603914360) You'll then see a list of Bluefruit Connect functions ("modules"). Choose the UART module (2): ![](https://cdn-learn.adafruit.com/assets/assets/000/096/567/medium800/adafruit_products_airlift-uart.png?1603914460) On the UART module page, you can type a string and press Send (3). You'll see that string entered, and then see it echoed back (echoing is in gray). ![](https://cdn-learn.adafruit.com/assets/assets/000/096/569/medium800/adafruit_products_airlift-echo.png?1603914605) # Adafruit AirLift FeatherWing - ESP32 WiFi Co-Processor ## Arduino WiFi You can use the AirLift with Arduino. Unlike CircuitPython, it work with just about any Arduino chip, even a classic Arduino UNO. However, if you want to use libraries like ArduinoJSON or add sensors and SD card, you'll really want an ATSAMD21 (Cortex M0) or ATSAMD51 (Cortex M4), both of which have _plenty_ or RAM. First, [make sure you've assembled your AirLift FeatherWing](https://learn.adafruit.com/adafruit-airlift-featherwing-esp32-wifi-co-processor-featherwing/assembly-2). ## **Arduino Microcontroller Pin Definitions** Because each Feather uses a different processor, you'll need to include the following pin definitions to your code depending on which board you are using: ### Feather M0, M4, 32u4, or NRF52840 ``` #define SPIWIFI SPI // The SPI port #define SPIWIFI_SS 13 // Chip select pin #define ESP32_RESETN 12 // Reset pin #define SPIWIFI_ACK 11 // a.k.a BUSY or READY pin #define ESP32_GPIO0 -1 ``` ### Feather 328P ``` #define SPIWIFI SPI // The SPI port #define SPIWIFI_SS 4 // Chip select pin #define ESP32_RESETN 3 // Reset pin #define SPIWIFI_ACK 2 // a.k.a BUSY or READY pin #define ESP32_GPIO0 -1 ``` ## Feather NRF52832 ``` #define SPIWIFI SPI // The SPI port #define SPIWIFI_SS 16 // Chip select pin #define ESP32_RESETN 15 // Reset pin #define SPIWIFI_ACK 7 // a.k.a BUSY or READY pin #define ESP32_GPIO0 -1 ``` ## Teensy ``` #define SPIWIFI SPI // The SPI port #define SPIWIFI_SS 5 // Chip select pin #define ESP32_RESETN 6 // Reset pin #define SPIWIFI_ACK 9 // a.k.a BUSY or READY pin #define ESP32_GPIO0 -1 ``` **Note:**  These pin definitions leave the the ESP32's **GPIO0** pin undefined (-1). If you wish to use this pin - **solder the pad on the bottom of the FeatherWing** and **set `#define ESP32_GPIO0`** to the correct pin for your microcontroller. **Note:**  These pin definitions leave the the ESP32's  **GPIO0**  pin undefined (-1). If you wish to use this pin -  **solder the pad on the bottom of the FeatherWing**  and  **set `#define ESP32_GPIO0`**  to the correct pin for your microcontroller. ![adafruit_products_4264_back_ORIG_2019_05.jpg](https://cdn-learn.adafruit.com/assets/assets/000/080/352/medium640/adafruit_products_4264_back_ORIG_2019_05.jpg?1567535317) # Library Install We're using a variant of the Arduino WiFiNINA library, which is amazing and written by the Arduino team! **The official WiFi101 library won't work because it doesn't support the ability to change the pins**. So! We made a fork that you can install. Click here to download the library: [Download Adafruit's version of WiFiNINA](https://github.com/adafruit/WiFiNINA/archive/master.zip) Within the Arduino IDE, select **Install library from ZIP...** ![adafruit_products_image.png](https://cdn-learn.adafruit.com/assets/assets/000/074/344/medium800/adafruit_products_image.png?1554927164) And select the zip you just downloaded. # First Test OK now you have it wired and library installed, time to test it out! Lets start by scanning the local networks. Load up the  **ScanNetworks**  example [![adafruit_products_image.png](https://cdn-learn.adafruit.com/assets/assets/000/074/345/medium800/adafruit_products_image.png?1554927615)](https://learn.adafruit.com/assets/74345) At the top you'll see a section where the GPIO pins are defined [![adafruit_products_image.png](https://cdn-learn.adafruit.com/assets/assets/000/074/351/medium800/adafruit_products_image.png?1554929035)](https://learn.adafruit.com/assets/74351) If you don't see this, you may have the wrong WiFiNINA library installed. Uninstall it and re-install the Adafruit one as above. Compile and upload to your board wired up to the AirLift [![adafruit_products_image.png](https://cdn-learn.adafruit.com/assets/assets/000/074/349/medium800/adafruit_products_image.png?1554928982)](https://learn.adafruit.com/assets/74349) If you don't even get the MAC address printed out, check your wiring. If you get the MAC address but cannot scan any networks, check your power supply. You need a solid 3-5VDC into  **Vin**  in order for the ESP32 not to brown out. # WiFi Connection Test Now that you have your wiring checked, time to connect to the Internet! Open up the  **WiFiWebClient ** example [![adafruit_products_image.png](https://cdn-learn.adafruit.com/assets/assets/000/074/355/medium800/adafruit_products_image.png?1554929528)](https://learn.adafruit.com/assets/74355) Open up the secondary tab,  **arduino\_secrets.h**. This is where you will store private data like the SSID/password to your network. [![adafruit_products_image.png](https://cdn-learn.adafruit.com/assets/assets/000/074/356/medium800/adafruit_products_image.png?1554929677)](https://learn.adafruit.com/assets/74356) You must change these string values before updating to your board! After you've set it correctly, upload and check the serial monitor. You should see the following. If not, go back, check wiring, power and your SSID/password [![adafruit_products_image.png](https://cdn-learn.adafruit.com/assets/assets/000/074/357/medium800/adafruit_products_image.png?1554929767)](https://learn.adafruit.com/assets/74357) # Secure Connection Example Many servers today do not allow non-SSL connectivity. Lucky for you the ESP32 has a great TLS/SSL stack so you can have that all taken care of for you. Here's an example of a secure WiFi connection: [![adafruit_products_image.png](https://cdn-learn.adafruit.com/assets/assets/000/074/359/medium800/adafruit_products_image.png?1554930586)](https://learn.adafruit.com/assets/74359) Note we use `WiFiSSLClient client;` instead of `WiFiClient client;` to require an SSL connection! [![adafruit_products_image.png](https://cdn-learn.adafruit.com/assets/assets/000/074/358/medium800/adafruit_products_image.png?1554930524)](https://learn.adafruit.com/assets/74358) ## JSON Parsing Demo This example is a little more advanced - many sites will have API's that give you JSON data. We'll use [ArduinoJSON](https://arduinojson.org/) to convert that to a format we can use and then display that data on the serial port (which can then be re-directed to a display of some sort) First up, [use the Library manager to install ArduinoJSON](https://arduinojson.org/v6/doc/installation/). Then load the example  **JSONdemo** [![adafruit_products_image.png](https://cdn-learn.adafruit.com/assets/assets/000/074/362/medium800/adafruit_products_image.png?1554932723)](https://learn.adafruit.com/assets/74362) By default it will connect to to the Twitter banner image API, parse the username and followers and display them. [![adafruit_products_image.png](https://cdn-learn.adafruit.com/assets/assets/000/074/361/medium800/adafruit_products_image.png?1554932631)](https://learn.adafruit.com/assets/74361) ## Adapting Other Examples Once you've got it connecting to the Internet you can check out the other examples.  # Adafruit AirLift FeatherWing - ESP32 WiFi Co-Processor ## Downloads ## Files - [ESP32 WROOM32 Datasheet](https://www.espressif.com/sites/default/files/documentation/esp32-wroom-32_datasheet_en.pdf) - [EagleCAD files on GitHub](https://github.com/adafruit/Adafruit-AirLift-FeatherWing-PCB) - [Fritzing object in Adafruit Fritzing Library - rev B](https://github.com/adafruit/Fritzing-Library/blob/master/parts/Adafruit%20AirLift%20FeatherWing.fzpz) - [Fritzing object in Adafruit Fritzing Library - rev C](https://github.com/adafruit/Fritzing-Library/blob/master/parts/Adafruit%20AirLift%20FeatherWing%20rev%20C.fzpz) - [3D Models on GitHub](https://github.com/adafruit/Adafruit_CAD_Parts/tree/master/4264%20AirLift%20FeatherWing) ## Schematic and Fab Print ### Rev C ![](https://cdn-learn.adafruit.com/assets/assets/000/141/896/medium800/adafruit_products_schem.png?1768487404 ) ![](https://cdn-learn.adafruit.com/assets/assets/000/141/897/medium800/adafruit_products_fab.png?1768487414 ) ### Rev B ![](https://cdn-learn.adafruit.com/assets/assets/000/076/198/medium800/adafruit_products_AirLift_FeatherWing_Sch.png?1559155254) ![](https://cdn-learn.adafruit.com/assets/assets/000/076/199/medium800/adafruit_products_AirLift_FeatherWing_Fab_Print.png?1559155264) ## Primary Products ### Adafruit AirLift FeatherWing – ESP32 WiFi Co-Processor [Adafruit AirLift FeatherWing – ESP32 WiFi Co-Processor](https://www.adafruit.com/product/4264) Give your Feather project a _lift_ with the Adafruit AirLift FeatherWing - a FeatherWing that lets you use the powerful ESP32 as a WiFi co-processor. You probably have your favorite Feather ([like the Feather M4](https://www.adafruit.com/product/3857)) that comes with its own... In Stock [Buy Now](https://www.adafruit.com/product/4264) [Related Guides to the Product](https://learn.adafruit.com/products/4264/guides) ## Related Guides - [Air Quality Sensor 3D Printed Enclosure](https://learn.adafruit.com/air-quality-sensor-silo-house.md) - [IoT Air Quality Sensor with Adafruit IO](https://learn.adafruit.com/diy-air-quality-monitor.md) - [Adafruit IO Basics: Schedule Actions](https://learn.adafruit.com/adafruit-io-basics-scheduled-triggers.md) - [Quickstart - Raspberry Pi RP2040 with BLE and CircuitPython](https://learn.adafruit.com/quickstart-raspberry-pi-rp2040-with-ble-and-circuitpython.md) - [Upgrading AirLift ESP32 Firmware](https://learn.adafruit.com/upgrading-esp32-firmware.md) - [Discord and Slack Connected Smart Plant with Adafruit IO Actions](https://learn.adafruit.com/discord-and-slack-connected-smart-plant-with-adafruit-io-triggers.md) - [Networking in CircuitPython](https://learn.adafruit.com/networking-in-circuitpython.md) - [MQTT in CircuitPython](https://learn.adafruit.com/mqtt-in-circuitpython.md) - [Raspberry Pi Care and Troubleshooting](https://learn.adafruit.com/raspberry-pi-care-and-troubleshooting.md) - [Quick-Start the Pico W WiFi with CircuitPython](https://learn.adafruit.com/pico-w-wifi-with-circuitpython.md) - [Adafruit MENTA Kit](https://learn.adafruit.com/adafruit-menta-kit-mint-tin-arduino-compatible.md) - [Adafruit MIDI FeatherWing](https://learn.adafruit.com/adafruit-midi-featherwing.md) - [Adafruit MCP9601 I2C Thermocouple Amplifier](https://learn.adafruit.com/adafruit-mcp9601.md) - [7 Segment Display Internet Clock](https://learn.adafruit.com/7-segment-display-internet-clock.md) - [Adafruit Hallowing M0](https://learn.adafruit.com/adafruit-hallowing.md)