_{English · Deutsch}

The programmer reads the 32 registers of a KST or Chaservo servo over its signal wire, shows them as settings, and writes changed settings back. The servos of the two brands share one protocol and one register set. It is an overlay on the SERVO screen, opened with PROGRAM at the top of the right card. PROGRAM ends a running automatic test as stopped by the operator.

KST and Chaservo are names or trademarks of their respective owners. rcbench is independent: it is not affiliated with, endorsed by or sponsored by them. The names say which servos the programmer works with. Legal notice and disclaimer holds the project's notice.

The register layout and the timing come from 1 Tool Card #2, KST's programming card, and 1 Chaservo servo of unidentified model. The effect of a register on the servo's motion is not measured: the names, units and limits are those the vendor tool displays and accepts. What is open lists what a bench has to measure before a write is relied on.

• The coprocessor runs protocol 4.13 or later. With an older one the overlay says Not available: the coprocessor has no programming port. and Update the coprocessor to version 4.13 or later., and every control but CLOSE is off.

• LEAVE with its wait needs protocol 4.15 on the coprocessor. An older one is named and handled without it.

  

• The servo is on the coprocessor's programming port, port 1: GP13, pad 17 of the bring-up module, unless another pin is stored for it. The port is no output channel and no slot of OUTPUTS.

• The SERVO screen's PWM TARGET is PROG PORT (the target). With the standard outputs as target the programmer is locked.

• One servo at a time.

• The port is in PWM (pulse-width modulation) or in programming, never both. While the port is in programming, the tester sends no pulse to it, and its COMMANDED row reads ---.

• Programming and the ARMED state are exclusive. CONNECT on a bench that is ARMED for any role, asked to arm or has a finger on ARM is refused with DISARM first: the port is not taken while ARMED. While the port is held, from CONNECT until it reports PWM, no screen switches the bench to ARMED: ARM on SERVO and on MOTOR & ESC is drawn disabled and takes no press, and a run of the ESC stick programmer does not start and says Servo programmer holds a port: LEAVE on SERVO first. An arm that reaches the bench another way is refused with the alert no arm: the servo programmer holds a port. DISARM and STOP work in every state. While the bench is ARMED the read, the verify, the write, the restore and the pairing release are refused with the same line as CONNECT; LEAVE is taken.

• With a PD mini answering, the port sets the servo's supply at CONNECT (the supply). Without one the supply is not the bench's to set, and the programmer takes it as it is.

• The programmer assumes that a servo needs no power cycle: neither to take a written value into effect nor to follow PWM after programming. Neither is measured (limitations).

• Whether a given hardware carries the servo's reply back to the pin is not known to the coprocessor. A servo on a port that does not ends CONNECT with No servo answers. Check plug, supply and port.

The tester of the SERVO screen drives the standard servo outputs or the programming port. SETTINGS, tab DUT, holds the two rows:

Both rows are kept with the SERVO settings. The SERVO screen names the active target in the TARGET row of the right card, with the pins: PROG PORT GP13 in the warning colour, or GP4 for the pins bound as SERVO PWM. PWM TARGET changes only with the bench SAFE, no sweep and no test running, and the port not in programming; the panel releases a held position before it asks the coprocessor for the other target. PORT PWM goes on under the same rule. It goes off with the port not in programming, no sweep and no test running, with the bench ARMED as with the bench SAFE: STOP and DISARM end a sweep or a test. With OUTPUTS as target PORT PWM is locked.

While the programmer has the port neither row changes: from CONNECT to the port back in PWM after LEAVE, during every operation, and for as long as the coprocessor reports the port out of PWM. Both rows are drawn locked, a reset of the settings leaves the two values, the panel writes nothing to the coprocessor's page of the port, and the tester sends the port no command and no release. A release owed to the port goes out once the port is back in PWM.

A port without a pin cannot be the target: a slot of OUTPUTS that holds GP13 leaves the port none. The tester then keeps the standard outputs, whatever the row says.

With the standard outputs as target the programmer shows Programming needs the programming port. and SERVO screen, DUT tab: set PWM TARGET to PROG PORT., and every control but CLOSE is off.

CONNECT takes the port out of PWM, sets the supply where a PD mini answers, runs the entry sequence and reads all 32 registers. The button reads ABORT while an operation runs or a leave waits, and LEAVE in programming mode.

While a write, a restore or a pairing release runs, the SERVO tab shows Writing: do not unplug. in the warning colour, and RESTORE takes no tap. The record of that write is on the card or in memory and is not shown as an interrupted write before the write ends without a result.

While the port is in programming the overlay stays open, SETTINGS is off and the tester's controls send nothing to the port. STOP on the right card works. Leaving the SERVO screen leaves the port as it is; the overlay is open again at the next entry.

