Variation: Operating Fluid

The choice of operating fluid largely depends on your application. Water and air each have their own advantages and disadvantages as an operating fluid. For example, a pneumatic system can draw air from the environment (so the system doesn't need a reservoir) and any leaks that occur will cause a mess. However, air is a compressible fluid and this can mean that it takes more energy for the pump to compress the air to reach the desired pressure. Furthermore, for some medical applications, particularly when an actuator will interact with blood, using air presents serious safety concerns.

The opposite is true for hydraulic systems: they require a reservoir and leaks will result in water spillage which may cause problems, but the system may be more energy efficient and water may be a safer choice for some applications.

As mentioned on the previous page, here we describe a pneumatic control board but it is relatively straightforward to use these instructions to build a hydraulic board.  The main difference to consider is the selection of components. The following items on the Bill of Materials should be changed if you want to build a hydraulic control board (in most cases the vendors offer hydraulic versions of these parts):

• Pump
• Regulator
• Valves
• Pressure sensors
• Flow sensor
• In addition, a water reservoir will need to be added.

All other parts of the control board should stay the same, and the general fabrication and operation instructions provided here should apply.

Variation: Alternative Components

Most of the components on the board (and the particular models and brands of each component) can be replaced with alternatives based on cost, availability, and performance. We have found parts and suppliers specified here to be easy to obtain in the United States, but there may be better local options in other parts of the world. The part specification we provide can be useful in finding alternative components. We strongly advise you to get in touch with vendors directly to discuss your particular needs; most vendors can provide design expertise in their area and this can save you a lot of time and money.

Here we discuss some particular alternatives, but this list is by no means exhaustive:

• The relays can be replaced with MOSFETs such as these, or motor drivers such as these. One advantage of these alternatives is that they allow pulse width modulation (PWM) of the pressure in the system (see section on pressure regulation below). Version 2 of the control board (under construction) uses MOSFETs instead of relays.
• There is a massive variety of solenoid valves available. Some of these are designed for use with specific manifolds so before you buy any be sure to check if they are only compatible with certain setups. On that note, the use of a manifold can help to keep the board compact and well-organized, by eliminating the need for multiple branchhes of tubing. Version 2 of the control board uses a new set of solenoid valves and an associated manifold.
• When selecting a pump, the important parameters to consider are power consumption, weight and volume, operating pressure, and flow rate. These will depend on the types of applications you are interested in. For example, we have chosen a pump that is small and light and has relatively low power consumption (compared to less expensive pumps). We chose this pump so that the board could be modified for portable applications. If, however, you plan to always use the board as a static bench-based platform then the weight, size, and power consumption will be less of an issue and you can probably find a cheaper pump that will suit your needs. For the fluidic actuators described on this site we have found that an operating pressure of 30 psi and flow rate of about 1 SLPM is sufficient. Again, these values depend on your applications.

Variation: Pressure Regulation

As mentioned above, if using MOSFETs or motor drivers to control the switching of the solenoid valves, it is possible to use pulse width modulation (PWM) to control the pressure of the fluid passing through these valves. During PWM, a high-frequency pulses are sent to the solenoid valves, opening and closing them rapidly. By varying the length of these pulses, the amount of time the valve is open or closed is adjusted, and therefore the output pressure is adjusted.

This eliminates the need for the pressure regulator, which is the most expensive part of the control board. Using PWM also has the advantage that each valve is individually addressable; using a single regulator allows us to vary the pressure of the whole system, but if we want different pressure in different parts of the system (e.g. different pressures for different actuators) we need a way to control the pressure at each valve. For these reasons, the forthcoming Control Board Version 2 will use MOSFETs to replace the relays and pressure regulator.

The drawback of using PWM on the control board is that it is less straightforward to set up. For beginners with relatively little electronics and programming experience, using the regulator is probably an easier place to start.

Variation: Sensors

Sensors can easily be added to or removed from the board without affecting its performance. The choice of sensors again depends on what types of applications you are interested in.

• The flow sensor can probably be omitted as in our experience that has been the least-used part of the board (and future versions will not include it).
• For that matter, if you wish you could build a control board with no sensors at all.
• The breadboard allows easy interfacing of additional sensors. For example, a previous project team added a gyroscope to track the motion of their fiber-reinforced actuator. Other users have embedded flex sensors in their actuators to track bend angle.

Major Components

Miniature Diaphragm Pneumatic Pump Vendor link Data sheet Principle of operation (video)	Miniature Electronic Pressure Regulator Vendor link Data sheet // detailed manual
Miniature Pneumatic Solenoid Valve (x4) Vendor link Data sheet	One-Way Pneumatic Air Flow Control Valve* Vendor Link
Pressure Sensor Vendor link Data sheet Operation: pressure causes diaphragm to deflect, and deflection is measured by piezoresistor	Flow Sensor* Vendor link Data sheet Principle of operation: small element heats air, and adjacent temperature sensors detect transfer of heat caused by air motion
4-channel 5V Relay Module for Arduino Vendor link	Arduino UNO Vendor link Setup instructions: Windows, Mac

*Optional: can be omitted.

Base

These parts simply hold the above components in place. Use a laser cutter (make sure you are trained first!) to cut these pieces out of acrylic sheets. We use 3mm acrylic for all parts except the base board (6mm acrylic). Cut 2 copies of the base board. Download the .dxf files for cutting here.

Pump on/off switch	Solenoid valves
Arduino	Relays, power plugs, and toggle switches
Pressure sensors	Base board (12"x12" / 300mmx300mm)

Mounting

At each corner of the baseboard, install a standoff using a single screw with a plain washer. This elevates the board to make room for the wires/connections underneath.

Solder any necessary wires to all the electronic components (follow the data sheets and the below wiring diagram). Using heat shrink tubing may also be a good idea to prevent shorts. Next, mount all the of the components onto the baseboard, following the image below. Use zip ties, screws, washers, nuts and spacers wherever needed. Connect the air flow between components using appropriate tubing.

Wiring

Now that all the components are in place, they need to be connected to each other, following the wiring diagram below. A good place to start is by connecting all the components to power. Use red and black wires to represent voltage supply and common (ground), respectively. It may be helpful to use a bus to manage the various power wires.

When connecting signal wires, be careful not to mix up the Arduino's digital and analog pins (analog pins are prefaced by 'A'). Use the breadboard as an intermediate between the components and the Arduino to help keep all the wires organized.

Before connecting the control board to power, make sure there are no short-circuits. If the board doesn't work properly at first, use a multi-meter to diagnose the problem and double-check your wiring. After connecting all the power plugs, make sure none of the components are getting too hot!

Note: The pressure regulator takes a control signal going up to 10V, however, the Arduino will only output up to 5V. If you need regulation at higher pressures, use an operational amplifier on the breadboard to modify the control signal accordingly.

Note: Always check the maximum air supply you provide to the system. Every component has its own specifications and can withstand different maximum pressures.

Basic manual control

1. Power the board by plugging in the power adapters. Be careful not to mix up the cords, as incorrect supply voltages will cause some components to burn out.
2. Flip the switch to turn on the air pump.
3. Try closing the manual flow valve. You should see the pressure reading on the regulator increase from 0 psi.
4. Turn the potentiometer dial to control the regulator pressure. The reading on the regulator should change accordingly.
5. Re-open the manual flow valve, and flip the switch(es) to open the solenoid valves, making sure that the corresponding relays are on as well. The behavior may be a little counter-intuitive since these solenoid valves are the "normally closed" model, which only open when they are powered. If you have the valves correctly open, you should be able to feel air coming out of the control board's output hose.
6. Connect an actuator and turn the potentiometer dial to control how much pressure it receives. Try making it go through its entire range of motion.

Basic Arduino control

If you haven't done so already, set up your Arduino Uno microcontroller using the official setup guide: Windows / Mac

If you were able to get the guide's Blink example to work, you're ready to write and upload your own custom code to control the board hardware. Those already familiar with Arduino programming can use and customize this sample code for monitoring the sensors and controlling the valves. Otherwise, read the brief tutorial below about basic Arduino coding.

First, we define some variables to assign and help keep track of what the various pins are connected to. By using these variables, we don't have to update numbers throughout the code every time we change the wiring. The flow sensor and potentiometer output analog voltages, so we connect them to the analog input pins A0 and A3, as seen in the wiring diagram in the assembly instructions.

The valve (via the relays) and the pressure regulator are controlled by output signals from the Arduino. The analog pins are input only, so we need to use the digital pins. There are 14 numbered digital pins on the Arduino Uno. Pins 0 and 1 cannot be used because we are also using serial communications, so we use Pin 2 for the valve.

For the regulator, we need a continuous control signal, unlike the valve which only requires a binary on/off signal. The Arduino has 6 pins capable of pulse-width modulation (PWM), which are marked by a ~ next to the pin number. We use one of these pins, Pin 9, to control the regulator.

We also create the variables flowReading and potValue to store the values that the Arduino reads from the flow sensor and potentiometer.

1 2 3 4 5 6 7

int flowPin = A0; int potPin = A1; int regPin = 9; int valvePin = 2; float flowReading = 0; float potValue = 0;

Next is the setup() function, which is required for all Arduino programs. The setup function will only run once after a sketch starts, following each powerup or reset of the Arduino. Here, we initialize serial communications at 9600 bits per second (baud) between the microcontroller and the computer. We also set the digital pins connected to the valve and regulator to behave as output pins.

1 2 3 4 5 6 7 8 9

void setup() { Serial.begin(9600); pinMode(valvePin, OUTPUT); pinMode(regPin, OUTPUT); }

Next is the loop() function, which is also required for all Arduino programs. However, unlike setup(), this function repeats continuously, with the speed at which it repeats determined by the delay() function. This function essentially pauses the program for X milliseconds before continuing.  In line 15 below, we have delay(1000), so the loop will repeat every 1 second.

Most of the functionality of the program is contained in this loop. For example, we can open the valve using the code in line 4: by using the digitalWrite() function to set the digital pin that controls the valve (via the relays) to HIGH, we turn on the valve. If we want to turn off the valve instead, we would use digitalWrite(valvePin, LOW).

The code for controlling the regulator via the potentiometer is also inside this loop. First, we read the analog value from the potentiometer with analogRead(), then use analogWrite() to set the output pin for the regulator to the appropriate control value. Since analogRead() values go from 0 to 1023, while analogWrite() values go from 0 to 255, we need to divide the potentiometer reading (potValue) by 4 before using it to set the regulator control signal.

Finally, we can also read and display sensor values here. Again, we use analogRead() to get a value from the flow sensor analog input pin, then scale this raw value to a reading in SLPM units using the calibration formula provided by the sensor manufacturer (read the datasheet for more details). Once we have this value, we use Serial.print() to send this information to the computer, where it is displayed in the Serial Monitor.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

void loop() { digitalWrite(valvePin, HIGH); potValue = analogRead(potPin); analogWrite(regPin, potValue/4); flowReading = analogRead(flowPin); flowReading = ((flowReading*0.0049)-1.25)/0.75; Serial.print("\n Flow = " ); Serial.print(flowReading); Serial.print(" SLPM " ); delay(1000); }

Turn on the control board and pump. Set the regulator so that you can feel air coming out of the board's output. In the Arduino Programming Platform, compile your code and upload it to the microcontroller. Open the Serial Monitor so you can view the flow sensor values. The values should update every second, since we set the loop delay to 1000ms. If you want more frequent updates, reduce the delay time and recompile+reupload the code. Try turning the manual flow valve and see the values change.

More Arduino control

Once you are comfortable with this code, you should be able to understand the sample code provided above, which gets readings from all the sensors and controls all 4 valves. You can add more complex functions and behaviors as well. For example, using digitalWrite(valvePin,!digitalRead(valvePin)) instead of digitalWrite(valvePin,HIGH) will toggle the valve state on each loop so that you can get alternating actuation. Basic feedback control can be achieved by utilizing conditional statements with the sensor values.

The examples and reference pages on the Arduino website are a good resource for discovering more things you can do with your code.

Advanced Control with the Arduino IDE

One of the advantages of using the Arduino microcontroller is the massive amount of support documentation and useful code libraries that are available. If there is a particular control architecture you wish to implement, there is a good chance that someone has published related Arduino code online. For example, see this guide to PID control using the Arduino, and this PID Arduino library.

Advanced Control with LabVIEW

LabVIEW is a development environment from National Instruments that uses a graphical programming language. Software code is created by dragging and dropping functional blocks and creating connections between these blocks. The following "virtual instrument", used in testing the performance of a PneuNets Bending Actuator, was created in LabVIEW.

The LabVIEW Interface For Arduino Toolkit can be used to create Arduino sketches in the LabVIEW environment.

Advanced Control with Simulink

Simulink from Mathworks is also a graphical programming language in which code is created by manipulating functional blocks in the development environment. One of the advantages of environments like LabVIEW and Simulink is that a designer can make use of provided robust algorithms, without having to make their controllers from scratch. The following block diagram was made in Simulink and used to implement closed-loop control of a PneuNets Bending Actuator.

The Arduino Support package for MATLAB allows you to develop software/algorithms using Simulink’s graphical programming language and download this algorithm to an Arduino device. The package has a built-in compiler that converts the block diagram into code that can be embedded and run remotely on the Arduino. This page contains details on how to set up and use the support package.