Interactive Display for Finding Wheelchair-Accessible Places

Overview

This project demonstrates how to build an interactive display that helps mobility-impaired people discover wheelchair-accessible places nearby.

The display dynamically builds a map highlighting the locations of accessible places and allows users to explore their details with touch interactions.

People requiring wheelchair accommodations can utilize a future full-scale version of this display to discover venues and establishments that meet their mobility needs when traveling to new places.

Build2gether Challenge

The inspiration for this project comes from the Build2gether Inclusive Innovation Challenge, which calls for participants to build "innovative solutions to help individuals with disabilities overcome their daily struggles".

One of the three solution themes outlined in the challenge is traveling for people with mobility impairments, which aims to assist this community in navigating and traversing the world around them.

To help gain insight into the struggles faced during travel, the challenge organized discussions with Contest Masters, a group of individuals who experience daily mobility issues.

Through conversations with the Contest Masters on Discord, I learned how their disabilities affect their access to public places, and used this knowledge to build a hardware solution designed to address this problem.

Problem Identification

The Contest Masters shared how their own conditions, such as Becker muscular dystrophy and spinal cord injury, introduce unique needs and require additional accommodations in order to travel.

What were the needs or pain points that you attended to and identified when you were solving problems faced by the Contest Masters?

In discussing their personal experiences with travel, the Contest Masters highlighted a significant pain point they are often confronted with:

Discovering public places that provide wheelchair-accessibility options is often difficult when traveling to a new area.

Wheelchair-accessibility options, including entrances, seating, and restrooms, are often not provided in many establishments, preventing individuals with mobility issues from navigating and enjoying these spaces.

The task of finding restaurants, shops, and other venues that are accessible is a recurring issue for wheelchair-bound travelers exploring new places.

Developing a Solution

To address this discoverability problem, I developed an idea for a public interactive display that highlights nearby wheelchair-accessible places.

This display could be installed in any pedestrian area and would showcase a map of accessible places in close proximity to it. Users could touch map points to access further details, including the place name, address, and a list of wheelchair accommodations.

When visiting a new place, disabled travelers can consult the display to easily answer their key questions - what places are accessible? What facilities do they have? And where are they located?

For the scope of this challenge, I built a miniaturized proof-of-concept of this interactive display. This prototype includes all the features of a full-scale version, thereby demonstrating the technical viability of the idea.

Key features of this display include:

1. WiFi Connectivity: The display can connect to the internet in order to automatically retrieve up-to-date maps and place data.

2. Custom Map Location: The map's center point can be configured to any location in order to discover accessible places nearby.

3. Accessibility Details: Wheelchair-accessible parking, entrances, restrooms, and seating availability are viewable for each place.

This combination of features works together to form an innovative hardware solution that helps ease the burden of finding wheelchair-accessible places.

Using the Display

The display prototype can be placed on any desktop or surface to easily view and interact with the information it presents.

Once the display is powered on, it first shows a splash screen as it connects to WiFi, downloads a map image, and searches for accessibility data.

When these processing steps are complete, a custom map of wheelchair-accessible places is then shown on its screen.

The center location and extent of the map are determined by a center point and search radius values, which can be configured in the device's software.

For example, the above map is centered on Charlottesville VA's city center and visualizes accessible places found within 100-meter radius of that point.

When installed in a public area, the full-scale version of this display would use the installation location as the center point, and show the places found within a defined distance around it.

Each handicapped symbol plotted on the map indicates the location of a place that includes one or more wheelchair-accessible amenities, and the yellow circle indicates the center of the map.

Places can include restaurants, shops, theaters, museums, banks, libraries, or any other type of establishment that is open to the public.

Touching any of the map icons will update the display to show additional details about that place.

The name of the selected place is shown across the top of the details menu, followed by its street address and distance from the center of the map.

For the full-scale version of the display, this distance value would indicate how far the user would have to traverse to get from the installed display to the selected place, which is helpful to know when traveling by wheelchair.