The servo's signal pin is a microcontroller GPIO (general-purpose input/output). The high level of its reply is at most 5 V and typically 3.3 V. The level is not measured. GP13 is rated 5.5 V while the coprocessor's IOVDD (input/output supply) is at 3.3 V (hardware/docs/IOBoard.md, pin ratings), so the port has no level shifter and no clamp.

With the coprocessor unpowered GP13 is rated 3.63 V. A servo that drives the wire at 5 V while the coprocessor is off exceeds that rating. What the servo's pin does at idle with the bench off is not measured.

Power the coprocessor before the servo's supply, or do not feed the servo from an external supply while the bench is off.

With the port in the tester's hands, MORE opens what CONNECT sets.

Each entry opens the number keypad with its range. A value outside the range is not taken. All three are kept with the SERVO settings.

CONNECT switches an output that is off on at the two values, and the session starts 1000 ms after the PD mini reads on. For an output that is on, the session runs at the lower of the two voltages and the lower of the two current limits: a voltage above the programming voltage is lowered to it, a current limit above CURRENT LIMIT is lowered to it, and neither is raised. Leaving programming does not restore a value CONNECT lowered.

The port programs at 4.8 V or more. The supply voltage a servo needs to store a register is not measured. An output that is on under 4.8 V is not programmed at and stays as it is; the operator raises it first. A PD mini whose input voltage is under 5.5 V cannot give 4.8 V, and no session starts on it.

While the port is out of PWM the supply's set points are the port's. The coprocessor refuses every change of the voltage and of the current limit and every ON; it takes an OFF. The SUPPLY screen and the SET row of the right card show the same: the set points, the sliders, the steps and OUTPUT ON are dimmed and take no press, OUTPUT OFF and RESET PEAKS work, and the MODE card of the SUPPLY screen reads servo programmer. The limits of the SUPPLY screen's settings stay editable; a limit lowered under a set point reaches the set point when the port is back in PWM.

An OFF that arrives while a frame is on the wire, from OUTPUT OFF, STOP or a lost heartbeat, reads off at once and reaches the PD mini when the port has cut the frame, 12 ms later at most. The PD mini's own protection is not delayed. How long the PD mini's output takes to fall after its off command is not measured.

A voltage above 6.0 V needs HV SERVO on the TEST tab of SETTINGS; without it the keypad ends at 6.0 V. With it, a value above 6.0 V opens the warning page of the SERVO screen's high-voltage setting, and HOLD TO APPLY takes it after 2 s. Switching HV SERVO off sets a programming voltage above 6.0 V back to 5.0 V.

A voltage above 6.0 V is not stored. The SERVO settings keep 6.0 V for it, and a stored value above 6.0 V, from the settings page or a settings file, is loaded as 6.0 V and stored as that, with HV SERVO on or off. The programmer reads the settings when it opens and at every entry of the SERVO screen while no port is held, and when the panel starts under a held port: each of these begins at 6.0 V or below, and a voltage above it takes the warning page and its hold of 2 s again. A session that holds its port keeps the voltage it began with.

With a PD mini answering, the state line names the values before CONNECT and the measured output voltage and current in programming mode. The SUPPLY screen and the supply rows of the right card follow what the port set.

Without a PD mini the voltage and the current limit are stored and not applied. WAIT BEFORE PWM is applied at leaving with and without a PD mini by a coprocessor of link version 4.15 or later.

In PWM with a PD mini answering the PORT row reads PORT 5.0 V 1000 mA: the voltage and the current limit that CONNECT sets. A row whose button is drawn off takes no tap: FILES outside programming mode and while the servo is in doubt, RESTORE while an operation runs, the write switch where it is refused.

Below the rows stand the port's state, the servo type, the name of the session's backup file and the last message. A message in the warning colour is a refusal or a result that needs a second look; one in the danger colour says the servo's content is in doubt.

The coprocessor compares the image with the layout of the known servo, its fingerprint. An image that fails is shown and never written: the edit rows and the write switch are off and take no tap, the tab keeps Read only: this servo is not a known type., and RELEASE PAIRING is refused. READ ALL, a save to a file and VERIFY work. A file is not loaded.

A value is edited in a draft on the panel. Nothing reaches the servo before WRITE n VALUES. A value that differs from the servo's is marked twice: by * before it and by the accent fill.

A numeric value opens the keypad. Its range is the range the hard limits accept in the draft as it stands, so a value outside cannot be entered. STRETCH opens a list of the 6 confirmed factors. An ON/OFF value flips on the tap. DEAD BAND and NEUTRAL have minus and plus keys: one raw count a tap, and while held 8 counts a second after 0.45 s and 30 a second after a further 1.8 s.

