Building a Pneumatic Test Fixture with Arduino Mega2560: Parts, Wiring, and Pitfalls
🌏 繁體中文版：Arduino Mega2560 測試治具學習
This post documents a pneumatic test fixture built around an Arduino Mega2560: a platform that slides in and out, a press that moves up and down, a buzzer, and a cycle counter — with manual buttons and automatic sequencing working side by side.
What the fixture does
- Two buttons move the platform in and out; a third button moves the press up and down.
- After the full sequence completes, pressing either in/out button retracts the platform, and the buzzer sounds on exit.
- Each time the platform reaches the "in" position, the counter increments, tracking how many times the press pins have been applied.
- Manual control and programmed control can run at the same time.
Architecture
The parts, and how to use them well
Below are the fixture's eight core parts, with the ways each can be used, the wiring essentials, and the traps that catch people when building test fixtures.
1. Arduino Mega2560
Basic use: the brain of the platform — reads the buttons, drives the relays, and controls the buzzer and counter. Power it from 5 V over USB, or from 12 V DC through Vin (the onboard regulator gets hot with heavy loads, so don't hang power-hungry devices off its 5 V pin).
Other ways to use it: (1) it has four hardware UARTs (Serial–Serial3), so one can go to a PC for monitoring while another talks to a PLC or a driver board; (2) with FreeRTOS (the Arduino_FreeRTOS library, which this fixture uses), manual buttons and the automatic sequence run as separate tasks without blocking each other; (3) there are enough digital pins for 8 relays + 3 buttons + buzzer with plenty left for sensors.
Traps: use the internal pull-ups on button inputs (INPUT_PULLUP, with the button wired to ground) so the inputs don't float. And an I/O pin can only supply about 20 mA (40 mA absolute maximum) — never drive a relay coil, solenoid, or anything inductive directly from a pin.
2. 8-channel relay board
Basic use: switches higher-power circuits from Arduino logic signals. Here it switches the three pneumatic valves and the buzzer. Typical wiring: module VCC and GND to a 5 V supply, and each IN pin to an Arduino output.
Other ways to use it: (1) split the 8 channels into function groups, e.g. 4 for pneumatics and 4 for motors/power; (2) feed a spare relay contact back to an Arduino input to confirm the action really happened (cylinder in position, valve actually switched); (3) choose an optocoupler-isolated relay board to survive electrical noise and surges on a shop floor.
Traps: a typical 5 V relay coil draws roughly 70–90 mA, so all eight on at once is around 0.6–0.7 A — too much for the Arduino's 5 V rail. Power the relay board from a separate 5 V supply and tie its ground to the Arduino's. When switching large inductive loads (motors, solenoids), add a flyback diode on the load side, or use a contactor.
3. Three push buttons
Basic use: (1) platform in / platform out (mutually exclusive, interlocked in software); (2) press up/down. Wiring: one leg to an INPUT_PULLUP pin, the other to ground; a press pulls the pin low.
Other ways to use it: (1) distinguish short and long presses with a FreeRTOS timer — a short press triggers a single action, a long press (>500 ms) starts a continuous action or switches modes; (2) two-button chords (e.g. "in + up" together for manual jogging), giving quick manual control without an HMI; (3) add a latching switch for a manual/auto mode selector.
Traps: mechanical buttons always bounce (5–20 ms), so debounce in software (re-read after ~20 ms, or use a state machine). In noisy or ESD-prone industrial settings, an RC filter (1 kΩ series + 100 nF to ground) on each input helps.
4. Three pneumatic solenoid valves
Basic use: energize the solenoid → the valve switches supply/exhaust → the cylinder moves. Driving the valve coils through relays is the most common approach, so the Arduino never drives a coil directly.
Other ways to use it: (1) a 3/2 valve with a single-acting cylinder (spring or air return); (2) a 5/2 valve with a double-acting cylinder (one port each way); (3) hierarchical control — a main valve for the air supply and sub-valves for each line, so one failed sub-valve doesn't take out the other circuits; (4) add a pressure regulator: most fixtures only need 0.3–0.6 MPa, and running straight off a 0.7 MPa+ shop supply wears out cylinder seals.
Traps: some DC valve coils (those with a built-in indicator LED or suppression diode) are polarized — wire them backwards and they won't actuate. Very rapid cycling heats the coil, so enforce a minimum interval between actions in software. And fit exhaust silencers, or every valve switch sounds like a small explosion.
5. One buzzer
Basic use: sounds when the fixture retracts, signaling pass or fail. An active buzzer (built-in oscillator) just needs DC power; a passive buzzer needs a 2–4 kHz square wave from an Arduino PWM/tone() pin.
Other ways to use it: (1) use rhythm to encode results — 1 short beep = PASS, 3 short beeps = FAIL, continuous = emergency stop/warning, a common test-fixture convention; (2) pair the buzzer with an LED so operators still get a visual signal in a noisy factory; (3) drive it from its own FreeRTOS task so beeping never blocks the main sequence.
Traps: buzzers draw around 15–40 mA, so drive them through a transistor or relay rather than straight from a pin. Continuous sounding warms them up, so switch it off when done (this fixture's code does). And a passive buzzer wired like an active one makes no sound at all.
6. Cycle counter
Basic use: every completed "in → press → out" cycle adds one, tracking press-pin cycles or fixture utilization. A hardware counter (e.g. a standalone counter module, or a MAX7219-driven display) just needs a pulse from an Arduino pin.
Other ways to use it: (1) set a target (e.g. 100 cycles) and alarm or lock out when reached — handy for fixed-quantity runs; (2) log history to EEPROM or an SD card for production traceability; (3) keep two counters — a lifetime total and a per-shift count that can be reset by hand.
Traps: a pure software counter (a variable) resets on power loss. To keep it, write to EEPROM — which has a limited number of write cycles, so batch the writes — or use a hardware counter that retains its value without power.
7. Four air cylinders
Basic use: four cylinders provide the linear motions — press pins up/down and the platform in/out. Size stroke and bore for the load: force = air pressure × piston area, minus friction (a conservative factor of about 0.7).
Other ways to use it: (1) two cylinders in parallel on the same side double the force; (2) add magnetic reed switches to report piston position — reading those is far more reliable than just waiting a fixed delay; (3) grippers, rotary actuators, and finger cylinders all use the same valve-driving scheme, so this architecture carries over directly.
Traps: without position switches, always protect with timeouts so a cylinder can't slam its end stop indefinitely. Aging cushions and seals leak and shorten the stroke, so schedule maintenance. For high cycle rates, choose cylinders designed for it (e.g. compact/short-stroke types with proper cushioning).
8. AC to 12 V DC power supply
Basic use: converts 110/220 V AC to 12 V DC for the relay board, valves, buzzer, and counter. The Mega's Vin accepts 7–12 V, so it can share the supply — just watch the total current.
Other ways to use it: (1) treat 12 V / 1 A as the bare minimum; with relays, valves, and buzzer all active, peaks of 1–1.5 A are realistic, so a 2 A supply gives headroom; (2) split the rails — 12 V for power loads (valves, relays) and a separate 5 V for the Arduino — so load current swings don't disturb the MCU; (3) in industrial settings, consider 24 V DC (the PLC-world standard) with 24 V valves and relays for better noise immunity and longer cable runs.
Traps: plan grounding deliberately. Bring all power-side grounds to one bus and connect it to the Arduino ground at a single point, avoiding ground loops that inject noise into the logic.
Putting it together
- Manual and automatic at the same time: this is the heart of the design. Button actions and the automatic sequence can run concurrently thanks to FreeRTOS task scheduling plus interlock flags, which stop manual and automatic logic from driving the same relay at once — that's what the program's flag structure is for.
- Wiring safety: run AC and DC in separate cable ducts, size the DC power wires (valves, relay loads) generously, and terminate every wire in a terminal block or cage clamp — never bare wire twisted under a screw.
Related tools: LED Resistor Calculator
This post is adapted from the Traditional Chinese original on Vic's Iteration Notes.
Comments
Post a Comment