PWM1 PWM Controller

J1 carries the 5 V supply input and the CAN bus. The mating connector is the Phoenix Contact 1027605.

Fitting a jumper on JP2 connects a 120 Ω termination resistor across the CAN bus. Fit it only on the two nodes at the ends of the bus. Jumper pitch: 1 mm.

J3 is designed for use with the ST-LINK-V3MINIE and can be used to debug the board or load firmware onto the microcontroller. Mating part: 14-pin STDC14 Cortex ribbon cable.

J5 is an 8-pin header (1.27 mm pitch) with four rows. Each row has a signal pin (odd pin numbers 1, 3, 5, 7) beside a ground pin (even pin numbers 2, 4, 6, 8). Every signal pin has a 10 kΩ pull-up to 3.3 V, so an open row reads high and a jumper fitted across a row pulls its signal low. The board silkscreen labels the rows 4 3 2 1 from left to right.

Row 1 selects the mode: with a jumper fitted the board is in servo mode and listens for ArrayCommand, with the row open it is in motor mode and listens for RawCommand. Rows 2 to 4 form a 3-bit actuator ID offset (0 to 7) in which a fitted jumper sets the bit to 1. Output 0 answers actuator ID = offset, output 1 offset + 1, output 2 offset + 2 and output 3 offset + 3. The pins are read at start-up only, so reset or power-cycle the board after changing a jumper. This offset does not change the node ID.

J5 pinout and function

Example J5 settings (1 = jumper fitted; row 1 is the mode, rows 2 to 4 are offset bits 0 to 2)

J4 is an 8-pin header with four signal and ground pairs, one pair per PWM output. The signals are 3.3 V push-pull logic from the PCA9685. J4 has no power pin: the servo or ESC supply must come from elsewhere, with its ground connected to J4. The PWM signals are also wired to analog inputs on the microcontroller, which the current firmware does not use.

Every node on a DroneCAN bus has a unique node ID from 1 to 127, which is the source address of the messages it sends. The J5 jumpers select the mode and actuator IDs, not the node ID, so the node ID is 10 unless a different ID has been stored over CAN. Give each board on the same bus its own node ID.

To set the ID over CAN, use the standard DroneCAN parameter services (for example in the DroneCAN GUI tool): write the integer parameter NODE_ID (1 to 127) with uavcan.protocol.param.GetSet. The value is stored in flash straight away and is used after the node restarts, which can be requested with uavcan.protocol.RestartNode. Writing 0 removes the stored ID so that the default of 10 is used again, and the ExecuteOpcode erase command removes the stored ID, pulse width limits and motor timeout. Values outside 0 to 127 are ignored. Writing flash stops the processor for a few tens of milliseconds, so do not change the ID while the actuators are in use.

DroneCAN priorities run from 0 (highest) to 31 (lowest). The node’s own messages (NodeStatus) use priority 1 in motor mode and priority 20 in servo mode.

With the J5 row 1 jumper fitted, the board subscribes to uavcan.equipment.actuator.ArrayCommand (type ID 1010). Each Command in the array whose actuator_id is between the actuator ID offset and offset + 3 updates the matching output; other entries are ignored. Only command types UNITLESS and PWM are used, and other types are ignored.

With the J5 row 1 jumper open, the board subscribes to uavcan.equipment.esc.RawCommand (type ID 1030). The command array is indexed by actuator ID: the board uses entries offset to offset + 3 (those present in the message) for outputs 0 to 3. The valid range is 0 to 8191 and maps linearly from the motor minimum pulse width (0) towards the motor maximum (8192 would be full scale); the defaults are 1000 µs and 2000 µs. Negative values are not supported, because there is no meaningful PWM for them, and are treated as 0 (1000 µs). If no RawCommand message is received for the motor timeout (5 seconds by default), the outputs are switched off.