The NEUTRAL conversion between register and µs is a fit to 3 values and uncertain by about 1 µs. The tab says of the two angles LEFT ANGLE, RIGHT ANGLE: the servo's number, unit unknown. The screens write us for µs: their font has no micro sign.

The limits are those of protocols/kst/kst_limits.c; the panel holds none of its own. The lower limit of MAX. DUTY and the 5 % of SPEED are choices, not readings of a servo.

A tap that would break a hard limit changes nothing and says which limit.

A value inside the hard limits that breaks a soft limit opens CHECK THIS CHANGE with the field's line and one line per limit. The field's line counts from the servo's value, not from an edit before this one: MAX. DUTY: 96 -> 97 % is the value the servo holds, the new value and the unit. HOLD TO APPLY takes it after 2 s of holding; CANCEL, or a finger that slides off, leaves the draft as it was.

A limit confirmed for a value is confirmed for that value. A later edit of the field opens the page again when it moves the value further from the servo's than the value confirmed, or to its other side: 97 % confirmed, 98 % asks again and shows MAX. DUTY: 96 -> 98 %, and 97 % after that does not. A write, a read and DISCARD EDITS end every confirmation.

"The servo's" in this table is the value of the session's backup, the servo as the session first read it. A write of the session does not move it: a value raised in two writes is compared with the value the servo came with. Where the panel does not hold that backup, or the backup is another servo's, it is the value last read. The warnings of a restore compare with the servo as last read.

These values are shown and no edit changes them. Their function or their encoding is not confirmed. The tab also shows the pairing value, register 1D, and the card number the vendor tool needs for this servo. A servo in Gyro Servo mode is read and not written: the limits of that mode are not known.

ENABLE WRITE TO SERVO is off by default. A tap on OFF opens a page that names the risks; HOLD TO ENABLE switches it on after 2 s. A tap on ON switches it off at once. A tap on WRITE n VALUES with the switch off opens the same page: its hold switches the switch on and writes nothing, and the next tap on WRITE n VALUES opens the write page.

The switch goes off:

• at every entry of the SERVO screen,
• when the link to the coprocessor goes or the coprocessor starts again,
• at STOP and at every stop the bench latches,
• with every CONNECT and every LEAVE,
• when a read finds another image than the one held,
• when a read fails the fingerprint,
• when a write, a restore, a read or VERIFY ends with the servo in doubt: the read that follows does not switch it on again,
• when a read finds a servo that fits the record of an interrupted write.

With the switch off the panel sends no write, no restore and no pairing release, and the coprocessor refuses one that arrives without the switch's key. Reading, VERIFY, saving to a file and loading a file work with the switch off.

The switch takes its tap with a servo read. Where it does not, OFF is drawn off: without a servo read, with a servo that fails the fingerprint, while an operation runs and while the panel asks whether the servo is the one of an interrupted write. A session the coprocessor has locked after an interrupted write takes it with no servo read as well, once the panel holds the session's backup: this is the state of a panel that starts under such a session. The switch then opens one write, the restore of the session's backup. An edit, a write of values, a pairing release and a load of a file stay refused until a read and the end of the lock. READ ALL in that state reads the servo and shows its values; the lock stays, and no value is edited.

WRITE n VALUES counts the fields in which the draft differs from the servo; with one such field it reads WRITE 1 VALUE. It is off without a change. With the switch off its tap opens the switch's page.

A tap opens the write page. HOLD TO WRITE starts the write after 2 s. The page has 12 lines.

The changed values come first, in the order of the tabs, one line each: DEAD BAND: 2.0 -> 1.6 us is the servo's value, the new value and the unit. A value at fault for a soft limit is in the warning colour. With more values than lines the last of these lines counts the rest: and 4 more. A first write with a card shows 7 values, or 6 and the count; one without a card 6, or 5 and the count.

Horn free, no linkage attached. and Test the servo on the bench before it goes into a model. follow on the first write after a CONNECT and on every write that changes REVERSION, NEUTRAL, PULSE LOWER, PULSE UPPER, LEFT ANGLE or RIGHT ANGLE. A write that the card, a stop or the link kept from starting is not that first write: the lines stay for the next one.

1. The first write of a session saves the servo's values to a new file on the card. A card that is mounted and does not take the file ends the write. With no card mounted the write page says that no file is saved, and the write goes without one. While the record of an interrupted write is held no file is saved: the servo may be half written, and the record holds its values as found.
2. The panel records the image the servo holds, the image the write is to leave and the port: with a card in KST/KST.TXT, without one in memory. The page says which. With a card that takes no file within 3 s the write is not sent: The card took no file. Nothing was written to the servo.
3. The panel sends the target image. The coprocessor checks it against the same limits, plans the register writes and runs them.
4. Every register written is read back. A write that does not take is undone.
5. 3 values written and verified., or 1 value written and verified., ends it and clears the record.