Each of the wheelchair-accessible accommodations provided by the place is listed prominently with a custom icon, name, and check mark. Possible accommodations include a restroom, entrance, seating, and parking.

Touching anywhere on the details screen reverts the display back to the map.

The display enables users to explore nearby places of interest to find a place that meets their accessibility needs.

Simply looking at the map gives users an overall picture of the number of accessible places close by. From there, they can read through the details of multiple places to confirm they have the wheelchair accommodations they require and are within a close enough traveling distance.

How it Works

The display prototype utilizes an Adafruit PyPortal board, which includes WiFi connectivity, a 3.2" color display and touchscreen, onboard storage, and the ability to run Python scripts.

A 3D-printed case and stand enclose the PyPortal and hold it upright. The fully assembled device can be positioned on any desktop or flat surface for use.

When the device is powered on via USB cable, a Python script loaded on the PyPortal automatically begins to execute. This script is responsible for collecting map data, controlling the display output, and handling touch inputs.

A center location coordinate (latitude/longitude) and search radius (km) values are defined within the script. These values determine the location and geographical extent of the wheelchair-accessible places to be displayed and can be configured by the user.

Below are the script's default location and radius values, defining a location in Charlottesville, VA with a search radius of 0.1 kilometers.

# Map center
center_lat = 38.0306
center_lon = -78.4807

# Search radius (km)
radius_km = 0.1

A splash image is displayed to inform the user of the script's progress as it works through its initial steps to prepare the map content.

First, the PyPortal connects to the local WiFi network whose SSID and Password information have been set in the device's configuration file.

Then, the script works to download a map that will used as the base layer of the wheelchair-accessibility visualization.

Geoapify is an online service that enables users to generate custom map images via an API URL using parameters to control the dimensions, style, position, and geographic bounds of the map.

The script builds a Geoapify API URL for a map image that is centered on the user-defined center location and encompasses the defined place search radius around that point. The dimensions and aspect ratio of the map are set to match the layout of the PyPortal screen.

In order for the map image to be displayed on the PyPortal, it must first be converted to BMP format.

To accomplish this, the script makes a request to the Adafruit I/O image conversion service, passing in the Geoapify map URL. This converts the map image into BMP format, which is then downloaded to the PyPortal filesystem.

Next, the script works to collect information about wheelchair-accessible establishments located within the defined search area.

Google Places API is an online service that enables searching of Google's expansive index of real-world places using custom parameters and data filters.

The script makes a request to the API for all places located within the defined search radius extending from the center point, and also contain at least one wheelchair-accessible option.

Results from the API request are JSON formatted and contain name, address, location, and accessibility data for each place that fits the search criteria. Below is an example of the data returned for a specific place.

{
    "formattedAddress": "212 E Main St, Charlottesville, VA 22902, USA",
    "location": {
        "latitude": 38.030190800000007,
        "longitude": -78.4804429
    },
    "displayName": {
        "text": "Citizen Burger Bar",
        "languageCode": "en"
    },
    "accessibilityOptions": {
        "wheelchairAccessibleParking": true,
        "wheelchairAccessibleEntrance": true,
        "wheelchairAccessibleRestroom": true,
        "wheelchairAccessibleSeating": true
    }
}

The distance between the center point and each place is calculated from their latitude and longitude values. This distance value is then stored within the place data as a new distance field.

Finally, the script completes the map visualization by overlaying handicap sign icons on the map to indicate the location of each place, as well as a center point map marker.

Latitude and longitude values for each place are used to calculate corresponding X and Y pixel coordinates that correctly position the icons on the map image. Similarly, the pixel coordinates of the center point are calculated and a yellow circle is added to the map at that position.

The splash screen is removed from the display and replaced with the combined map visualization.

From here, the script enters a continuous loop where it checks for and processes touch events from the user.