The limits that scale the commands, and the motor mode timeout, are programmable over CAN as integer parameters (uavcan.protocol.param.GetSet; microseconds for the pulse width limits and milliseconds for the timeout), for example from the DroneCAN GUI tool or the can_pwm_param.py script supplied with the firmware. They are stored in flash, take effect immediately and are kept across restarts. Writing 0 to a parameter, or erasing, restores its default. The pulse width limits must be 1 to 20000. The timeout must be 100 to 60000 ms, the timeout action 0 or 1, the prescale 3 to 255, and the arming time 100 to 10000 ms. A change that would leave an output with a maximum that is not above its minimum is ignored, so when moving a range up, set the maximum first. Servo commands of type PWM are also limited to the servo range, so a pulse width outside it is clamped to the minimum or maximum.

Bench measurement. Three parameters that are not stored let the board time its own PWM outputs: writing 1 to 4 to PWM_MEASURE times output 0 to 3 (it reads back 0 none yet, 1 busy, 2 done, 3 failed or refused), and PWM_PERIOD_US and PWM_HIGH_US hold the last period and idle pulse width in µs. A measurement drives the 1000 µs idle pulse on that output for about a second, so the board refuses it once it has received a command since it started, or while the PCA9685 is not answering. It is used to calibrate PWM_PRESCALE at bring-up.

Calibrating the PWM timing. The period is 4096 × (PWM_PRESCALE + 1) divided by the PCA9685 oscillator frequency, which is 20 ms at the default of 121 only if the oscillator is exactly 25 MHz. Measure the period of an output (for example with an oscilloscope while the board is sending a motor command of 0) with the default prescale and set PWM_PRESCALE to round(122 × 20000 / measured period in µs) – 1. A board measured at 18.6 ms needs 130. The change applies at once, with a pause of about a millisecond in the outputs.

Many ESCs have to see the zero throttle pulse (1000 µs) once before they arm, so an ESC will not arm if the motor minimum pulse width is raised above it. If MOTOR_ARM_MS is set, the board in motor mode holds all four outputs at 1000 µs for that long after power-up so the ESCs can arm, then idles them at the configured minimum pulse width until commands arrive. RawCommand messages received during the arming time are ignored. Servo mode does not arm.

After power-up the outputs stay low (0 % duty) until the first command for that output arrives.

In motor mode, if no RawCommand message is received for the motor timeout (5 seconds by default, programmable), all four PWM signals are switched off (held low), or, if MOTOR_TIMEOUT_ACTION is 1, held at the minimum pulse width (zero throttle) so an ESC stays armed. They resume with the next RawCommand. Any RawCommand message restarts the timer, whether or not it contains entries for this board. In servo mode there is no timeout: each output keeps its last pulse width, so arrange failsafe behavior in the flight controller or the actuator.

If the PCA9685 stops answering on the I²C bus, the board reports it in NodeStatus, stops writing to it, and every second tries to re-initialize it. When it answers again the health returns to OK and the outputs are restored to their last commanded state. After a CAN bus-off the board restarts its CAN controller every 100 ms until it rejoins the bus.

A new board is set up in one step with tools/bring_up.py: it erases the flash, programs the firmware, runs a CAN transceiver self-test, calibrates the PWM timing (PWM_PRESCALE) against the MCU’s timer, checks all four outputs, and records the result in a log file. To update the firmware on a configured board, connect an ST-LINK-V3MINIE to J3 (STDC14) and run make flash in the firmware repository. This runs tools/flash_and_check.py, which programs and verifies the firmware over SWD with OpenOCD, resets the board and then checks over CAN that the node answers GetNodeInfo with health OK, and prints PASS or FAIL. The node ID, pulse width limits and motor timeout stored in flash are kept when the firmware is updated unless the script is asked to clear them.

The firmware version (major.minor, with the git commit it was built from) and the hardware version (the board revision as a number: Rev A is 1, Rev B is 2) are reported by GetNodeInfo and is also stored in flash right after the vector table, so it can be read over SWD without a CAN connection. flash_and_check.py shows it before and after programming and checks that the board reports the version that was programmed.

The firmware repository includes Python scripts for use with a serial USB-CAN adapter. Any DroneCAN GUI tool can also read and set the parameters.