├── CmdLine.png
├── README.md
├── SabvotonCommandlineInterface.ino
└── SabvotonRegister.xlsx


/CmdLine.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/slothorpe/SabvotonCommandLineInterface/b0ab4bbcf0b1429a6f23fa882225417baf2940a5/CmdLine.png


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # SabvotonCommandLineInterface
 2 | simple command-line interface for MQ Sabvoton BLDC controller using ModBus-Master library
 3 | 
 4 | This is a sipmle arduino sketch providing a command line interface to the MQ Sabvoton BLDC controller using the ModBus-Master library.
 5 | Also there is a screenshot showing the usage and a spreadsheet with the known registers of the Sabvoton.
 6 | 
 7 | Please be carefull with writing in unknown registers, you might kill your controller !
 8 | 
 9 | Last update:
10 | - minor bugfixes
11 | - added support for small OLED displays with U8GLIB to show the values of all status registers all 500ms
12 | 


--------------------------------------------------------------------------------
/SabvotonCommandlineInterface.ino:
--------------------------------------------------------------------------------
  1 | /* Command-Line Interface für den Sabvoton-Controller
  2 |  * Basis ModbusMaster Library
  3 |  * Holger Lesch, August 2019
  4 |  * holger.lesch@gmx.net
  5 |  * 
  6 |  * last Change: March 2020: oled-display for status registers
  7 |  */
  8 | 
  9 | #include <ModbusMaster.h>
 10 | #include <avr/pgmspace.h>
 11 | 
 12 | #define OLED_DISPLAY
 13 | #ifdef OLED_DISPLAY
 14 | #include "U8glib.h"
 15 | //U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE);  // I2C / TWI 
 16 | U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NO_ACK);
 17 | #endif
 18 | 
 19 | #define LED_PIN 13
 20 | 
 21 | 
 22 | // instantiate ModbusMaster object
 23 | ModbusMaster node;
 24 | 
 25 | #define BUF_LENGTH 128  /* Buffer for the incoming command. */
 26 | static bool do_echo = true;
 27 | static unsigned long lastMillis = 0;
 28 | 
 29 | #define NUM_STAT_REG  26
 30 | uint16_t data[NUM_STAT_REG] ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 31 | 
 32 | #ifdef OLED_DISPLAY
 33 | void u8g_prepare(void) {
 34 |   u8g.setFont(u8g_font_6x10);
 35 |   u8g.setFontRefHeightExtendedText();
 36 |   u8g.setDefaultForegroundColor();
 37 |   u8g.setFontPosTop();
 38 | }
 39 | 
 40 | #define NUM_COLUMNS 5
 41 | 
 42 | void draw(void) {
 43 |    int z,i;
 44 |    char buf[80];
 45 |    u8g_prepare();
 46 |    u8g.drawStr( 0, 0, "Sabvoton CL-Interface");
 47 |    for (z=1;z<=NUM_COLUMNS;z++) {
 48 |       for (i=0;i<NUM_STAT_REG/NUM_COLUMNS;i++) {
 49 |         sprintf (buf,"%04x ",data[i+(z-1)*(NUM_STAT_REG/NUM_COLUMNS)]);
 50 |          u8g.drawStr(i*26,10+(z-1)*11,buf);
 51 |       }
 52 |    }
 53 | }
 54 | #endif
 55 | 
 56 | #define SINGLEFLOAT 54.6
 57 | #define DOUBLEFLOAT 6553.0
 58 |  
 59 | /* Ein Kommando ausführen */
 60 | static void exec(char *cmdline)
 61 | {
 62 |     char *command = strsep(&cmdline, " ");
 63 |     char buf[80];
 64 |     
 65 |     if (strcmp_P(command, PSTR("help")) == 0) {
 66 |         Serial.println(F(
 67 |             "write <register> <value>: writeSingleRegister\r\n"
 68 |             "read <register>: readHoldingRegister\r\n"
 69 |             "dump <startregister> <endregister>: try to read all registers in a range\r\n"
 70 |             "test <register> <startval> <endval> <increment> <delay in ms>: write incremental values to a single register\r\n"
 71 |             "echo <value>: set echo off (0) or on (1)"));
 72 |     } else if (strcmp_P(command, PSTR("write")) == 0) {
 73 |         int reg = atoi(strsep(&cmdline, " "));
 74 |         if (reg == 0 || strlen(cmdline)==0) {
 75 |           Serial.print(F("error: invalid command: "));
 76 |           Serial.println(command);
 77 |           Serial.println("usage: write <register> <value>");
 78 |           return;
 79 |         }
 80 |         int val = atoi(cmdline);
 81 |         int result = node.writeSingleRegister(reg, val);
 82 |         if (result != node.ku8MBSuccess) result = node.writeSingleRegister(reg, val);
 83 |         if (result == node.ku8MBSuccess)
 84 |         {
 85 |           sprintf(buf,"register %d set to %d (0x%04x)",reg, val, val);
 86 |           Serial.println(buf);
 87 |         } else {
 88 |           sprintf(buf,"write error: %02x", result);
 89 |           Serial.println(buf);
 90 |         }
 91 |     } else if (strcmp_P(command, PSTR("read")) == 0) {
 92 |         int reg = atoi(cmdline);
 93 |         if (reg == 0) {
 94 |           Serial.print(F("error: invalid command: "));
 95 |           Serial.println(command);
 96 |           Serial.println("usage: read <register>");
 97 |           return;
 98 |         }
 99 |         int result = node.readHoldingRegisters(reg, 1);
100 |         if (result != node.ku8MBSuccess) result = node.readHoldingRegisters(reg, 1);
101 |         if (result == node.ku8MBSuccess)
102 |         {
103 |           int r = node.getResponseBuffer(0);
104 |           float rf = ((float)r)/SINGLEFLOAT;
105 |           int vk = (int) rf;
106 |           int nk = (int)((rf - ((float)vk)*SINGLEFLOAT)*100);
107 |           float rdf = ((float)r)/DOUBLEFLOAT;
108 |           int vdk = (int) rdf;
109 |           int ndk = (int)((rdf - ((float)vdk)*DOUBLEFLOAT)*100);
110 |           sprintf(buf,"register %d: %d (0x%04x %d.%d %d.%d)",reg, r,r,vk,nk,vdk, ndk);
111 |           Serial.println(buf);
112 |         } else {
113 |           sprintf(buf,"read error: %02x", result);
114 |           Serial.println(buf);
115 |         }
116 |     } else if (strcmp_P(command, PSTR("dump")) == 0) {
117 |         int reg1 = atoi(strsep(&cmdline, " "));
118 |         int reg2 = atoi(cmdline);
119 |         if (reg1 == 0 || reg2==0 || reg1>reg2) {
120 |           Serial.print(F("error: invalid command: "));
121 |           Serial.println(command);
122 |           Serial.println("usage: dump <startregister> <endregister>");
123 |           return;
124 |         }
125 |         int j;
126 |         for (j=reg1; j<=reg2;j++) {
127 |           int result = node.readHoldingRegisters(j, 1);
128 |           if (result != node.ku8MBSuccess) result = node.readHoldingRegisters(j, 1);
129 |           if (result == node.ku8MBSuccess)
130 |           {
131 |             int r = node.getResponseBuffer(0);
132 |             float rf = ((float)r)/SINGLEFLOAT;
133 |             int vk = (int) rf;
134 |             int nk = (int)((rf - ((float)vk)*SINGLEFLOAT)*100);
135 |             float rdf = ((float)r)/DOUBLEFLOAT;
136 |             int vdk = (int) rdf;
137 |             int ndk = (int)((rdf - ((float)vdk)*DOUBLEFLOAT)*100);
138 |             sprintf(buf,"%04d: %d (0x%04x %d.%d %d.%d)",j,r,r,vk,nk,vdk,ndk);
139 |             Serial.println(buf);
140 |           } else {
141 |             //sprintf(buf,"%04d: error",j);
142 |             //Serial.println(buf);
143 |           }
144 |         }
145 |     } else if (strcmp_P(command, PSTR("test")) == 0) {
146 |         int reg = atoi(strsep(&cmdline, " "));
147 |         if (reg == 0 || strlen(cmdline)==0) {
148 |           Serial.print(F("error: invalid command: "));
149 |           Serial.println(command);
150 |           Serial.println("usage: write test <register> <startval> <endval> <increment> <time in ms>");
151 |           return;
152 |         }
153 |         int startval = atoi(strsep(&cmdline, " "));
154 |         int endval = atoi(strsep(&cmdline, " "));
155 |         int incre =  atoi(strsep(&cmdline, " "));
156 |         int dtime = atoi(cmdline);
157 |         if (startval >= endval || incre==0 || dtime ==0) {
158 |           Serial.print(F("error: invalid command: "));
159 |           Serial.println(command);
160 |           Serial.println("usage: test <register> <startval> <endval> <increment> <time in ms>");
161 |           return;
162 |         }
163 |         int i;
164 |         for (i=startval; i<=endval;i+=incre) {
165 |           int result = node.writeSingleRegister(reg, i);
166 |           if (result != node.ku8MBSuccess) result = node.writeSingleRegister(reg, i);
167 |           if (result == node.ku8MBSuccess) {
168 |             sprintf(buf,"register %d set to %d (0x%04x)",reg, i, i);
169 |             Serial.println(buf);
170 |           } else {
171 |             sprintf(buf,"write error: %02x", result);
172 |             Serial.println(buf);
173 |             return;
174 |             }
175 |           delay(dtime);
176 |           }
177 |         } else {
178 |         Serial.print(F("error: unknown command: "));
179 |         Serial.println(command);
180 |     }
181 | }
182 | 
183 | 
184 | // Das MQCON Programm schreibt immer am Anfang drei mal den Wert 13345 in das Register 4039 !?
185 | void startseq()
186 | {
187 |   uint32_t value;
188 |   uint8_t result;
189 |  
190 |   value = 13345;
191 |  
192 |   // slave: write TX buffer to (1) 16-bit registers starting at register 4039
193 |   digitalWrite(LED_PIN,1);
194 |   result = node.writeSingleRegister(4039, value);
195 |   Serial.print(result);
196 |   delay(50);
197 |   result = node.writeSingleRegister(4039, value);
198 |   Serial.print(result);
199 |   delay(50);
200 |   result = node.writeSingleRegister(4039, value);
201 |   Serial.println(result);
202 |   digitalWrite(LED_PIN,0);
203 |   if (result != node.ku8MBSuccess) {
204 |     Serial.println("couldn't send startseq, please connect to Sabvoto controller and restart/reset.");
205 |     while (1);
206 |   }
207 | }
208 | 
209 | void setup()
210 | {
211 |   pinMode(LED_PIN,OUTPUT);
212 |   digitalWrite(LED_PIN,0);
213 |   // use Serial3 (port 3); initialize Modbus communication baud rate
214 |   Serial3.begin(19200,SERIAL_8O1);
215 |   Serial.begin(115200);
216 | 
217 |   // communicate with Modbus slave ID 1 over Serial (port 3)
218 |   node.begin(1, Serial3);
219 | 
220 |   startseq();
221 |   Serial.println("Welcome to the SABVOTON command line interface");
222 |   Serial.println("type help for help");
223 |   Serial.println("");
224 |   Serial.println("Note: in the arduino serial monitor you have to end any commandline with a '.' or activate sending '\\n'");
225 |   Serial.println("");
226 |   Serial.println("PLEASE BE CAREFULL WITH WRITING INTO UNKNOWN REGISTER");
227 |   Serial.println("");
228 |   Serial.print("> ");
229 | }
230 | 
231 | 
232 | void loop()
233 | {
234 |   uint8_t result;
235 |   int j;
236 |   static unsigned long lastMicros;
237 |   
238 |   // Alle 500ms einmal die Statusregister ab 2748 lesen
239 |   if (millis()>lastMillis+500) {
240 |     digitalWrite(LED_PIN,1);
241 |     result = node.readHoldingRegisters(2748, NUM_STAT_REG);
242 |     digitalWrite(LED_PIN,0);
243 |     //Serial.println(result);
244 |     if (result == node.ku8MBSuccess)
245 |     {
246 |       for (j = 0; j < NUM_STAT_REG; j++)
247 |       {
248 |         data[j] = node.getResponseBuffer(j);
249 |         //Serial.print(data[j]);
250 |         //Serial.print(" ");
251 |       }
252 |       //Serial.println();
253 |     } else {
254 |       //Serial.println("read error");
255 |     }
256 |     lastMillis=millis();
257 |   }
258 | 
259 |   // Kommandos entgegen nehmen
260 |   while (Serial.available()) {
261 |         static char buffer[BUF_LENGTH];
262 |         static int length = 0;
263 | 
264 |         int data = Serial.read();
265 |         if (data == '\b' || data == '\177') {  // BS and DEL
266 |             if (length) {
267 |                 length--;
268 |                 if (do_echo) Serial.write("\b \b");
269 |             }
270 |         }
271 |         else if (data == '\r' || data =='.') {
272 |             if (do_echo) Serial.write("\r\n");    // output CRLF
273 |             buffer[length] = '\0';
274 |             if (length) exec(buffer);
275 |             Serial.print("> ");
276 |             length = 0;
277 |         }
278 |         else if (length < BUF_LENGTH - 1) {
279 |             buffer[length++] = data;
280 |             if (do_echo) Serial.write(data);
281 |         }
282 |     }
283 | 
284 | #ifdef OLED_DISPLAY
285 |  // Display-Loop
286 |   u8g.firstPage();  
287 |   do {
288 |     draw();
289 |   } while( u8g.nextPage() );
290 | #endif
291 | }
292 | 


--------------------------------------------------------------------------------
/SabvotonRegister.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/slothorpe/SabvotonCommandLineInterface/b0ab4bbcf0b1429a6f23fa882225417baf2940a5/SabvotonRegister.xlsx


--------------------------------------------------------------------------------