Blue Team – Prototype II Final Report: Smart Cushion


The Smart Cushion was conceived specifically to reduce instances of pressure sores in wheelchair-bound individuals. Pressure sores are caused by a force (such as a person’s body weight) being applied consistently to an area of soft tissue, thereby obstructing blood flow and causing tissue failure. Because a great many wheelchair users have limited mobility, as well as limited sensation, it can be difficult for them to change position with sufficient frequency.

 To combat the difficulty many wheelchair users have in staving off pressure sores resulting from long periods of sustained sitting, the Smart Cushion will comprise air cell quadrants that will respond to variations in the user’s positioning by equalizing pressure across the contact area. Each cell will be equipped with a small pressure sensor, which in turn will be monitored by an Arduino microcontroller to ensure that each cell’s pressure stays in the target range. Small compressor motors will handle inflation duties.

 For the second prototype, we were able to (somewhat crudely) implement nearly our entire overarching design. In other words, there are few planned features for the Smart Cushion that this prototype does not implement in some fashion. Notably, we intend to later implement solenoid valves for each cell in order to deflate when necessary. However, unlike the first prototype, this iteration demonstrates in a truly meaningful way how the final product will operate.

 The most obvious difference, from a visual standpoint, between the first and second implementations of the Smart Cushion is the presence of an actual seat cushion, rather than a pair of inflatable camping pillows. Even more importantly, the second prototype actually inflates automatically, rather than manually. This is achieved by connecting each cell to a powered lumbar seat pump. As before, each cell gets a 14.5 psi pressure sensor for monitoring purposes. Once again, the heart of the system is the Arduino Uno, which polls the pressure sensors and sends instructions to the pumps, accordingly. Further refinement has been made with respect to the laptop display interface, as well. Rather than displaying numerical values for each pressure sensor, a colored grid displays pressure variation for each quadrant.

 Parts List

  1. Seat Cushion, ROHO Quadtro Select, used (1)
  2. Microcontroller, Arduino Uno (1)
  3. Power lumbar seat pump, Ford OEM (4)
  4. Pressure sensor, Freescale Semiconductor MPXV5100GC7U (4)
  5. MOSFET (8)
  6. Diode (8)
  7. Resistor, 10kΩ (8)
  8. ON/OFF switch (1)
  9. 12V power supply (1)
  10. Female wiring adapter for 12V power supply (1)
  11. Vinyl tubing, 3/16″ id, 5/16” od (8ft)
  12. All-purpose plastic cement
  13. Circuit board (2)
  14. Connecting wire (20ft)


1. The first step in constructing the second prototype of the Smart Cushion involves irreversibly altering the ROHO seat cushion. At the front of the ROHO, there is a four-inlet manifold. Each inlet is connected to one of the four quadrants of the cushion. The manifold has a sliding switch. When closed, each of the quadrants is isolated from the others. When open, air is allowed to flow between quadrants. For our application, we needed access to each individual chamber, so we removed the manifold. At first, we tried drilling out the rivets and carefully extricating the manifold from the seat cushion rubber. The glue on the manifold housing began tearing at the rubber, however, so we just cut the manifold off with a razor knife.

 2. Small, tube-like chambers are molded into the rubber of the cushion. These chambers meet at the front of the cushion where the manifold was removed. It is here that we connected the vinyl tubing to the cushion, using all-purpose plastic cement. The 5/16” outside diameter was small enough to fit snuggly in the pre-molded chambers of the ROHO, and a generous slathering of plastic cement ensured an air-tight seal.

 3. We chose to mount the cushion to the top of a 4” deep wooden box, with length and width dimensions closely matching those of the ROHO. Since the implementation of the Smart Cushion described here is independent of mounting choice, we will forego a detailed explanation of the box construction. Suffice it to say, it is a box with a hinged lid, inside of which the electrical components are secured.

 4. Two circuit boards were used for soldering components. Onto the first, we soldered the MOSFETS, diodes, and resistors. Onto the second, we soldered the pressure sensors. The choice to use two circuit boards was based on our particular display setup; one board would be perfectly fine. The motor driver board diagram can be found below. The sensor board was used as shown in the datasheet for the sensors, simply the Vin of the sensors connected to 5V, Gnd connected to the common ground of the system, and Vout connected to the appropriate analog in ports on the Arduino. As such there is no dedicated circuit diagram for this board.

 5. 1/16” holes were drilled into the vinyl tubing for insertion of the pressure sensor inlets. We chose to forego the use of plastic cement due to the fact that we will need to reuse the sensors in further iterations of the project. Because of the snug fit, however, there is little air loss at the sensor inlet insertion points.

 6. The four pumps should be wired to four MOSFETs on the board. Slide the ends of the tubing onto the pump outlets. The other four MOSFETs will be used in a later prototype for connecting solenoid valves.

 7. Our particular 12V power supply required a female adapter for wiring purposes. Other applications may differ. Wire the 12V supply to the ON/OFF switch. Then wire the switch to the board with all the MOSFETS. Make final connections between the two circuit boards and the Arduino Uno. 

 8. The latest code for the microcontroller at time of writing can be found in our dropbox folder under “Arduino_pump_control1/_2atAtime”. In this iteration only 2 pumps run at any given time (using a time sharing system) to fit the limitations of the current power supply. The latest iteration of the pressure display program can be found in “Processing_serial_pressure_graph”







As with Prototype I, things turned out well with our second prototype. We were somewhat less successful with time management, largely due to unforeseen parts/equipment issues. The first batch of pumps we ordered (some cheap little jobs used in blood pressure cuffs) did not have near the output we required. As a result, we had to scramble to find replacements, and not much work got done in the interim. This bump in the road forced us to make up a lot of work nearer the project deadline. Nevertheless, the whole team was committed to putting in the required hours, and it all got done as planned. 

In retrospect, there is one thing we could have done to alleviate some of the time crunch caused by the pump fiasco. We should have gone ahead and soldered all the sensors and MOSFETs to circuit boards while we were waiting on the second batch of pumps to be delivered. This ended up being a fairly time consuming endeavor at a late juncture in the project’s development. There was really no reason to wait; we knew how they were going to be wired. For whatever reason, this didn’t occur to us and we basically did next to nothing for that particular week. 

We were also a bit late to the party with respect to getting our solenoid valves ordered. We were so preoccupied with the pumps that we really didn’t even look into valve options until less than two weeks out from the deadline. As a result, we were unable to get them implemented, with a failed effort to get them operational the night before the presentation. 

From a conceptual standpoint, we believe we are on the right track in our efforts to tackle the pressure sore problem. We feel that it’s simply a matter of refining our implementation. For example, while this iteration uses four pumps, we expect that our next prototype will use one pump connected to a manifold. In general, we’re looking forward to making things more compact. As it stands now, the Smart Cushion is heavy, bulky, and unusable in any real-world capacity. Further refinement will make it more direct and concise.

We also have a great deal of work to do from a testing standpoint. While the logic of our code works, we still have no real idea as to an appropriate target pressure range. We’ve borrowed an old pressure map from Greg at CPRF, and plan to use it as a reference point in the future. We also plan to tidy up our own pressure mapping software.