Source code

001package jmri.jmrix.bachrus.speedmatcher.basic;
002
003import jmri.DccThrottle;
004import jmri.jmrix.bachrus.Speed;
005
006/**
007 * This is a simple speed matcher which will speed match a locomotive to a given
008 * start and top speed using ESU's complex speed table. Speed steps 1, 10, 19,
009 * and 28 will be set according to values interpolated linearly between the
010 * given start and to speeds. Values for the remaining CVs will interpolated
011 * between these 4 CVs. This is done to reduce the time the speed match takes
012 * and to increase likelihood of success.
013 *
014 * @author Todd Wegter Copyright (C) 2024
015 */
016public class BasicESUTableSpeedMatcher extends BasicSpeedMatcher {
017
018    //<editor-fold defaultstate="collapsed" desc="Constants">
019    private final int INITIAL_VSTART = 1;
020    private final int INITIAL_VHIGH = 255;
021    private final int INITIAL_TRIM = 128;
022    private final int STEP28_VALUE = 255;
023    private final int STEP1_VALUE = 1;
024
025    private final int VHIGH_MAX = 255;
026    private final int VHIGH_MIN = INITIAL_VSTART + 1;
027    private final int STEP19_MIN = 19;
028    private final int STEP10_MIN = 10;
029    private final int VSTART_MIN = 1;
030    //</editor-fold>
031
032    //<editor-fold defaultstate="collapsed" desc="Enums">
033    protected enum SpeedMatcherState {
034        IDLE,
035        WAIT_FOR_THROTTLE,
036        INIT_THROTTLE,
037        INIT_ACCEL,
038        INIT_DECEL,
039        INIT_VSTART,
040        INIT_VHIGH,
041        INIT_SPEED_TABLE,
042        INIT_FORWARD_TRIM,
043        INIT_REVERSE_TRIM,
044        POST_INIT,
045        FORWARD_WARM_UP,
046        FORWARD_SPEED_MATCH_VHIGH,
047        FORWARD_SPEED_MATCH_VSTART,
048        FORWARD_SPEED_MATCH_STEP19,
049        RE_INIT_SPEED_TABLE_MIDDLE_THIRD,
050        FORWARD_SPEED_MATCH_STEP10,
051        INTERPOLATE_SPEED_TABLE,
052        POST_INTERPOLATE,
053        REVERSE_WARM_UP,
054        REVERSE_SPEED_MATCH_TRIM,
055        COMPLETE,
056        USER_STOPPED,
057        CLEAN_UP,
058    }
059    //</editor-fold>
060
061    //<editor-fold defaultstate="collapsed" desc="Instance Variables">
062    private SpeedTableStep initSpeedTableStep;
063    private int initSpeedTableStepValue;
064
065    private SpeedTableStep interpolationSpeedTableStep;
066
067    private int speedMatchCVValue = INITIAL_VHIGH;
068    private int lastSpeedMatchCVValue = INITIAL_VHIGH;
069
070    private int reverseTrimValue = INITIAL_TRIM;
071    private int lastReverseTrimValue = INITIAL_TRIM;
072
073    private final float targetVHighSpeedKPH;
074    private final float targetStep19SpeedKPH;
075    private final float targetStep10SpeedKPH;
076    private final float targetVStartSpeedKPH;
077
078    private int vHigh = INITIAL_VHIGH;
079    private int lastVHigh = INITIAL_VHIGH;
080    private int step19CVValue;
081    private int step10CVValue;
082    private int vStart;
083    private int lastVStart = INITIAL_VSTART;
084    private int vStartMax;
085
086    private SpeedMatcherState speedMatcherState = SpeedMatcherState.IDLE;
087    //</editor-fold>
088
089    /**
090     * Constructs the BasicESUTableSpeedMatcher from a BasicSpeedMatcherConfig
091     * 
092     * @param config BasicSpeedMatcherConfig
093     */
094    public BasicESUTableSpeedMatcher(BasicSpeedMatcherConfig config) {
095        super(config);
096
097        targetVHighSpeedKPH = targetTopSpeedKPH;
098        targetStep19SpeedKPH = getSpeedForSpeedStep(SpeedTableStep.STEP19, targetStartSpeedKPH, targetTopSpeedKPH);
099        targetStep10SpeedKPH = getSpeedForSpeedStep(SpeedTableStep.STEP10, targetStartSpeedKPH, targetTopSpeedKPH);
100        targetVStartSpeedKPH = targetStartSpeedKPH;
101    }
102
103    //<editor-fold defaultstate="collapsed" desc="SpeedMatcher Overrides">
104    /**
105     * Starts the speed matching process
106     *
107     * @return true if speed matching started successfully, false otherwise
108     */
109    @Override
110    public boolean startSpeedMatcher() {
111        if (!validate()) {
112            return false;
113        }
114
115        //reset instance variables
116        speedMatchCVValue = INITIAL_VHIGH;
117        lastSpeedMatchCVValue = INITIAL_VHIGH;
118        reverseTrimValue = INITIAL_TRIM;
119        lastReverseTrimValue = INITIAL_TRIM;
120
121        speedMatcherState = SpeedMatcherState.WAIT_FOR_THROTTLE;
122
123        if (!initializeAndStartSpeedMatcher(e -> speedMatchTimeout())) {
124            cleanUpSpeedMatcher();
125            return false;
126        }
127
128        startStopButton.setText(Bundle.getMessage("SpeedMatchStopBtn"));
129
130        return true;
131    }
132
133    /**
134     * Stops the speed matching process
135     */
136    @Override
137    public void stopSpeedMatcher() {
138        if (!isSpeedMatcherIdle()) {
139            logger.info("Speed matching manually stopped");
140            userStop();
141        } else {
142            cleanUpSpeedMatcher();
143        }
144    }
145
146    /**
147     * Indicates if the speed matcher is idle (not currently speed matching)
148     *
149     * @return true if idle, false otherwise
150     */
151    @Override
152    public boolean isSpeedMatcherIdle() {
153        return speedMatcherState == SpeedMatcherState.IDLE;
154    }
155
156    /**
157     * Cleans up the speed matcher when speed matching is stopped or is finished
158     */
159    @Override
160    protected void cleanUpSpeedMatcher() {
161        speedMatcherState = SpeedMatcherState.IDLE;
162        super.cleanUpSpeedMatcher();
163    }
164    //</editor-fold>
165
166    //<editor-fold defaultstate="collapsed" desc="Speed Matcher State">
167    /**
168     * Main speed matching timeout handler. This is the state machine that
169     * effectively does the speed matching process.
170     */
171    private synchronized void speedMatchTimeout() {
172        switch (speedMatcherState) {
173            case WAIT_FOR_THROTTLE:
174                cleanUpSpeedMatcher();
175                logger.error("Timeout waiting for throttle");
176                statusLabel.setText(Bundle.getMessage("StatusTimeout"));
177                break;
178
179            case INIT_THROTTLE:
180                //set throttle to 0 for init
181                setThrottle(true, 0);
182                initNextSpeedMatcherState(SpeedMatcherState.INIT_ACCEL);
183                break;
184
185            case INIT_ACCEL:
186                //set acceleration momentum to 0 (CV 3)
187                if (programmerState == ProgrammerState.IDLE) {
188                    writeMomentumAccel(INITIAL_MOMENTUM);
189                    initNextSpeedMatcherState(SpeedMatcherState.INIT_DECEL);
190                }
191                break;
192
193            case INIT_DECEL:
194                //set deceleration mementum to 0 (CV 4)
195                if (programmerState == ProgrammerState.IDLE) {
196                    writeMomentumDecel(INITIAL_MOMENTUM);
197                    initNextSpeedMatcherState(SpeedMatcherState.INIT_VSTART);
198                }
199                break;
200
201            case INIT_VSTART:
202                //set vStart to 0 (CV 2)
203                if (programmerState == ProgrammerState.IDLE) {
204                    writeVStart(INITIAL_VSTART);
205                    initNextSpeedMatcherState(SpeedMatcherState.INIT_VHIGH);
206                }
207                break;
208
209            case INIT_VHIGH:
210                //set vHigh to 255 (CV 5)
211                if (programmerState == ProgrammerState.IDLE) {
212                    writeVHigh(INITIAL_VHIGH);
213                    initNextSpeedMatcherState(SpeedMatcherState.INIT_SPEED_TABLE);
214                }
215                break;
216
217            case INIT_SPEED_TABLE:
218                //initialize speed table steps
219                //don't need to set steps 1 or 28 since they are locked to 1 and
220                //255, respectively on ESU decoders
221                if (programmerState == ProgrammerState.IDLE) {
222                    if (stepDuration == 0) {
223                        initSpeedTableStepValue = INITIAL_VSTART;
224                        initSpeedTableStep = SpeedTableStep.STEP2;
225                        stepDuration = 1;
226                    }
227
228                    if (initSpeedTableStep.getSpeedStep() > SpeedTableStep.STEP18.getSpeedStep()) {
229                        initSpeedTableStepValue = INITIAL_VHIGH;
230                    }
231
232                    writeSpeedTableStep(initSpeedTableStep, initSpeedTableStepValue);
233
234                    initSpeedTableStep = initSpeedTableStep.getNext();
235                    if (initSpeedTableStep == SpeedTableStep.STEP28) {
236                        initNextSpeedMatcherState(SpeedMatcherState.INIT_FORWARD_TRIM);
237                    }
238                }
239                break;
240
241            case INIT_FORWARD_TRIM:
242                //set forward trim to 128 (CV 66)
243                if (programmerState == ProgrammerState.IDLE) {
244                    writeForwardTrim(INITIAL_TRIM);
245                    initNextSpeedMatcherState(SpeedMatcherState.INIT_REVERSE_TRIM);
246                }
247                break;
248
249            case INIT_REVERSE_TRIM:
250                //set reverse trim to 128 (CV 95)
251                if (programmerState == ProgrammerState.IDLE) {
252                    writeReverseTrim(INITIAL_TRIM);
253                    initNextSpeedMatcherState(SpeedMatcherState.POST_INIT);
254                }
255                break;
256
257            case POST_INIT: {
258                statusLabel.setText(Bundle.getMessage("StatRestoreThrottle"));
259
260                //un-brick Digitrax decoders
261                setThrottle(false, 0);
262                setThrottle(true, 0);
263
264                SpeedMatcherState nextState;
265                if (warmUpForwardSeconds > 0) {
266                    nextState = SpeedMatcherState.FORWARD_WARM_UP;
267                } else {
268                    nextState = SpeedMatcherState.FORWARD_SPEED_MATCH_VHIGH;
269                }
270                initNextSpeedMatcherState(nextState);
271                break;
272            }
273
274            case FORWARD_WARM_UP:
275                //Run 4 minutes at high speed forward
276                statusLabel.setText(Bundle.getMessage("StatForwardWarmUp", warmUpForwardSeconds - stepDuration));
277
278                if (stepDuration >= warmUpForwardSeconds) {
279                    initNextSpeedMatcherState(SpeedMatcherState.FORWARD_SPEED_MATCH_VHIGH);
280                } else {
281                    if (stepDuration == 0) {
282                        setSpeedMatchStateTimerDuration(5000);
283                        setThrottle(true, 28);
284                    }
285                    stepDuration += 5;
286                }
287                break;
288
289            case FORWARD_SPEED_MATCH_VHIGH:
290                //Use PID Controller to adjust vHigh (Speed Step 28) to the max speed
291                if (programmerState == ProgrammerState.IDLE) {
292                    if (stepDuration == 0) {
293                        statusLabel.setText(Bundle.getMessage("StatSettingSpeed", SpeedMatcherCV.VHIGH.getName()));
294                        logger.info("Setting CV {} to {} KPH ({} MPH)", SpeedMatcherCV.VHIGH.getName(), String.valueOf(targetVHighSpeedKPH), String.valueOf(Speed.kphToMph(targetVHighSpeedKPH)));
295                        setThrottle(true, 28);
296                        setSpeedMatchStateTimerDuration(8000);
297                        stepDuration = 1;
298                    } else {
299                        setSpeedMatchError(targetVHighSpeedKPH);
300
301                        if (Math.abs(speedMatchError) < ALLOWED_SPEED_MATCH_ERROR) {
302                            initNextSpeedMatcherState(SpeedMatcherState.FORWARD_SPEED_MATCH_VSTART);
303                        } else {
304                            vHigh = getNextSpeedMatchValue(lastVHigh, VHIGH_MAX, VHIGH_MIN);
305
306                            if (((lastVHigh == VHIGH_MAX) || (lastVHigh == VHIGH_MIN)) && (vHigh == lastVHigh)) {
307                                statusLabel.setText(Bundle.getMessage("StatSetSpeedFail", SpeedMatcherCV.VHIGH.getName()));
308                                logger.info("Unable to achieve desired speed for CV {}", SpeedMatcherCV.VHIGH.getName());
309                                abort();
310                                break;
311                            }
312
313                            lastVHigh = vHigh;
314                            writeVHigh(vHigh);
315                        }
316                    }
317                }
318                break;
319                
320            case FORWARD_SPEED_MATCH_VSTART:
321                //Use PID Controller to adjust vStart (Speed Step 1) to the min speed
322                if (programmerState == ProgrammerState.IDLE) {
323                    if (stepDuration == 0) {
324                        vStartMax = vHigh - 1;
325                        statusLabel.setText(Bundle.getMessage("StatSettingSpeed", SpeedMatcherCV.VSTART.getName()));
326                        logger.info("Setting CV {} to {} KPH ({} MPH)", SpeedMatcherCV.VSTART.getName(), String.valueOf(targetVStartSpeedKPH), String.valueOf(Speed.kphToMph(targetVStartSpeedKPH)));
327                        setThrottle(true, 1);
328                        setSpeedMatchStateTimerDuration(8000);
329                        stepDuration = 1;
330                    } else {
331                        setSpeedMatchError(targetVStartSpeedKPH);
332
333                        if (Math.abs(speedMatchError) < ALLOWED_SPEED_MATCH_ERROR) {
334                            initNextSpeedMatcherState(SpeedMatcherState.FORWARD_SPEED_MATCH_STEP19);
335                        } else {
336                            vStart = getNextSpeedMatchValue(lastVStart, vStartMax, VSTART_MIN);
337
338                            if (((lastVStart == vStartMax) || (lastVStart == VSTART_MIN)) && (vStart == lastVStart)) {
339                                statusLabel.setText(Bundle.getMessage("StatSetSpeedFail", SpeedMatcherCV.VSTART.getName()));
340                                logger.info("Unable to achieve desired speed for CV {}", SpeedMatcherCV.VSTART.getName());
341                                abort();
342                                break;
343                            }
344
345                            lastVStart = vStart;
346                            writeVStart(vStart);
347                        }
348                    }
349                }
350                break;
351
352            case FORWARD_SPEED_MATCH_STEP19:
353                //Use PID Controller to adjust Speed Step 19 to the interpolated speed
354                if (programmerState == ProgrammerState.IDLE) {
355                    if (stepDuration == 0) {
356                        lastSpeedMatchCVValue = STEP28_VALUE;
357                    }
358                    speedMatchSpeedTableStep(SpeedTableStep.STEP19, targetStep19SpeedKPH, INITIAL_VHIGH, STEP19_MIN, SpeedMatcherState.RE_INIT_SPEED_TABLE_MIDDLE_THIRD);
359                    step19CVValue = speedMatchCVValue;
360                }
361                break;
362
363            case RE_INIT_SPEED_TABLE_MIDDLE_THIRD:
364                //Re-initialize Speed Steps 10-18 based off value for Step 19
365                if (programmerState == ProgrammerState.IDLE) {
366                    if (stepDuration == 0) {
367                        initSpeedTableStep = SpeedTableStep.STEP18;
368                        stepDuration = 1;
369                    }
370
371                    writeSpeedTableStep(initSpeedTableStep, step19CVValue);
372
373                    if (initSpeedTableStep == SpeedTableStep.STEP10) {
374                        initNextSpeedMatcherState(SpeedMatcherState.FORWARD_SPEED_MATCH_STEP10);
375                    } else {
376                        initSpeedTableStep = initSpeedTableStep.getPrevious();
377                    }
378
379                }
380                break;
381
382            case FORWARD_SPEED_MATCH_STEP10:
383                //Use PID Controller to adjust Speed Step 10 to the interpolated speed
384                if (programmerState == ProgrammerState.IDLE) {
385                    if (stepDuration == 0) {
386                        lastSpeedMatchCVValue = step19CVValue;
387                    }
388                    speedMatchSpeedTableStep(SpeedTableStep.STEP10, targetStep10SpeedKPH, step19CVValue - 9, STEP10_MIN, SpeedMatcherState.INTERPOLATE_SPEED_TABLE);
389                    step10CVValue = speedMatchCVValue;
390                }
391                break;
392
393            case INTERPOLATE_SPEED_TABLE: {
394                //Interpolate the values of the intermediate speed steps
395                if (programmerState == ProgrammerState.IDLE) {
396                    if (stepDuration == 0) {
397                        setThrottle(true, 0);
398                        interpolationSpeedTableStep = SpeedTableStep.STEP27;
399                        stepDuration = 1;
400                    }
401
402                    int interpolatedSpeedStepCVValue = getInterpolatedSpeedTableCVValue(interpolationSpeedTableStep);
403                    writeSpeedTableStep(interpolationSpeedTableStep, interpolatedSpeedStepCVValue);
404
405                    do {
406                        interpolationSpeedTableStep = interpolationSpeedTableStep.getPrevious();
407                    } while (interpolationSpeedTableStep == SpeedTableStep.STEP19 || interpolationSpeedTableStep == SpeedTableStep.STEP10);
408
409                    if (interpolationSpeedTableStep == SpeedTableStep.STEP1) {
410                        initNextSpeedMatcherState(SpeedMatcherState.POST_INTERPOLATE);
411                    }
412
413                }
414                break;
415            }
416
417            case POST_INTERPOLATE: {
418                statusLabel.setText(Bundle.getMessage("StatRestoreThrottle"));
419
420                //un-brick Digitrax decoders
421                setThrottle(false, 0);
422                setThrottle(true, 0);
423
424                SpeedMatcherState nextState;
425                if (trimReverseSpeed) {
426                    if (warmUpReverseSeconds > 0) {
427                        nextState = SpeedMatcherState.REVERSE_WARM_UP;
428                    } else {
429                        nextState = SpeedMatcherState.REVERSE_SPEED_MATCH_TRIM;
430                    }
431                } else {
432                    nextState = SpeedMatcherState.COMPLETE;
433                }
434                initNextSpeedMatcherState(nextState);
435                break;
436            }
437
438            case REVERSE_WARM_UP:
439                //Run specified reverse warm up time at high speed in reverse
440                statusLabel.setText(Bundle.getMessage("StatReverseWarmUp", warmUpReverseSeconds - stepDuration));
441
442                if (stepDuration >= warmUpReverseSeconds) {
443                    initNextSpeedMatcherState(SpeedMatcherState.REVERSE_SPEED_MATCH_TRIM);
444                } else {
445                    if (stepDuration == 0) {
446                        setSpeedMatchStateTimerDuration(5000);
447                        setThrottle(false, 28);
448                    }
449                    stepDuration += 5;
450                }
451
452                break;
453
454            case REVERSE_SPEED_MATCH_TRIM:
455                //Use PID controller logic to adjust reverse trim until high speed reverse speed matches forward
456                if (programmerState == ProgrammerState.IDLE) {
457                    if (stepDuration == 0) {
458                        statusLabel.setText(Bundle.getMessage("StatSettingReverseTrim"));
459                        setThrottle(false, 28);
460                        setSpeedMatchStateTimerDuration(8000);
461                        stepDuration = 1;
462                    } else {
463                        setSpeedMatchError(targetTopSpeedKPH);
464
465                        if (Math.abs(speedMatchError) < ALLOWED_SPEED_MATCH_ERROR) {
466                            initNextSpeedMatcherState(SpeedMatcherState.COMPLETE);
467                        } else {
468                            reverseTrimValue = getNextSpeedMatchValue(lastReverseTrimValue, REVERSE_TRIM_MAX, REVERSE_TRIM_MIN);
469
470                            if (((lastReverseTrimValue == REVERSE_TRIM_MAX) || (lastReverseTrimValue == REVERSE_TRIM_MIN)) && (reverseTrimValue == lastReverseTrimValue)) {
471                                statusLabel.setText(Bundle.getMessage("StatSetReverseTrimFail"));
472                                logger.info("Unable to trim reverse to match forward");
473                                abort();
474                                break;
475                            }
476
477                            lastReverseTrimValue = reverseTrimValue;
478                            writeReverseTrim(reverseTrimValue);
479                        }
480                    }
481                }
482                break;
483
484            case COMPLETE:
485                if (programmerState == ProgrammerState.IDLE) {
486                    statusLabel.setText(Bundle.getMessage("StatSpeedMatchComplete"));
487                    setThrottle(true, 0);
488                    initNextSpeedMatcherState(SpeedMatcherState.CLEAN_UP);
489                }
490                break;
491
492            case USER_STOPPED:
493                if (programmerState == ProgrammerState.IDLE) {
494                    statusLabel.setText(Bundle.getMessage("StatUserStoppedSpeedMatch"));
495                    setThrottle(true, 0);
496                    initNextSpeedMatcherState(SpeedMatcherState.CLEAN_UP);
497                }
498                break;
499
500            case CLEAN_UP:
501                //wrap it up
502                if (programmerState == ProgrammerState.IDLE) {
503                    cleanUpSpeedMatcher();
504                }
505                break;
506
507            default:
508                cleanUpSpeedMatcher();
509                logger.error("Unexpected speed match timeout");
510                break;
511        }
512
513        if (speedMatcherState != SpeedMatcherState.IDLE) {
514            startSpeedMatchStateTimer();
515        }
516    }
517    //</editor-fold>
518
519    //<editor-fold defaultstate="collapsed" desc="ThrottleListener Overrides">
520    /**
521     * Called when a throttle is found
522     *
523     * @param t the requested DccThrottle
524     */
525    @Override
526    public void notifyThrottleFound(DccThrottle t) {
527        super.notifyThrottleFound(t);
528
529        if (speedMatcherState == SpeedMatcherState.WAIT_FOR_THROTTLE) {
530            logger.info("Starting speed matching");
531            // using speed matching timer to trigger each phase of speed matching            
532            initNextSpeedMatcherState(SpeedMatcherState.INIT_THROTTLE);
533            startSpeedMatchStateTimer();
534        } else {
535            cleanUpSpeedMatcher();
536        }
537    }
538    //</editor-fold>
539
540    //<editor-fold defaultstate="collapsed" desc="Helper Functions">
541    /**
542     * Gets the interpolated CV value for the given speed step in the speed
543     * table
544     *
545     * @param speedStep the SpeedTableStep to get the speed for
546     * @return the target speed for the given speed step in KPH
547     */
548    private int getInterpolatedSpeedTableCVValue(SpeedTableStep speedStep) {
549        SpeedTableStep maxStep;
550        SpeedTableStep minStep;
551        int maxStepCVValue;
552        int minStepCVValue;
553
554        if (speedStep.getSpeedStep() >= SpeedTableStep.STEP19.getSpeedStep()) {
555            maxStep = SpeedTableStep.STEP28;
556            minStep = SpeedTableStep.STEP19;
557            maxStepCVValue = STEP28_VALUE;
558            minStepCVValue = step19CVValue;
559        } else if (speedStep.getSpeedStep() >= SpeedTableStep.STEP10.getSpeedStep()) {
560            maxStep = SpeedTableStep.STEP19;
561            minStep = SpeedTableStep.STEP10;
562            maxStepCVValue = step19CVValue;
563            minStepCVValue = step10CVValue;
564        } else {
565            maxStep = SpeedTableStep.STEP10;
566            minStep = SpeedTableStep.STEP1;
567            maxStepCVValue = step10CVValue;
568            minStepCVValue = STEP1_VALUE;
569        }
570
571        return Math.round(minStepCVValue + ((((float) (maxStepCVValue - minStepCVValue)) / (maxStep.getSpeedStep() - minStep.getSpeedStep())) * (speedStep.getSpeedStep() - minStep.getSpeedStep())));
572    }
573
574    /**
575     * Helper function for speed matching a given speed step
576     *
577     * @param speedStep      the SpeedTableStep to speed match
578     * @param targetSpeedKPH the target speed in KPH
579     * @param maxCVValue     the maximum allowable value for the CV
580     * @param minCVValue     the minimum allowable value for the CV
581     * @param nextState      the SpeedMatcherState to advance to if speed
582     *                       matching is complete
583     */
584    private void speedMatchSpeedTableStep(SpeedTableStep speedStep, float targetSpeedKPH, int maxCVValue, int minCVValue, SpeedMatcherState nextState) {
585        if (stepDuration == 0) {
586            statusLabel.setText(Bundle.getMessage("StatSettingSpeed", speedStep.getCV() + " (Speed Step " + String.valueOf(speedStep.getSpeedStep()) + ")"));
587            logger.info("Setting CV {} (speed step {}) to {} KPH ({} MPH)", speedStep.getCV(), speedStep.getSpeedStep(), String.valueOf(targetSpeedKPH), String.valueOf(Speed.kphToMph(targetSpeedKPH)));
588            setThrottle(true, speedStep.getSpeedStep());
589            setSpeedMatchStateTimerDuration(8000);
590            stepDuration = 1;
591        } else {
592            setSpeedMatchError(targetSpeedKPH);
593
594            if (Math.abs(speedMatchError) < ALLOWED_SPEED_MATCH_ERROR) {
595                initNextSpeedMatcherState(nextState);
596            } else {
597                speedMatchCVValue = getNextSpeedMatchValue(lastSpeedMatchCVValue, maxCVValue, minCVValue);
598
599                if (((speedMatchCVValue == maxCVValue) || (speedMatchCVValue == minCVValue)) && (speedMatchCVValue == lastSpeedMatchCVValue)) {
600                    statusLabel.setText(Bundle.getMessage("StatSetSpeedFail", speedStep.getCV() + " (Speed Step " + String.valueOf(speedStep.getSpeedStep()) + ")"));
601                    logger.info("Unable to achieve desired speed for CV {} (Speed Step {})", speedStep.getCV(), String.valueOf(speedStep.getSpeedStep()));
602                    abort();
603                    return;
604                }
605
606                lastSpeedMatchCVValue = speedMatchCVValue;
607                writeSpeedTableStep(speedStep, speedMatchCVValue);
608            }
609        }
610    }
611
612    /**
613     * Aborts the speed matching process programmatically
614     */
615    private void abort() {
616        initNextSpeedMatcherState(SpeedMatcherState.CLEAN_UP);
617    }
618
619    /**
620     * Stops the speed matching process due to user input
621     */
622    private void userStop() {
623        initNextSpeedMatcherState(SpeedMatcherState.USER_STOPPED);
624    }
625
626    /**
627     * Sets up the speed match state by clearing the speed match error, clearing
628     * the step duration, setting the timer duration, and setting the next state
629     *
630     * @param nextState - next SpeedMatcherState to set
631     */
632    protected void initNextSpeedMatcherState(SpeedMatcherState nextState) {
633        resetSpeedMatchError();
634        stepDuration = 0;
635        speedMatcherState = nextState;
636        setSpeedMatchStateTimerDuration(1800);
637    }
638    //</editor-fold>
639
640    //debugging logger
641    private final static org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(BasicESUTableSpeedMatcher.class);
642}