Jon Freeman / Mbed 2 deprecated Alternator2020_06

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   mbed BufferedSerial Servo2 PCT2075 I2CEeprom FastPWM

cli.cpp@5:6ca3e7ffc553, 2020-12-05 (annotated)

Committer:
JonFreeman
Date:
Sat Dec 05 12:40:17 2020 +0000
Revision:
5:6ca3e7ffc553
Parent:
3:43cb067ecd00 
Code for 'Smart Regulator' to August 2020, published as is. Basic low-level functions all thoroughly tested and debugged, top level algorithms have scope for further development - over to you! For help contact jon @ jons-workshop[.com

Who changed what in which revision?

UserRevisionLine numberNew contents of line
JonFreeman 0:77803b3ee157 1 /*
JonFreeman 0:77803b3ee157 2 Command Line Interpreter code module.
JonFreeman 0:77803b3ee157 3 Purpose -
JonFreeman 0:77803b3ee157 4 Provides easy interface to pc terminal programme for use during programme development, debug etc.
JonFreeman 0:77803b3ee157 5 Also usable as comms subsystem in finished code for accepting commands, reporting data etc.
JonFreeman 0:77803b3ee157 6 */
JonFreeman 0:77803b3ee157 7 #include "mbed.h"
JonFreeman 3:43cb067ecd00 8 #include "field.h"
JonFreeman 0:77803b3ee157 9 #include "Alternator.h"
JonFreeman 3:43cb067ecd00 10 #include "BufferedSerial.h"
JonFreeman 0:77803b3ee157 11 #include <cctype>
JonFreeman 0:77803b3ee157 12 using namespace std;
JonFreeman 0:77803b3ee157 13
JonFreeman 3:43cb067ecd00 14 ee_settings_2020 user_settings ;
JonFreeman 0:77803b3ee157 15
JonFreeman 3:43cb067ecd00 16 extern BufferedSerial pc;
JonFreeman 3:43cb067ecd00 17 extern void maketable () ;
JonFreeman 1:450090bdb6f4 18 extern void query_system (struct parameters & a) ;
JonFreeman 0:77803b3ee157 19 extern uint32_t ReadEngineRPM () ;
JonFreeman 3:43cb067ecd00 20 extern double Read_Link_Volts () ;
JonFreeman 3:43cb067ecd00 21 extern double Read_Field_Volts () ;
JonFreeman 3:43cb067ecd00 22 extern double Read_Ammeter () ;
JonFreeman 5:6ca3e7ffc553 23 extern void charge_pump_override (parameters & a) ; // 0 disables, !0 enables charge pump
JonFreeman 5:6ca3e7ffc553 24 extern void set_v_out_opamp (parameters & a) ; // 0 to 1.0 sets opamp output in range 0 to 5v, charge pump permitting
JonFreeman 1:450090bdb6f4 25
JonFreeman 3:43cb067ecd00 26 //bool ee_settings_2020::wr (char c, uint32_t i) { // Write one setup char value to private buffer 'settings'
JonFreeman 3:43cb067ecd00 27 /*
JonFreeman 3:43cb067ecd00 28 void slope_cmd (struct parameters & a) {
JonFreeman 3:43cb067ecd00 29 Provides a quick way of filling lookup table.
JonFreeman 3:43cb067ecd00 30 Sets percent at 3000 RPM with first parameter 0 to 100
JonFreeman 3:43cb067ecd00 31 */
JonFreeman 3:43cb067ecd00 32 void slope_cmd (struct parameters & a) { // Requires two params. First %@ 3000 rpm, second slope MAX +/-20 % per krpm above
JonFreeman 3:43cb067ecd00 33 const int startat = 1800; // rpm to start at
JonFreeman 3:43cb067ecd00 34 const int rpm_per = 200; // rpm per lookup table step
JonFreeman 3:43cb067ecd00 35 const int threshold = startat / rpm_per;
JonFreeman 3:43cb067ecd00 36 signed char at_power_beyond, slope;
JonFreeman 3:43cb067ecd00 37 pc.printf ("Slope - set pct = %d @ 3krpm, slope %d pct above\r\n", (int32_t)a.dbl[0], (int32_t)a.dbl[1]);
JonFreeman 3:43cb067ecd00 38 if (a.numof_dbls != 2)
JonFreeman 3:43cb067ecd00 39 pc.printf ("Need 2 params in slope, got %d, ", a.numof_dbls);
JonFreeman 3:43cb067ecd00 40 else {
JonFreeman 3:43cb067ecd00 41 pc.printf ("Got slope params %.1f, %.1f\r\n", a.dbl[0], a.dbl[1]);
JonFreeman 3:43cb067ecd00 42 if (a.dbl[0] > 100.0) a.dbl[0] = 100.0;
JonFreeman 3:43cb067ecd00 43 if (a.dbl[0] < 0.0) a.dbl[0] = 0.0;
JonFreeman 3:43cb067ecd00 44 if (a.dbl[1] > +20.0) a.dbl[1] = +20.0;
JonFreeman 3:43cb067ecd00 45 if (a.dbl[1] < -20.0) a.dbl[1] = -20.0;
JonFreeman 3:43cb067ecd00 46 at_power_beyond = (signed char)a.dbl[0];
JonFreeman 3:43cb067ecd00 47 slope = (signed char)a.dbl[1];
JonFreeman 3:43cb067ecd00 48 pc.printf ("Setting slope ");
JonFreeman 3:43cb067ecd00 49 for (int i = 0; i < threshold; i++) { // Zero all very low speed settings
JonFreeman 3:43cb067ecd00 50 user_settings.wr (0, i);
JonFreeman 3:43cb067ecd00 51 }
JonFreeman 3:43cb067ecd00 52 for (int i = threshold; i < 21; i++) {
JonFreeman 3:43cb067ecd00 53 user_settings.wr (at_power_beyond, i);
JonFreeman 3:43cb067ecd00 54 pc.printf ("%d, ", at_power_beyond);
JonFreeman 3:43cb067ecd00 55 at_power_beyond += slope;
JonFreeman 3:43cb067ecd00 56 if (at_power_beyond < 0) at_power_beyond = 0;
JonFreeman 3:43cb067ecd00 57 if (at_power_beyond > 100) at_power_beyond = 100;
JonFreeman 3:43cb067ecd00 58 }
JonFreeman 3:43cb067ecd00 59 pc.printf ("\r\nDone\r\n");
JonFreeman 3:43cb067ecd00 60 user_settings.save ();
JonFreeman 3:43cb067ecd00 61 maketable ();
JonFreeman 3:43cb067ecd00 62 }
JonFreeman 3:43cb067ecd00 63 }
JonFreeman 2:8e7b51353f32 64
JonFreeman 3:43cb067ecd00 65 void table_tweak_cmd (struct parameters & a) { // Requires two params. First '20', '22' etc representing hundreds RPM. Second 0 to 99 percent
JonFreeman 2:8e7b51353f32 66 char txt[100];
JonFreeman 2:8e7b51353f32 67 uint32_t d[3];
JonFreeman 2:8e7b51353f32 68 txt[0] = 0;
JonFreeman 2:8e7b51353f32 69 if (a.numof_dbls != 2)
JonFreeman 2:8e7b51353f32 70 sprintf (txt, "Need 2 params, got %d, ", a.numof_dbls);
JonFreeman 2:8e7b51353f32 71 else {
JonFreeman 2:8e7b51353f32 72 d[2] = (uint32_t)a.dbl[0];
JonFreeman 3:43cb067ecd00 73 d[0] = d[2] / 2;
JonFreeman 2:8e7b51353f32 74 d[1] = (uint32_t)a.dbl[1];
JonFreeman 3:43cb067ecd00 75 if (d[0] > 20 || d[1] > 100 || d[2] != d[0] * 2)
JonFreeman 2:8e7b51353f32 76 sprintf (txt + strlen(txt), "Param out of range %d, %d, ", d[2], d[1]);
JonFreeman 2:8e7b51353f32 77 else {
JonFreeman 2:8e7b51353f32 78 pc.printf ("Off to reset table %d RPM, %d percent\r\n", d[2] * 100, d[1]);
JonFreeman 2:8e7b51353f32 79 user_settings.wr ((char)d[1], d[0]);
JonFreeman 2:8e7b51353f32 80 user_settings.save ();
JonFreeman 2:8e7b51353f32 81 maketable ();
JonFreeman 2:8e7b51353f32 82 }
JonFreeman 2:8e7b51353f32 83 }
JonFreeman 2:8e7b51353f32 84 if (txt[0])
JonFreeman 2:8e7b51353f32 85 pc.printf ("Errors in table_tweak_cmd - %s\r\n", txt);
JonFreeman 2:8e7b51353f32 86 else
JonFreeman 2:8e7b51353f32 87 pc.printf ("Good in table_tweak_cmd, RPM=%d, percentage=%d\r\n", d[0] * 500, d[1]);
JonFreeman 2:8e7b51353f32 88 }
JonFreeman 0:77803b3ee157 89
JonFreeman 3:43cb067ecd00 90
JonFreeman 3:43cb067ecd00 91 //extern VEXT_Data Field;
JonFreeman 3:43cb067ecd00 92 extern FieldControl Field;
JonFreeman 3:43cb067ecd00 93
JonFreeman 3:43cb067ecd00 94 extern int32_t set_engine_RPM_lit (uint32_t RPMrequest) ; // Returns speed error pos or neg
JonFreeman 3:43cb067ecd00 95 extern int32_t set_engine_RPM_pct (uint32_t RPMrequest) ; // Returns speed error pos or neg
JonFreeman 3:43cb067ecd00 96 void ss_cmd (struct parameters & a) { // Set engine Speed 0 - 8000 RPM
JonFreeman 3:43cb067ecd00 97 uint32_t v = (uint32_t) a.dbl[0];
JonFreeman 3:43cb067ecd00 98 pc.printf ("Setting engine RPM to %d, measured RPM returned = %d\r\n", v, set_engine_RPM_lit (v));
JonFreeman 3:43cb067ecd00 99 }
JonFreeman 0:77803b3ee157 100
JonFreeman 3:43cb067ecd00 101 void sp_cmd (struct parameters & a) { // Set engine Speed 0 - 8000 RPM
JonFreeman 3:43cb067ecd00 102 uint32_t v = (uint32_t) a.dbl[0];
JonFreeman 3:43cb067ecd00 103 pc.printf ("Setting engine RPM percent to %d, measured RPM returned = %d\r\n", v, set_engine_RPM_pct (v));
JonFreeman 3:43cb067ecd00 104 }
JonFreeman 3:43cb067ecd00 105
JonFreeman 3:43cb067ecd00 106 void rfcmd (struct parameters & a) { //
JonFreeman 3:43cb067ecd00 107 // pc.printf ("Field.measured_period = %u", (uint32_t)Field.get_measured_period());
JonFreeman 3:43cb067ecd00 108 // pc.printf (", Field.measured_pw_us = %u, duty_cycle = %.3f\r\n", (uint32_t)Field.measured_pw_us, Field.duty_cycle());
JonFreeman 3:43cb067ecd00 109 pc.printf ("Field duty cycle measured = %.3f\r\n", Field.get_duty_ratio());
JonFreeman 3:43cb067ecd00 110 }
JonFreeman 3:43cb067ecd00 111
JonFreeman 3:43cb067ecd00 112 void vcmd (struct parameters & a) {
JonFreeman 3:43cb067ecd00 113 pc.printf ("link volts %.2f, field volts %.2f\r\n", Read_Link_Volts(), Read_Field_Volts());
JonFreeman 3:43cb067ecd00 114 }
JonFreeman 3:43cb067ecd00 115
JonFreeman 3:43cb067ecd00 116 void acmd (struct parameters & a) {
JonFreeman 3:43cb067ecd00 117 pc.printf ("amps %.2f\r\n", Read_Ammeter());
JonFreeman 3:43cb067ecd00 118 }
JonFreeman 3:43cb067ecd00 119
JonFreeman 1:450090bdb6f4 120
JonFreeman 3:43cb067ecd00 121 extern void set_pwm (double) ; // Range 0.0 to 1.0
JonFreeman 3:43cb067ecd00 122 void fls_cmd (struct parameters & a) {
JonFreeman 3:43cb067ecd00 123 pc.printf ("Setting field.limiter to %d percent\r\n", (int)a.dbl[0]);
JonFreeman 3:43cb067ecd00 124 set_pwm (a.dbl[0] / 100.0);
JonFreeman 3:43cb067ecd00 125 }
JonFreeman 3:43cb067ecd00 126
JonFreeman 3:43cb067ecd00 127 void set_defaults_cmd (struct parameters & a) {
JonFreeman 3:43cb067ecd00 128 struct sldandt * p = NULL;
JonFreeman 3:43cb067ecd00 129 bool flag = true;
JonFreeman 3:43cb067ecd00 130 int i = 0;
JonFreeman 3:43cb067ecd00 131 while (flag) {
JonFreeman 3:43cb067ecd00 132 p = user_settings.inform(i); // Returns NULL when i goes out of range
JonFreeman 3:43cb067ecd00 133 if (p == NULL)
JonFreeman 3:43cb067ecd00 134 flag = false;
JonFreeman 3:43cb067ecd00 135 else {
JonFreeman 3:43cb067ecd00 136 pc.printf ("min %d, max %d, default %d, text %s\r\n", p->min, p->max, p->de_fault, p->txt);
JonFreeman 3:43cb067ecd00 137 user_settings.wr (p->de_fault, i);
JonFreeman 3:43cb067ecd00 138 i++;
JonFreeman 3:43cb067ecd00 139 }
JonFreeman 0:77803b3ee157 140 }
JonFreeman 3:43cb067ecd00 141 user_settings.save ();
JonFreeman 3:43cb067ecd00 142 }
JonFreeman 0:77803b3ee157 143
JonFreeman 3:43cb067ecd00 144 void servodir_cmd (struct parameters & a) {
JonFreeman 3:43cb067ecd00 145 char ch = (char)a.dbl[0];
JonFreeman 3:43cb067ecd00 146 if (a.numof_dbls != 1 || ch > 1) {
JonFreeman 3:43cb067ecd00 147 pc.printf ("Wrong servodir set\r\n");
JonFreeman 3:43cb067ecd00 148 return ;
JonFreeman 3:43cb067ecd00 149 }
JonFreeman 3:43cb067ecd00 150 if (user_settings.rd(SERVO_DIR) != ch) {
JonFreeman 3:43cb067ecd00 151 pc.printf ("Setting servo dir %.1f \r\n", a.dbl[0]);
JonFreeman 3:43cb067ecd00 152 user_settings.wr(ch, SERVO_DIR);
JonFreeman 3:43cb067ecd00 153 user_settings.save();
JonFreeman 3:43cb067ecd00 154 }
JonFreeman 0:77803b3ee157 155 }
JonFreeman 0:77803b3ee157 156
JonFreeman 3:43cb067ecd00 157 char * modes_txt[] = {
JonFreeman 3:43cb067ecd00 158 "0\tSafe nothing mode for cli cmd testing",
JonFreeman 3:43cb067ecd00 159 "1\tPot to Servo direct, field OFF",
JonFreeman 3:43cb067ecd00 160 "2\tVariable voltage",
JonFreeman 3:43cb067ecd00 161 "3\tFixed voltage",
JonFreeman 3:43cb067ecd00 162 "4\tEngine Revs Control",
JonFreeman 3:43cb067ecd00 163 "5\tSet Engine to Driver's Pot",
JonFreeman 3:43cb067ecd00 164 "6\tControl Engine by Current Load",
JonFreeman 3:43cb067ecd00 165 "7\tAuto Test",
JonFreeman 3:43cb067ecd00 166 } ;
JonFreeman 3:43cb067ecd00 167
JonFreeman 3:43cb067ecd00 168 int numof_op_modes = sizeof(modes_txt) / sizeof(char *);
JonFreeman 0:77803b3ee157 169
JonFreeman 3:43cb067ecd00 170 char * get_mode_text (uint32_t mode) {
JonFreeman 3:43cb067ecd00 171 if (mode > numof_op_modes) {
JonFreeman 3:43cb067ecd00 172 pc.printf ("mode OOR in get_mode_text, %d\r\n", mode);
JonFreeman 3:43cb067ecd00 173 mode = numof_op_modes - 1;
JonFreeman 3:43cb067ecd00 174 }
JonFreeman 3:43cb067ecd00 175 return modes_txt[mode];
JonFreeman 3:43cb067ecd00 176 }
JonFreeman 1:450090bdb6f4 177
JonFreeman 3:43cb067ecd00 178 void mode20_cmd (struct parameters & a) ;
JonFreeman 3:43cb067ecd00 179 void mode_cmd (struct parameters & a) {
JonFreeman 3:43cb067ecd00 180 if (a.numof_dbls == 1 && (uint32_t) a.dbl[0] <= numof_op_modes) {
JonFreeman 3:43cb067ecd00 181 a.dbl[1] = a.dbl[0];
JonFreeman 3:43cb067ecd00 182 a.dbl[0] = OP_MODE; //23.0;
JonFreeman 3:43cb067ecd00 183 a.numof_dbls = 2;
JonFreeman 3:43cb067ecd00 184 mode20_cmd (a);
JonFreeman 3:43cb067ecd00 185 return;
JonFreeman 3:43cb067ecd00 186 }
JonFreeman 3:43cb067ecd00 187 pc.printf ("Current mode is %d \r\nTo set operating mode, use mode n :- where \r\n", user_settings.rd(OP_MODE));
JonFreeman 3:43cb067ecd00 188 for (int i = 0; i < numof_op_modes; i++)
JonFreeman 3:43cb067ecd00 189 pc.printf ("%s\r\n", get_mode_text(i));
JonFreeman 0:77803b3ee157 190 }
JonFreeman 0:77803b3ee157 191
JonFreeman 3:43cb067ecd00 192 void mode20_cmd (struct parameters & a) {
JonFreeman 3:43cb067ecd00 193 struct sldandt * p = NULL; // Pointer to struct containing max, min and default values, and brief text descriptor for a command
JonFreeman 3:43cb067ecd00 194 int i = 0;
JonFreeman 3:43cb067ecd00 195 bool flag = true;
JonFreeman 3:43cb067ecd00 196 bool save_settings = false;
JonFreeman 3:43cb067ecd00 197 int32_t cmd_num = (int32_t) a.dbl[0], first_p = (int32_t) a.dbl[1];
JonFreeman 3:43cb067ecd00 198 pc.printf ("At user setting, numofparams = %d, dbl[0]=%.2f, dbl[1]=%.2f\r\n", a.numof_dbls, a.dbl[0], a.dbl[1]);
JonFreeman 3:43cb067ecd00 199 if (a.numof_dbls < 2) { // Need at least command number followed by at least one parameter
JonFreeman 3:43cb067ecd00 200 pc.printf ("Listing Setup\r\nTo alter, enter us param number, new value\r\n");
JonFreeman 3:43cb067ecd00 201 while (flag) {
JonFreeman 3:43cb067ecd00 202 p = user_settings.inform(i); // Returns false when i goes out of range
JonFreeman 3:43cb067ecd00 203 if (p == NULL)
JonFreeman 3:43cb067ecd00 204 flag = false;
JonFreeman 3:43cb067ecd00 205 else {
JonFreeman 3:43cb067ecd00 206 pc.printf ("%d\tval %d, min %d, max %d, default %d, text %s\r\n", i, user_settings.rd(i), p->min, p->max, p->de_fault, p->txt);
JonFreeman 3:43cb067ecd00 207 i++;
JonFreeman 3:43cb067ecd00 208 }
JonFreeman 3:43cb067ecd00 209 }
JonFreeman 3:43cb067ecd00 210 return ;
JonFreeman 3:43cb067ecd00 211 } // When too few parameters, output list. Done.
JonFreeman 3:43cb067ecd00 212 p = user_settings.inform(cmd_num); // Set pointer to min, max, default and text info
JonFreeman 3:43cb067ecd00 213 if (p == NULL) {
JonFreeman 3:43cb067ecd00 214 pc.printf ("Invalid command number %d in user setting entry\r\n", cmd_num);
JonFreeman 3:43cb067ecd00 215 return ;
JonFreeman 3:43cb067ecd00 216 }
JonFreeman 3:43cb067ecd00 217 if (first_p < p->min || first_p > p->max) {
JonFreeman 3:43cb067ecd00 218 pc.printf ("%s\r\nParameter min %d, max %d, you entered %d. Not setting\r\n", p->txt, p->min, p->max, first_p);
JonFreeman 3:43cb067ecd00 219 return ;
JonFreeman 3:43cb067ecd00 220 }
JonFreeman 3:43cb067ecd00 221 pc.printf ("Hoping to set [%s] to %d\r\n", p->txt, first_p);
JonFreeman 3:43cb067ecd00 222 switch (cmd_num) {
JonFreeman 3:43cb067ecd00 223 case OP_MODE: //
JonFreeman 3:43cb067ecd00 224 case WARM_UP_DELAY:
JonFreeman 3:43cb067ecd00 225 case WARMUP_SERVO_POS:
JonFreeman 3:43cb067ecd00 226 case SPEED_CTRL_P:
JonFreeman 3:43cb067ecd00 227 case SERVO_DIR:
JonFreeman 3:43cb067ecd00 228 i = user_settings.rd(cmd_num);
JonFreeman 3:43cb067ecd00 229 if (i == first_p)
JonFreeman 3:43cb067ecd00 230 pc.printf ("No need, [%s] already set to %d\r\n", p->txt, i);
JonFreeman 3:43cb067ecd00 231 else {
JonFreeman 3:43cb067ecd00 232 user_settings.wr((char)first_p, cmd_num);
JonFreeman 3:43cb067ecd00 233 save_settings = true;
JonFreeman 3:43cb067ecd00 234 pc.printf ("Setting [%s] to %d\r\n", p->txt, first_p);
JonFreeman 3:43cb067ecd00 235 }
JonFreeman 3:43cb067ecd00 236 break;
JonFreeman 3:43cb067ecd00 237 default:
JonFreeman 3:43cb067ecd00 238 pc.printf ("No code for [%s]\r\n", p->txt);
JonFreeman 3:43cb067ecd00 239 break;
JonFreeman 3:43cb067ecd00 240 }
JonFreeman 3:43cb067ecd00 241 if (save_settings)
JonFreeman 3:43cb067ecd00 242 user_settings.save();
JonFreeman 0:77803b3ee157 243 }
JonFreeman 0:77803b3ee157 244
JonFreeman 3:43cb067ecd00 245 extern void auto_test_initiate (int bulb_count) ;
JonFreeman 3:43cb067ecd00 246 void auto_test_kickoff_cmd (struct parameters & a) {
JonFreeman 3:43cb067ecd00 247 auto_test_initiate ((int)a.dbl[0]);
JonFreeman 0:77803b3ee157 248 }
JonFreeman 0:77803b3ee157 249
JonFreeman 3:43cb067ecd00 250 void test_Fsfs_cmd (struct parameters & a) {
JonFreeman 3:43cb067ecd00 251 uint32_t rpm = (uint32_t)a.dbl[0];
JonFreeman 3:43cb067ecd00 252 pc.printf ("Field.set_for_speed %d returned %d\r\n", rpm, Field.set_for_speed(rpm));
JonFreeman 1:450090bdb6f4 253 }
JonFreeman 1:450090bdb6f4 254
JonFreeman 0:77803b3ee157 255 void null_cmd (struct parameters & a) {
JonFreeman 0:77803b3ee157 256 pc.printf ("At null_cmd, parameters : First %.3f, second %.3f\r\n", a.dbl[0], a.dbl[1]);
JonFreeman 0:77803b3ee157 257 }
JonFreeman 0:77803b3ee157 258
JonFreeman 0:77803b3ee157 259 void menucmd (struct parameters & a);
JonFreeman 0:77803b3ee157 260
JonFreeman 0:77803b3ee157 261 struct kb_command {
JonFreeman 0:77803b3ee157 262 const char * cmd_word; // points to text e.g. "menu"
JonFreeman 0:77803b3ee157 263 const char * explan;
JonFreeman 0:77803b3ee157 264 void (*f)(struct parameters &); // points to function
JonFreeman 0:77803b3ee157 265 } ;
JonFreeman 0:77803b3ee157 266
JonFreeman 0:77803b3ee157 267 struct kb_command const command_list[] = {
JonFreeman 0:77803b3ee157 268 {"?", "Lists available commands, same as ls", menucmd},
JonFreeman 5:6ca3e7ffc553 269 {"cp", "Charge pump disable (0), enable (!0)", charge_pump_override},
JonFreeman 5:6ca3e7ffc553 270 {"vo", "Set out volts to ESC 0 - 100 pct", set_v_out_opamp},
JonFreeman 3:43cb067ecd00 271 {"ft", "Test Field.set_for_speed fn", test_Fsfs_cmd},
JonFreeman 3:43cb067ecd00 272 {"at", "Initiate Auto Test sequence", auto_test_kickoff_cmd},
JonFreeman 3:43cb067ecd00 273 {"svod", "Set servo sense 0 or 1", servodir_cmd},
JonFreeman 3:43cb067ecd00 274 {"sd", "Set User Settings Defaults", set_defaults_cmd},
JonFreeman 3:43cb067ecd00 275 {"us", "Set User Settings", mode20_cmd},
JonFreeman 3:43cb067ecd00 276 {"tt", "Table Tweak 0 - 100", table_tweak_cmd},
JonFreeman 3:43cb067ecd00 277 {"ss", "Set Speed 0 - 8000 RPM", ss_cmd},
JonFreeman 3:43cb067ecd00 278 {"sp", "Set Speed 0 - 100 percent", sp_cmd},
JonFreeman 3:43cb067ecd00 279 // {"tl", "Throttle logger tester, enter param 0.0 - 1.0", throt_log_cmd},
JonFreeman 0:77803b3ee157 280 {"rf", "Check rise and fall on VEXT", rfcmd},
JonFreeman 0:77803b3ee157 281 {"v", "Read Battery volts", vcmd},
JonFreeman 3:43cb067ecd00 282 {"i", "Read Ammeter", acmd},
JonFreeman 3:43cb067ecd00 283 {"fl", "Field limiter set 0 to 99 percent", fls_cmd},
JonFreeman 3:43cb067ecd00 284 {"mode", "Set operating mode - as us23", mode_cmd},
JonFreeman 3:43cb067ecd00 285 {"slope", "Field limiter set pct 0 to 99 @3k, slope pct per k above", slope_cmd},
JonFreeman 1:450090bdb6f4 286 {"q", "Query system - toggle message stream on/off", query_system},
JonFreeman 0:77803b3ee157 287 {"nu", "do nothing", null_cmd},
JonFreeman 0:77803b3ee157 288 };
JonFreeman 0:77803b3ee157 289
JonFreeman 0:77803b3ee157 290 const int numof_menu_items = sizeof(command_list) / sizeof(kb_command);
JonFreeman 0:77803b3ee157 291 void menucmd (struct parameters & a)
JonFreeman 0:77803b3ee157 292 {
JonFreeman 1:450090bdb6f4 293 pc.printf("\r\nIntelligent Alternator Controller - Jon Freeman 2020\r\nAt menucmd function - listing commands:-\r\n");
JonFreeman 0:77803b3ee157 294 for(int i = 0; i < numof_menu_items; i++)
JonFreeman 0:77803b3ee157 295 pc.printf("[%s]\t\t%s\r\n", command_list[i].cmd_word, command_list[i].explan);
JonFreeman 0:77803b3ee157 296 pc.printf("End of List of Commands\r\n");
JonFreeman 0:77803b3ee157 297 }
JonFreeman 0:77803b3ee157 298
JonFreeman 0:77803b3ee157 299 void command_line_interpreter ()
JonFreeman 0:77803b3ee157 300 {
JonFreeman 1:450090bdb6f4 301
JonFreeman 0:77803b3ee157 302 const int MAX_CMD_LEN = 120;
JonFreeman 0:77803b3ee157 303 static char cmd_line[MAX_CMD_LEN + 4];
JonFreeman 0:77803b3ee157 304 static int cl_index = 0;
JonFreeman 0:77803b3ee157 305 int ch;
JonFreeman 0:77803b3ee157 306 char * pEnd;
JonFreeman 0:77803b3ee157 307 static struct parameters param_block ;
JonFreeman 0:77803b3ee157 308 while (pc.readable()) {
JonFreeman 0:77803b3ee157 309 ch = tolower(pc.getc());
JonFreeman 0:77803b3ee157 310 // pc.printf("%c", ch);
JonFreeman 0:77803b3ee157 311 if (cl_index > MAX_CMD_LEN) { // trap out stupidly long command lines
JonFreeman 0:77803b3ee157 312 pc.printf ("Error!! Stupidly long cmd line\r\n");
JonFreeman 0:77803b3ee157 313 cl_index = 0;
JonFreeman 0:77803b3ee157 314 }
JonFreeman 0:77803b3ee157 315 if (ch == '\r' || ch >= ' ' && ch <= 'z')
JonFreeman 0:77803b3ee157 316 pc.printf("%c", ch);
JonFreeman 0:77803b3ee157 317 else { // Using <Ctrl>+ 'F', 'B' for Y, 'L', 'R' for X, 'U', 'D' for Z
JonFreeman 0:77803b3ee157 318 cl_index = 0; // 6 2 12 18 21 4
JonFreeman 0:77803b3ee157 319 pc.printf("[%d]", ch);
JonFreeman 0:77803b3ee157 320 //nudger (ch); // was used on cnc to nudge axes a tad
JonFreeman 0:77803b3ee157 321 }
JonFreeman 0:77803b3ee157 322 if(ch != '\r') // was this the 'Enter' key?
JonFreeman 0:77803b3ee157 323 cmd_line[cl_index++] = ch; // added char to command being assembled
JonFreeman 0:77803b3ee157 324 else { // key was CR, may or may not be command to lookup
JonFreeman 0:77803b3ee157 325 cmd_line[cl_index] = 0; // null terminate command string
JonFreeman 0:77803b3ee157 326 if(cl_index) { // If have got some chars to lookup
JonFreeman 0:77803b3ee157 327 int i, wrdlen;
JonFreeman 0:77803b3ee157 328 for (i = 0; i < numof_menu_items; i++) { // Look for input match in command list
JonFreeman 0:77803b3ee157 329 wrdlen = strlen(command_list[i].cmd_word);
JonFreeman 0:77803b3ee157 330 if(strncmp(command_list[i].cmd_word, cmd_line, wrdlen) == 0 && !isalpha(cmd_line[wrdlen])) { // If match found
JonFreeman 0:77803b3ee157 331 for (int k = 0; k < MAX_PARAMS; k++) {
JonFreeman 0:77803b3ee157 332 param_block.dbl[k] = 0.0;
JonFreeman 0:77803b3ee157 333 }
JonFreeman 0:77803b3ee157 334 param_block.position_in_list = i;
JonFreeman 3:43cb067ecd00 335 //param_block.last_time = clock ();
JonFreeman 0:77803b3ee157 336 param_block.numof_dbls = 0;
JonFreeman 0:77803b3ee157 337 pEnd = cmd_line + wrdlen;
JonFreeman 0:77803b3ee157 338 while (*pEnd) { // Assemble all numerics as doubles
JonFreeman 0:77803b3ee157 339 param_block.dbl[param_block.numof_dbls++] = strtod (pEnd, &pEnd);
JonFreeman 0:77803b3ee157 340 while (*pEnd && !isdigit(*pEnd) && '-' != *pEnd && '+' != *pEnd) {
JonFreeman 0:77803b3ee157 341 pEnd++;
JonFreeman 0:77803b3ee157 342 }
JonFreeman 0:77803b3ee157 343 }
JonFreeman 0:77803b3ee157 344 pc.printf ("\r\n");
JonFreeman 0:77803b3ee157 345 // for (int k = 0; k < param_block.numof_dbls; k++)
JonFreeman 0:77803b3ee157 346 // pc.printf ("Read %.3f\r\n", param_block.dbl[k]);
JonFreeman 3:43cb067ecd00 347 // param_block.times[i] = clock();
JonFreeman 0:77803b3ee157 348 command_list[i].f(param_block); // execute command
JonFreeman 0:77803b3ee157 349 i = numof_menu_items + 1; // to exit for loop
JonFreeman 0:77803b3ee157 350 } // end of match found
JonFreeman 0:77803b3ee157 351 } // End of for numof_menu_items
JonFreeman 0:77803b3ee157 352 if(i == numof_menu_items)
JonFreeman 0:77803b3ee157 353 pc.printf("No Match Found for CMD [%s]\r\n", cmd_line);
JonFreeman 0:77803b3ee157 354 } // End of If have got some chars to lookup
JonFreeman 0:77803b3ee157 355 pc.printf("\r\n>");
JonFreeman 0:77803b3ee157 356 cl_index = 0;
JonFreeman 0:77803b3ee157 357 } // End of else key was CR, may or may not be command to lookup
JonFreeman 0:77803b3ee157 358 } // End of while (pc.readable())
JonFreeman 1:450090bdb6f4 359
JonFreeman 0:77803b3ee157 360 }
JonFreeman 0:77803b3ee157 361
JonFreeman 0:77803b3ee157 362