Method processByte

src/frontend/swo/core.ts:94–176

(byte: number)

    }

    public processByte(byte: number) {
        let newStatus: Status = this.status;

        if (this.checkSync(byte)) { // check for completed sync
            newStatus = Status.IDLE;
            this.emit('synchronized');
        }
        else {
            switch (this.status) {
                case Status.IDLE:
                    if (byte === 0x00) { break; } // Sync Packet
                    else if (byte === 0b01110000) { this.emit('overflow'); }
                    else if ((byte & TIMESTAMP_MASK) === 0x00) {
                        this.timestamp = 0;
                        this.resetRxPacket(-1, 5, PacketType.TIMESTAMP);
                        this.rxWriteByte(byte);
                                                
                        if (byte & 0x80) {
                            newStatus = Status.TIMESTAMP;
                        }
                        else {
                            this.emit('timestamp', this.getRxPacket());
                        }
                    }
                    else if ((byte & LENGTH_MASK) !== 0x00) {
                        let count = byte & 0x03;
                        if (count === 3) { count = 4; }

                        const port = (byte & PORT_MASK) >>> 3;
                        
                        if ((byte & HARDWARE_MASK) !== 0) {
                            this.resetRxPacket(port, count, PacketType.HARDWARE);
                            newStatus = Status.HARDWARE_EVENT;
                        }
                        else {
                            this.resetRxPacket(port, count, PacketType.SOFTWARE);
                            newStatus = Status.SOFTWARE_EVENT;
                        }
                    }
                    else {
                        newStatus = Status.RESERVED;
                        this.emit('lost-synchronization');
                    }
                    break;
                case Status.TIMESTAMP:
                    const receivedMax = this.rxWriteByte(byte);
                    // Check if the continuation bit is false.
                    // This indicates the last byte in a timestamp
                    if ((byte & 0x80) === 0x00) {
                        this.emit('timestamp', this.getRxPacket());
                        newStatus = Status.IDLE;
                    } else if (receivedMax) {
                        // A timestamp is at most 5 packets. If we didn't see the continuation bit false, something has gone wrong
                        // This often happens with PeMicro because it starts sending garbage after a clock change.
                        // In theory we should go to UNSYNCED, but that leads to never recovering.
                        // Going back to IDLE allows recovery when it stops sending garbage
                        newStatus = Status.IDLE;
                    }