Refactor modes, to make it independent of the rest of the code base

Author: adrianscheit2

src/frame.ts

@@ -46,10 +46,6 @@ export class Frame {
         ];
     }
 
-    protected getError(e: any): string {
-        return e.message;
-    }
-
     private getDataAsText(): string {
         if (this.type === 'error') {
             return `Invalid frame: 0x${this.hexData}`;

src/int.spec.ts

@@ -3,7 +3,8 @@ import {RtuModeStrategy} from "./mode/rtu-mode-strategy";
 import {AsciiModeStrategy} from "./mode/ascii-mode-strategy";
 
 export const intTest = (): void => {
-    new RtuModeStrategy(300).receive(new Uint8Array([
+    new RtuModeStrategy(() => {
+    }, 300).receive(new Uint8Array([
         0x11, 0x22, 0x33, 0x44, 0x55, // some mess
         0x04, 0x01, 0x00, 0x0A, 0x00, 0x0D, 0xdd, 0x98, // valid: address & quantity
         0xFF, 0xFF, // valid CRC but invalid frame
@@ -13,7 +14,8 @@ export const intTest = (): void => {
         0x01, 0x10, 0x0F, 0xA3, 0x00, 0x02, 0x04, 0x00, 0x14, 0x07, 0xD0, 0xBB, 0x9A, // valid: expected uint16  20, 2000
     ]));
 
-    new AsciiModeStrategy().receive(Converters.textAsUInt8Array(
+    new AsciiModeStrategy(() => {
+    },).receive(Converters.textAsUInt8Array(
         '&*^&^%^%$*&&%%$#' + // simply totally invalid frame
         ':0401000A000DE4\r\n' + // valid: address & quantity
         'xyz!@=$%#$;' + // simply totally invalid frame

src/main.ts

@@ -1,6 +1,6 @@
 /// <reference types="w3c-web-serial" />
 
-import {ModeStrategy} from "./mode/mode-startegy";
+import {ModeStrategy, ReportType} from "./mode/mode-startegy";
 import {clearSniffingTable, Dom, downloadAllSniffedEntries, insertFrameRow} from "./dom";
 import {Frame} from "./frame";
 import {FunctionCodes} from "./function-codes";
@@ -16,11 +16,15 @@ if (!serial) {
 Dom.clearSnifferButton.addEventListener('click', () => clearSniffingTable());
 Dom.downloadSnifferButton.addEventListener('click', () => downloadAllSniffedEntries());
 
+const getModeReport = (bytes: number[], type: ReportType): void =>
+    insertFrameRow(new Frame(bytes, type));
+
+
 Dom.serialForm.submit = (formData) => {
     formData.baudRate = +formData.baudRate;
     formData.stopBits = formData.parity !== 'none' ? 1 : 2;
     formData.dataBits = formData.mode === 'ASCII' ? 7 : 8;
-    start(formData, formData.mode === 'ASCII' ? new AsciiModeStrategy() : new RtuModeStrategy(formData.baudRate));
+    start(formData, formData.mode === 'ASCII' ? new AsciiModeStrategy(getModeReport) : new RtuModeStrategy(getModeReport, formData.baudRate));
 };
 
 let send: ((bytest: number[]) => Promise<void>) | undefined = undefined;

src/mode/ascii-mode-strategy.ts

@@ -1,12 +1,14 @@
-import {Frame} from "../frame";
 import {Converters} from "../converters";
-import {ModeStrategy, reportFrame} from "./mode-startegy";
+import {ModeStrategy, ReportType} from "./mode-startegy";
 
 export class AsciiModeStrategy implements ModeStrategy {
     frameChars: number[] = [];
     frameBytes: number[] = [];
     currentLrc: number = 0x00;
 
+    constructor(readonly report: (bytes: number[], type: ReportType) => void) {
+    }
+
     receive(data: Uint8Array): void {
         data.forEach((it) => this.frameChars.push(it));
         while (this.frameChars.length >= 2) {
@@ -20,9 +22,9 @@ export class AsciiModeStrategy implements ModeStrategy {
                 } else if (char === 0x0D && char2 === 0x0A) {
                     this.frameBytes.pop();
                     if (!isNaN(this.currentLrc) && (this.currentLrc & 0xff) === 0) {
-                        reportFrame(new Frame(this.frameBytes, ''));
+                        this.report(this.frameBytes, ReportType.valid);
                     } else {
-                        reportFrame(new Frame(this.frameBytes, 'error'));
+                        this.report(this.frameBytes, ReportType.errored);
                     }
                     this.frameBytes = [];
                     this.currentLrc = 0x00;
@@ -39,15 +41,12 @@ export class AsciiModeStrategy implements ModeStrategy {
         let lrc = 0;
         bytes.forEach((byte) => lrc += byte);
         const line = `:${Converters.bytesAsHex(bytes)}${Converters.byteToHex(-lrc & 0xff)}\r\n`;
-        console.log(bytes, line);
-        const result = Converters.textAsUInt8Array(line);
-        //this.receive(result);
-        return result;
+        return Converters.textAsUInt8Array(line);
     }
 
     private resetFrame(): void {
         if (this.frameBytes.length) {
-            reportFrame(new Frame(this.frameBytes, 'error'));
+            this.report(this.frameBytes, ReportType.errored);
             this.frameBytes = [];
             this.currentLrc = 0x00;
         }

src/mode/mode-startegy.ts

@@ -1,13 +1,14 @@
-import {insertFrameRow} from "../dom";
-import {Frame} from "../frame";
-
-export const reportFrame = (frame: Frame): void => {
-    insertFrameRow(frame);
-};
+export enum ReportType {
+    valid = '',
+    errored = 'error',
+    sent = 'send',
+}
 
 export interface ModeStrategy {
     receive(data: Uint8Array): void;
 
     send(bytes: number[]): Uint8Array;
+
+    report(bytes: number[], type: ReportType): void;
 }
 

src/mode/rtu-mode-strategy.ts

@@ -1,5 +1,4 @@
-import {Frame} from "../frame";
-import {ModeStrategy, reportFrame} from "./mode-startegy";
+import {ModeStrategy, ReportType} from "./mode-startegy";
 
 class RtuCrc {
     crc: number = 0xFFFF;
@@ -28,7 +27,7 @@ export class RtuModeStrategy implements ModeStrategy {
     protected timeoutHandler?: any;
     protected timeoutMs: number;
 
-    constructor(baudRate: number) {
+    constructor(readonly report: (bytes: number[], type: ReportType) => void, baudRate: number) {
         this.timeoutMs = 1 + Math.ceil(50 * 1000 / baudRate);
     }
 
@@ -43,17 +42,16 @@ export class RtuModeStrategy implements ModeStrategy {
                 if (this.history[i].updateCrc(byte)) {
                     const bytes = this.history.map((it) => it.byte);
                     if (i) {
-                        reportFrame(new Frame(bytes.slice(0, i), 'error'));
+                        this.report(bytes.slice(0, i), ReportType.errored);
                     }
-                    const validFrame = new Frame(bytes.slice(i, -2), '');
-                    reportFrame(validFrame);
+                    this.report(bytes.slice(i, -2), ReportType.valid);
                     this.history = [];
                     clearTimeout(this.timeoutHandler!);
                     break;
                 }
             }
             if (this.history.length > 2300) {
-                reportFrame(new Frame(this.history.splice(0, 200).map((it) => it.byte), 'error'))
+                this.report(this.history.splice(0, 200).map((it) => it.byte), ReportType.errored);
             }
         });
     }
@@ -63,13 +61,11 @@ export class RtuModeStrategy implements ModeStrategy {
         bytes.forEach((byte) => rtuCrc.updateCrc(byte));
         const firstCrcByte = rtuCrc.crc & 0xff;
         rtuCrc.updateCrc(firstCrcByte);
-        const result = new Uint8Array([...bytes, firstCrcByte, rtuCrc.crc]);
-        //this.receive(result);
-        return result;
+        return new Uint8Array([...bytes, firstCrcByte, rtuCrc.crc]);
     }
 
     private resetFrame(): void {
-        reportFrame(new Frame(this.history.map((it) => it.byte), 'error'));
+        this.report(this.history.map((it) => it.byte), ReportType.errored);
         this.history = [];
     }
 }