A value written and read back is taken as in effect. The programmer asks for no power cycle after a write, and its verify is the read-back of the same session. Whether a servo acts on a written value before its next power-up is not measured.

Only registers whose value changes are written. Register 00 is never written; register 1D is written by RELEASE PAIRING only.

A message about a failed write names the register and the count of writes done: Register 03, 1 write done.

KST.TXT is the record of a write under way: text of at most 400 bytes in the card's folder KST with the line RCBENCH KST 2, the lines journal=, target=, port= and pin=, and check= with the CRC-16 (cyclic redundancy check) of the bytes before it. pin= holds the GPIO (general-purpose input/output) the port drove at the write, in two hexadecimal digits: 0D for GP13, FF when the panel knew no pin for the port. A record of version 1 (RCBENCH KST 1, no pin= line) is read and names the port only. A pin above GP47 reads the same way: the record stands and its lines name the port. A file whose check fails is not used: KST.TXT on the card is not readable. It is not used. The name KST is the record's: no servo file takes it, and the list of files leaves it out.

The panel writes the text to KST.NEW, and the file takes the name KST.TXT once the card holds it whole. A write that the card or the supply ends leaves KST.TXT as it was or a whole KST.NEW. At power-on a KST.NEW whose check holds is used and renamed; one whose check fails is removed and KST.TXT is used. A file the card does not take is written again every 5 s until the card takes it, so that a record discarded on the panel does not stay on the card.

A servo file is a text file in the folder KST of the panel's SD card with the 32 registers of one servo, named <name>.TXT. The panel creates the folder with the first save. FILES opens the list. It is active in programming mode with a servo read and not in doubt; otherwise the tap answers Read the servo first: READ ALL. Saving and loading work with the write switch off: a file changes the draft on the panel, never the servo.

The first entry saves. Below it stand the files sorted by name, 5 a page, each with its servo type; a file without a type line shows none. The files with a proposed name, KST and 3 digits, stand together at the place of KST000, the highest number first. The list reaches every servo file of the card. With more than 5 files the title counts them, FILES 1 TO 5 OF 7, and Show the next files turns the page, back to the first after the last. The panel asks the card for each page and waits at most 5 s for it.

A servo and a file are V6 or V8. The 20k_sel field decides: 1 is V6, a 20 kHz drive; 0 is V8, a 333 Hz drive. No other register enters the type. Once a servo is read, the SERVO row reads SERVO V6 or SERVO V8 and the line below the rows says Servo type V6: 20 kHz drive. The type is never edited and never written.

Save this servo's values as a new file opens the text keyboard with the next free preset name, KST001 to KST999. The keyboard takes up to 16 characters: A to Z, 0 to 9, -, _ and the full stop. OK saves; the card's side checks the name and never replaces a file. Names compare without case. A file with a longer name, up to 32 characters, is listed and loaded; a line that names it shows its first 14 characters and ...

A save the card ends after the 5 s is the file it made. With no other file operation running the line changes to Servo values saved to the card: and the name. It is the session's backup file if the servo still holds the saved values and no write followed.

A save writes the image as read, the locked fields included, also of a servo that fails the fingerprint.

The first write, restore or pairing release of a session saves the servo's image to a new file under the next free preset name, without asking. The write page says The servo's values go to a new file on the card first. The servo receives nothing before the card holds the file. A mounted card that is full, that fails the write or that leaves the slot between the request and the file ends the write with the lines of the table above, and nothing is written to the servo. Freeing space on the card or removing the card lets the write go. The SERVO tab then names the file: Backup file of this session: KST003. A save by hand before the first write of the session counts as that file. A save by hand after a write holds the written values and leaves the line as it is. A read that finds other values makes the next write save again.

A servo in doubt is the exception: its image is not worth a file, and the restore of the session's backup runs without one.

With no card mounted the write, the restore and the pairing release are not blocked. The page whose hold sends the write carries three more lines:

No card: no backup file of the servo is saved.
The backup of this session is held in the bench only.
It is gone when the session ends or the bench loses power.

The page's one hold of 2 s confirms them; no second hold is asked for. A hold released before 2 s sends nothing.

After such a write the SERVO tab shows No backup file: no card. Session restore only. in place of the file's name. The only copy of the servo as found is the session's backup in the coprocessor: LEAVE, a restart of the coprocessor and a power loss of the bench end it, and the values the servo held before the write are then not recoverable from the bench.