Touches events include X and Y coordinates of the screen position where the touch occurred. When the touch coordinates fall within the bounds of a map icon, the display will update to show a details page for the selected place.

This page is built by dynamically positioning text and image elements that highlight the place's name, address, distance to the center point, and wheelchair-accessible accommodation.

When the touch coordinates fall anywhere on the details page, the display will update to show the map visualization.

Build Instructions

Below are instructions on how to build and configure the interactive display for finding wheelchair-accessible places. These instructions assume working knowledge of the Adafruit PyPortal and CircuitPython.

Download Project Files

The complete set of project files, including Python code, libraries, images, and 3D model files, required to build the project are contained within a public GitHub repository.

1. Browse to the project's GitHub repository page, then click "Code", then "Download ZIP".

This downloads a ZIP file pyportal-accessibility-map-main.zip, containing the contents of the repository's main branch.

2. Unzip the downloaded ZIP file as a pyportal-accessibility-map-main directory to access the project files.

Hardware Setup

Begin the build by first assembling the display from its 3D printed parts and Adafruit PyPortal board.

1. 3D print the display's case and stand.

The three model files (.stl) to print are found in the 3D_models directory within the project files, as well as the attachment section of this project.

PLA plastic was used as the print material for the parts showcased in this tutorial, but other materials can work just as well.

2. Attach the case back plate to the stand, then enclose the PyPortal between the back and front plates of the case.

Line up the mounting holes on the case back plate with the holes in the stand, and attach them using four M2.5x5 screws. Ensure that the USB case hole is facing the bottom of the stand.

The PyPortal press-fits within the case front plate, which then press-fits onto the back plate to complete the assembly.

3. Connect the display to the computer via USB cable.

The USB connection serves to power the board and open a data link to interact with the PyPortal's file system.

Load Project Files

Project code, images, and configuration files must be copied onto the PyPortal for it to create and display the wheelchair-accessibility visualization.

When connected to the computer over USB, the PyPortal's filesystem can be accessed through the available CIRCUITPYTHON drive on the computer.

1. Copy over the following items from the pyportal-accessibility-map-main directory into the CIRCUITPYTHON drive.

• code.py: This Python script gets automatically executed when the PyPortal is powered on, and is responsible for collecting map data, displaying the visualization, and handling user touch events.
• secrets.py: User-specific account API keys and wifi configurations are stored in this file, which are utilized by the main Python script.
• boot.py: This file configures the PyPortal's filesystem as writable when the PyPortal boots up, allowing files to be dynamically saved to it.
• fonts: Text fonts used in the visualization are stored in this directory.
• img: Image files, such as map and details icons used in the visualization, are stored in this directory.
• lib: This directory stores Python libraries that enable complex functionality such as interacting with the display, connecting to WiFi, and capturing touch-screen inputs.

2. Reset the PyPortal by powering it off and on again.

This reset is required for the boot.py to automatically run and properly configure the PyPortal as writeable.

Configure User Settings

In order for the code.py script to download the visualization's map image and search for place data, it needs to connect to the internet and make requests to multiple online services.

Access to these services is controlled by user-specific API keys, which are passed along with each request to authenticate the user making the request.

Update the secrets.py file with valid WiFi network configuration settings and API keys**

1. In a text editor, open secrets.py from the CIRCUITPYTHON drive.

2. Update the ssid and password values with the settings of a WiFi network the PyPortal can access.

3. Follow this tutorial to create a Geoapify account and create a new project. Update the geoapify_api_key value with the project's API key.

4. Follow this tutorial to create an Adafruit/IO account. Update the adafruit_io_username and adafruit_io_key values with the account's username and API key.

5. Follow this tutorial to create a Google Cloud account and create a new project with the Places API added. Update the google_api_key value with the project's API key.

With these user-specific values updated, the script will be able to connect to the internet and reach out the the Geoapify, Adafruit/IO, and Google Cloud services it needs to obtain images and data for the visualization.