A tap on a file loads it. Its editable fields become the draft, exactly as edits typed on the tabs: changed values are marked, WRITE n VALUES counts them, and nothing reaches the servo before the write switch, the write page and its 2 s hold.

The line of an edited file counts the values its lines give, of the 27 a servo file has. A value the file does not give stays as the servo has it.

A file whose values pass a soft limit that the servo's own values keep opens CHECK THIS FILE before anything becomes the draft. The page has 12 lines: the file's line, the line of an edited file, the values that differ as the write page lists them, 4 or 3 and and 2 more, and the same warning lines an edit past those limits shows; with more warnings than lines the last line counts the rest. HOLD TO LOAD for 2 s takes the values into the draft. CANCEL leaves the draft as it was.

A load writes the editable fields only. These stay as the servo holds them, whatever the file says:

• the servo type, 20k_sel,
• Lock,
• the mode, Servo or Gyro Servo,
• the protection block of the LOCKED tab,
• the pairing value, register 1D,
• register 00 and every bit that belongs to no named field.

A file that differs there is loaded, and the difference is counted: 2 locked values differ: locked, not written., or 1 locked value differs: locked, not written. The LOCKED tab marks each such value with !. A file without a type line that holds the other type's 20k_sel is loaded the same way, since nothing but the type line denies a load.

The restore of the session's backup is the one way to write a locked register, and it ends with the session.

RESTORE opens the list of what there is to restore. Every restore needs the write switch and a 2 s hold.

A restore from the panel's image is an ordinary write: the coprocessor accepts an unchecked restore only of the backup it holds itself, and that check is not weakened. The page counts the locked values that differ and stay: 2 locked values differ and stay as they are., or 1 locked value differs and stays as it is. A servo file is not in this list: a load makes it the draft, and the ordinary write sends it.

A backup whose values pass a soft limit that the servo's own values keep opens CHECK THIS BACKUP first. The page lists the warnings of those limits, the same lines an edit past them shows, at most 5; with more than 5 the fifth line counts the rest. HOLD TO GO ON for 2 s opens the restore page, which needs a press and a 2 s hold of its own. The restore of the session's backup is checked the same way while the servo's values are known.

The session's backup belongs to the servo it was read from. A read that differs from the backup in a field no write of the session set out to change is another servo: Another servo: the session's backup is not for it. LEAVE, then CONNECT: a session with its own backup. The write switch goes off, the restore list does not hold the session's backup, and no restore of it is sent. LEAVE and CONNECT begin a session whose backup is this servo's. A read of the first servo brings its backup back. A write that the card, a stop or the coprocessor keeps from starting, or that the coprocessor ends with no register written, counts as no write: its fields still tell the servos apart. So does a write that is undone and read back with no write counted done.

The coprocessor makes the comparison again, register by register, on the read that precedes the first write of a restore of the session's backup. It holds the set of registers that the writes of the session changed. A servo that differs from the backup in any other register is not the backup's servo: the restore ends with The servo differs from the read. READ ALL., no register is written, the write switch goes off and the port takes READ ALL and nothing else until the servo is read. The restore therefore does not repair a register that something other than a write of the session changed. After a write that ended without a full read of the servo, the registers that differ at the next full read count as changed by that write.

While a read is owed after a write in doubt and the session is not locked, the restore list does not hold the session's backup: Read the servo first: READ ALL.

A restore, a pairing release or a write that the card or the panel's control task keeps from starting leaves the pending values, the write switch and the record of an interrupted write as they were before the hold. Two servos equal in every field the session did not write are not told apart. After a link loss or a start of the panel under a session the session's writes are not known, and the comparison is not made.

A power cycle of the servo ends the session's backup and the record of the session's writes. The servo on the port may be another one after it. Such a power cycle is a PD mini's supply switched off under the session, a supply cycle the port runs, or the POWER_CYCLED operation the panel sends in place of LEAVE. The port is then in PWM, and the restore list holds no session backup. CONNECT begins a session whose backup is the servo as its first READ ALL finds it. A backup file on the card stays there.

The SERVO screen's limit run drives the programmer itself whenever PWM TARGET is PROG PORT (Servo procedures). Its first session reads the servo, with SEARCH ONLY as well: CONNECT with its read, LEAVE. With SERVO PULSES at 1000-2000 that session also writes PULSE LOWER 1000.0 µs and PULSE UPPER 2000.0 µs. With SEARCH+PROG each later write is a session: CONNECT with its read, ENABLE WRITE TO SERVO on, LEFT ANGLE and RIGHT ANGLE written and read back, the write switch off, LEAVE. Whatever the overlay has open closes at each step. A value under 50 passes its soft limit without the page: the run's 2 s start hold is the consent. A hard limit refuses a value as it refuses an edit, and the run ends. A write refused before it is sent switches ENABLE WRITE TO SERVO off again, as the end of a sent write does.

The run's first write saves the backup file, as any first write does. A later session of the run whose servo differs from the run's first read in LEFT ANGLE, RIGHT ANGLE, PULSE LOWER and PULSE UPPER at most saves no file: the first file holds the servo as the run found it. A session after the run has ended is the operator's: its first write saves its own backup file, as every session's first write does. The run holds that read in the panel's memory until the next run's first write or a start of the panel, and RESTORE offers it as Values before the limit run. While the run holds the port, the screen's TARGET row and the run's box name it: PROG PORT GP13.

A run aborted inside a session leaves the port in programming mode with the values last written. LEAVE gives it back to PWM; CONNECT and READ ALL offer the restore. A run that fails inside a session gives the port back with LEAVE itself, and the run's box stays on the left card. The programmer's part of the run, with the supply values it keeps, ends once that LEAVE is over. A LEAVE that fails leaves the port in programming mode, and the programmer opens on the left card.

• VERIFY reads all registers and compares them with the image held: Verified: the servo holds what was read. or the count of registers that differ.
• DISCARD EDITS sets the draft back to the servo's values.
• RELEASE PAIRING sets register 1D to 00 after the write switch and a 2 s hold. What the servo does with the value is not known. A restore of the session's backup sets it back.

A write counts as interrupted when the link goes, the coprocessor or the panel starts again, ABORT or a stop ends it, or no result arrives in time. The record made before the write then stands, on the card across a power cycle of the bench.

A write was interrupted. The servo may be half written. stays until the servo is read, with the pin of the write below it: Do not use it. Connect it on GP13 and READ ALL. A record that holds no pin names the port instead: Connect it on port 1 and READ ALL. Every control but CONNECT, READ ALL, RESTORE, LEAVE and, where the session's restore needs it, the write switch is off. The read compares the servo with the record:

Discard the record of the interrupted write in the restore list removes the record without a write.

A servo that holds, register for register, the image before the write or the image the write was to leave is either the servo of the write or a second servo with the same settings. The panel cannot tell the two apart and asks. The two lines stay on the SERVO tab, the write switch does not go on, and no write, restore or pairing release is sent. If it is the servo of the write, Discard the record of the interrupted write in the restore list ends the question. If it is not, LEAVE keeps the record for the servo of the write.

The record belongs to one servo. A servo read on another port is not that servo, and neither is one with a register that holds neither the value of the image before the write nor the value the write was to leave: This is not the servo of the interrupted write. It was on GP13. RESTORE: discard the record. For a record that holds no pin the line names the port: It was on port 1. Nothing is restored, edited or written while that stands, and RESTORE holds the discard entry only. LEAVE and a CONNECT of the write's servo bring the comparison above. One register is exempt: the low register of a field that lies in two registers and that the write changes, because the plan of a write may set it to a third value on its way.

The comparison is made when the servo is read and when the record is loaded: a record from a card mounted with a servo already read is compared with that servo at once. A restore of the session's backup with no servo read does not belong to a record that is held: the record stays as it is, on the panel and on the card. With no record held such a restore makes its own, with the backup as the image the servo is to hold. A record made while no card is mounted is written to a card that is mounted later.

Max. Duty lies in registers 01 and 02. A write cut between those two leaves an image that breaks a hard limit, and the panel's restore, which is a checked write, does not start from such an image. The restore of the session's backup does. After a restart of the coprocessor in that state the programmer reads the servo and writes nothing to it.

LEAVE, or CLOSE in programming mode, asks to end the session and to return the port to servo PWM. The programmer does this without a supply cycle: the servo stays powered, a PD mini's output stays on at its voltage and current limit, and the tester's signal follows on the same port. Whether a servo that received a frame follows PWM before its supply was off is not measured.

Leaving the SERVO screen is no LEAVE: the session and the port stay. A PD mini output SERVO switched on -- by OUTPUT ON, by a test or by CONNECT -- is the SERVO screen's, and while the port holds it the output stays on after SERVO is left: an OFF would end the session and cut a write on the wire. An ON SERVO asked for that is on its way when the port takes the supply counts as switched on, also when it is reported on only after the leave. The output goes off when the port lets go -- a CONNECT that ends without a session after SERVO was left, a STOP that switches the supply off -- unless SERVO is shown again first. After LEAVE on SERVO the output stays on until SERVO is left.

LEAVE PROGRAMMING opens with The port goes back to servo PWM. The supply stays as is. and The servo gets the tester's signal and may move. The page warns before changed values are lost and before a session ends that could still restore a servo in doubt. HOLD TO LEAVE for 2 s sends the port's LEAVE operation of link version 4.15. No frame goes to the servo and no supply command to the PD mini. The port holds its line low for WAIT BEFORE PWM and then gives the pin to the PWM generator.

The page is the same with a PD mini answering.

The state line reads Leaving programming mode. PWM is not on yet. and the tester's controls stay off until the port reports PWM. The button reads ABORT while the wait runs. Then The tester has the port again. and the tester drives the port at once, with PWM TARGET on PROG PORT and PORT PWM on. The next CONNECT starts a new session with its own read.

WAIT BEFORE PWM is 0 to 10 000 ms, 100 ms by default. The keypad takes no value above 10 000 ms, and no leave is sent with one. A wait of 0 ms ends at the coprocessor's next pass. The time left of a running wait is not shown. The wait a servo needs is not measured.

The port refuses a leave while it asks for a read or holds a servo that a write left in doubt.

Without a PD mini STOP switches no supply and leaves the port in programming mode, and a servo that no longer answers takes no read. The panel then sends the port's POWER_CYCLED operation in place of LEAVE. Without a PD mini it changes the port's state only: no frame, no wait, and the servo's supply is whatever feeds it. The record of an interrupted write stays for the next session.

Link versions 4.13 and 4.14 have no LEAVE. The panel sends none to them.

With a PD mini on such a coprocessor, STOP or the supply's output switched off ends the session: the supply stays off for 2000 ms and the port is in PWM again.

Every refusal of the port and every result of the session has its own line. The link page lists the codes.

• A running write shows the count of registers it sets and the frames sent. The register under way is not on the link page and is not shown. A restore of the session's backup and a pairing release show the frames only.
• The screens write us for µs: the font has no micro sign.
• The record of an interrupted write is read from the card when the panel starts, and from a card put in later when the programmer mounts it. A record the panel already holds stands, before and after the servo is read back: the record on such a card is not read then, and the next record written replaces it.
• A card taken out and put back while the panel runs is not mounted again.
• The time a mount attempt without a card holds the screen is not measured.
• The limits and trip settings of the SUPPLY screen are not held while the programmer has the port; the set points and OUTPUT ON are.
• With the coprocessor unpowered and the servo fed from another supply, a servo that drives the signal wire above 3.63 V exceeds the rating of GP13 (the signal level).
• With the simulated supply selected (no PD mini wired) the panel dims the same controls, and the servo's supply is whatever feeds it.
• The rows PWM TARGET and PORT PWM follow the port's state one frame of the screen after the control task does. The control task holds the page of the port and the tester's commands from its own reading of the port.
• The panel's glue in firmware/panel/main/main.c is not in the host suite: the command queue between the screen and the control task, the point where the control task drops a withdrawn command, the hand-over of the port's state to the page and the tester, and the card's file calls.
• Whether a servo follows PWM while it is in programming mode is not measured. The programmer leaves programming without a supply cycle and drives the port with PWM afterwards.
• Whether a written value acts before the servo's next power-up is not measured. The programmer treats a value that reads back as in effect.
• With a PD mini answering and a coprocessor older than link version 4.15, the port is not left from the programmer: STOP or the supply's output switched off ends the session, with the supply off.
• With a PD mini answering, a port that holds a servo in doubt is left by RESTORE and LEAVE, or by STOP with the supply off.
• WAIT BEFORE PWM is not applied by a coprocessor older than link version 4.15, and not on the leave of a port in doubt without a PD mini. The wait a servo needs is not measured. The time left of a running wait is not shown.
• Without a PD mini the programming voltage and the current limit are not applied.
• The error code the card's file system gives for a write-protected card is not known. A code other than read-only file system, access denied and operation not permitted shows Card write error. in place of Card takes no file.
• The proposed names end at KST999. With that name taken the next free number is proposed, and the highest number is then not the latest file.
• A page behind the first 64 files reads the directory once more per 64 files in front of it. The time this takes is not measured; the panel waits 5 s for a page.
• A write without a card leaves no backup file. The session's backup is then the only copy of the servo as found and ends with LEAVE, a coprocessor restart or a power loss of the bench.
• A session's first write with a mounted card needs free space on it.
• A servo file carries the servo type, V6 or V8, and no other identity. A file of one V8 servo loads into any V8 servo.
• A servo file restores the editable fields only: what it does not restore.
• The list shows 5 files a page, sorted by name, and has no search. Files are not removed or renamed on the panel.
• The record of an interrupted write names its port and holds the servo's values. A second servo on that port whose 32 registers equal the image before the write or the image the write was to leave is not told apart from the first: the panel asks, and the answer is the operator's.
• Without a card the record of a write is lost at power off.
• A mounted card that does not take the record stops every write: a card taken out after the mount, a write-protected card, or a card on which KST/KST.TXT or KST/KST.NEW is a folder. Each attempt ends with The card took no file. Nothing was written to the servo. The panel does not unmount such a card. A panel started without a card holds the record in memory and writes.
• The record of a write that ended is cleared on the card after the write, by a file write of its own that is repeated every 5 s until the card takes it. A power loss before it leaves the record of a finished write: at the next read the panel asks whether the servo is the record's.
• The record of an interrupted write found at power-on is shown in the programmer only; no other screen announces it.
• A servo whose image breaks a hard limit as read can be read and saved. A write to it is refused.
• LEFT ANGLE and RIGHT ANGLE are the vendor tool's numbers; their unit is not known.
• The supply voltage a servo needs in programming mode is not measured. The floor is 4.8 V.
• A session has no idle timeout. From CONNECT to LEAVE the port is held, the servo is in programming mode and a PD mini's output is on, on every screen and for as long as the bench is powered. STOP, a link loss and the supply's output switched off end it.
• A card put in while the panel runs is read by the task that draws the screen. The screen does not change and takes no touch for the time of that read. The time is not measured.
• The 120 s an operation is given from its start are chosen. The time the longest write takes on a servo is not measured.

None of these is done.

1. The line's electricals on the port's path: levels of bench and servo, which side holds the line low at idle, the pull-down, the servo's output impedance, and the time both sides drive.
2. The motor's state in programming mode, and whether a written value acts at once.
3. What the servo does with a PWM pulse in programming mode, and with a frame outside it.
4. Persistence: whether a written value survives a power cycle, and whether a commit step exists.
5. Write reliability: 1000 writes with read-back, the count that do not take, the count of registers that change unasked, the spread of the reply delay.
6. The read error rate on a 1 m lead with other servos moving on neighbouring outputs: 100,000 reads.
7. The timing of entry and of exit: how long without power ends programming mode, whether a servo follows PWM after programming without a power cycle, and the wait it needs before the first pulse.
8. The function of each editable setting on a servo that may be lost: position, travel time, stall current, standing current and oscillation against the value.
9. The tolerance of the transmit rate around 25.40 µs a half-cell, and the shortest gap between frames the servo accepts.
10. A second servo of the same type, and other generations: fingerprint, reply timing, half-cell.
11. Open encodings: the NEUTRAL constants, the 2 unconfirmed STRETCH codes, the angle fields in Gyro Servo mode, and whether the vendor tool enforces the ranges it labels.
12. A servo written here is read by the vendor tool with its card.
13. The model of the servo the layout was taken from.
14. Whether 20k_sel separates the servo generations as the type rule assumes: 1 servo is recorded, and no V8 servo has been read.
15. A save, a list and a load on a card: the time each takes against the 5 s limit, and a card removed during a save.

test_prog_link runs the panel's side of the target and of the port's pulse switch: a port without a pin, a target that waits for a bench at rest, a coprocessor that starts again, and a programmer that has the port for each of the 16 pairs of page and wanted values. test_settings runs a held setting against every call that changes one, and test_servo the two rows of the DUT tab. test_kst_card runs the card's side of the files on a card held in memory. test_kst_prog runs the model and test_kst_panel the overlay, both against the coprocessor's port, a supply model and the servo model through the link's dispatcher: the supply's ranges at their ends and one step outside, the wait at 0 ms, 10 000 ms and 10 001 ms as the leave's wait, an abort, a switch to SAFE and a supply that goes off in the wait, a leave on link versions 4.13 and 4.14 with and without a PD mini, STOP during a leave, every limit at its edge, the 2 s holds on both sides of the threshold, every refusal and result with its line in both languages, the lines of the write page for 1 value, for more values than lines and for a value past a soft limit, a soft limit asked again for a value further from the servo's, the horn lines on a later write that moves the horn, the state line and the tab's line of a running write, a message that goes when its condition ends, the rows that take no tap, the PORT row's label, no comma in a number of the German table, a write cut by a link loss, a restart, ABORT and STOP, a card that fails, and the timeouts across the 2^32 ms wrap of the clock. The servo files run against a card model: every name result, every kind of file, both servo types and their mismatch in both directions, every refusal, the 5 s limit, a first write with a card that is full or failing, and the writes without a card: the first write, a restore and a pairing release, a hold released early, a card mounted between two writes and a card removed under the write page. A command the control task takes after its 2 s have passed reaches no wire, for every kind of operation; a refusal at each later exchange of each kind of operation asks for READ ALL; every result code of the session has a class, and a code without one fails the test; a restore that the card keeps from starting at each file step leaves the pending values; a record from a card mounted before and after the read, of the same and of another servo.