엔트리 하드웨어 개발 튜토리얼

class Testino {
    constructor() {
        this.id = 'FF.FF';
        this.url = 'http://www.my-company.org/';
        this.name = 'Testino';
        this.imageName = 'testino.png'; //thumbnail
        this.title = {
            ko: '테스트이노',
            en: 'testino',
        };

        // 블록메뉴에 표기될 블록명을 추가합니다. 이곳에 추가하지 않으면 블록이 표기되지 않습니다.  
        this.blockMenuBlocks = ['testino_on_digital_value', 'testino_off_digital_value'];
    }
}

class Testino {
    constructor() { /* ... */}
    setZero() {
        // 엔트리 실행이 정지되었을 때 보낼 신호(reset 명령을 보냄)
        // 2번부터 13번 포트를 0으로 초기화
        for(let i = 2 ; i <= 13 ; i++) {
            Entry.hw.sendQueue.PORT[i] = 0;
        }

        Entry.hw.update(); // 하드웨어에 명시적으로 정보를 보냄.
    }
}

class Testino {
    constructor() { /* ... */}
    setZero() { /* ... */ }
    setLanguage() {
        return {
            ko: {
                template: {
                    testino_on_digital_value: '디지털 핀 %1 번을 켜기 %2',
                    testino_off_digital_value: '디지털 핀 %1 번을 끄기 %2',
                },
            },
            en: {
                template: {
                    testino_on_digital_value: 'turn on digital pin %1 %2',
                    testino_off_digital_value: 'turn off digital pin %1 %2',
                },
            },
        };
    }
}

class Testino {
    constructor() { /* ... */}
    setZero() { /* ... */ }
    setLanguage() { /* ... */ }
    getBlocks() {
        return {
            testino_on_digital_value: {
                color: EntryStatic.colorSet.block.default.HARDWARE,
                outerLine: EntryStatic.colorSet.block.darken.HARDWARE,
                fontColor: '#ffffff',
                skeleton: 'basic', // 블록 모양 템플릿. 자세한 목록은 docs 를 참고해주세요
                statements: [],
                params: [
                    //입력될 파라미터들의 속성을 정의
                    {
                        type: 'Block',
                        accept: 'string', //숫자만 들어가도 string 입니다. 엔트리엔 이를 구분하지 않습니다.
                    },
                    // basic skeleton 의 마지막엔 인디케이터를 추가해주셔야 합니다.
                    { type: 'Indicator', img: 'block_icon/hardware_icon.svg', size: 12 },
                ],
                def: {
                    params: [
                        //파라미터에 들어갈 기본 값.
                        {
                            type: 'number',
                            params: [2],
                        },
                    ],
                    type: 'testino_on_digital_value', // 블록 상속과 관련된 값입니다. 블록명과 동일하게 해주면 됩니다.
                },
                paramsKeyMap: {
                    // 실제 블록의 로직인 func 에서 해당 인덱스의 파라미터를 가져올때 쓸 key 값
                    PORT: 0,
                },
                events: {},
                class: 'TestinoBlock', // 블록을 묶어서 보여줄 단위값. 이 값이 바뀌면 사이에 가로줄이 생깁니다.
                isNotFor: ['Testino'], // 하드웨어가 연결되었을 경우만 블록을 보여주겠다는 판단값입니다. name 과 동일해야 합니다.
                func: (sprite, script) => {
                    // paramsKeyMap 에서 PORT 는 파라미터의 0번 인덱스 값이었습니다.
                    const portNumber = script.getNumberValue('PORT');
                    Entry.hw.sendQueue[portNumber] = 1;
                    // 값을 반환해야하는 경우는 return 할 수 있습니다.
                },
                syntax: {
                    // 파이썬 문법 변환에 사용되고 있습니다.
                    js: [],
                    py: [
                        {
                            syntax: 'Testino.turnOnDigitalPort(%1)',
                            blockType: 'param',
                            textParams: [
                                {
                                    type: 'Block',
                                    accept: 'string',
                                },
                            ],
                        },
                    ],
                },
            },
            testino_off_digital_value: {
                color: EntryStatic.colorSet.block.default.HARDWARE,
                outerLine: EntryStatic.colorSet.block.darken.HARDWARE,
                fontColor: '#ffffff',
                skeleton: 'basic',
                statements: [],
                params: [
                    {
                        type: 'Block',
                        accept: 'string',
                    },
                    { type: 'Indicator', img: 'block_icon/hardware_icon.svg', size: 12 },
                ],
                def: {
                    params: [
                        {
                            type: 'number',
                            params: [2],
                        },
                    ],
                    type: 'testino_off_digital_value',
                },
                paramsKeyMap: {
                    PORT: 0,
                },
                events: {},
                class: 'TestinoBlock',
                isNotFor: ['Testino'],
                func: (sprite, script) => {
                    const portNumber = script.getNumberValue('PORT');
                    Entry.hw.sendQueue[portNumber] = 0;
                },
                syntax: {
                    js: [],
                    py: [
                        {
                            syntax: 'Testino.turnOffDigitalPort(%1)',
                            blockType: 'param',
                            textParams: [
                                {
                                    type: 'Block',
                                    accept: 'string',
                                },
                            ],
                        },
                    ],
                },
            },
        };
    }
}

Entry.Testino = new Testino();
module.exports = Entry.Testino;

// isNotFor: ['Testino'], // 하드웨어가 연결되었을 경우만 블록을 보여주겠다는 판단값입니다. 기본 명세의 name값과 동일해야합니다.

const BaseModule = require('./baseModule');

class Module extends BaseModule {
    constructor() {
        super();
        this.sp = null;
        this.digitalPin = [];
        this.sendBuffers = [];
    }
    
    init(handler, config) {
        // 엔트리 브라우저와 연결되었을때 호출됨
    }

    setSerialPort(sp) {
        // 최초 연결시도(handshake) 성공 후에 호출됨
        this.sp = sp;
    }

    requestInitialData() {
        // 최초 연결시도시 디바이스에 보낼 데이터. checkInitialData 가 선언되어있다면 필수
        return null;
    }

    checkInitialData(data, config) {
        // 최초 연결시도에서 디바이스의 데이터를 받아, 원하는 데이터가 맞는지 판단하는 로직
        // requestInitialData 가 선언되어있다면 필수
        return true;
    }

    // deprecated
    afterConnect(connector, cb) {
        // handshake 종료 후 정상 연결상태로 진입전에 호출됨. connector 와 UI state 를 강제변경할 수 있으나 비추천
        connector.connected = true;
        if (cb) {
            cb('connected'); // 해당 string state 로 UI state 를 강제변경하나 문제를 일으킬 수 있습니다.
        }
    }

    validateLocalData(data) {
        // 해당 함수가 존재하면, 디바이스에서 데이터를 받아온 후 validate 를 거친다. 없으면 그대로 처리로직으로 진행한다.
        return true;
    }

    requestRemoteData(handler) {
        // 디바이스에서 데이터를 받아온 후, 브라우저로 데이터를 보내기 위해 호출되는 로직. handler 를 세팅하는 것으로 값을 보낼 수 있다.
        // handler.write(key, value) 로 세팅한 값은 Entry.hw.portData 에서 받아볼 수 있다.
    };

    handleRemoteData(handler) {
        // 엔트리 브라우저에서 온 데이터를 처리한다. handler.read 로 브라우저의 데이터를 읽어올 수 있다.
        // handler 의 값은 Entry.hw.sendQueue 에 세팅한 값과 같다.
        let buffer = new Buffer([]);
        const digitalPin = this.digitalPin;

        for (let i = 0 ; i < 14 ; i++) {
            digitalPin[i] = handler.read(i);

            buffer = Buffer.concat([
                buffer,
                this.makeOutputBuffer(1, i, digitalPin[i] === 1 ? 255 : 0),
            ]);
        }

        if (buffer.length) {
            this.sendBuffers.push(buffer);
        }
    }

    requestLocalData() {
        // 디바이스로 데이터를 보내는 로직. control: slave 인 경우 duration 주기에 맞춰 디바이스에 데이터를 보낸다.
        // return 값으로 버퍼를 반환하면 디바이스로 데이터를 보내나, 아두이노의 경우 레거시 코드를 따르고 있다.

        if (this.sendBuffers.length > 0) {
            this.sp.write(this.sendBuffers.shift(), () => {
                if (this.sp) {
                    this.sp.drain(() => {
                        this.isDraing = false;
                    });
                }
            });
        }

        return null;
    }

    handleLocalData(data) {
        // 디바이스에서 온 데이터를 처리하는 로직. 여기서는 처리할 데이터가 없어 스킵하였음.
    }

    disconnect(connector) {
        // 커넥터가 연결해제될 때 호출되는 로직, 스캔 정지 혹은 디바이스 연결 해제시 호출된다.
        connector.close();
        if (this.sp) {
            delete this.sp;
        }
    };

    reset() {
        // 엔트리 브라우저와의 소켓 연결이 끊어졌을 때 발생하는 로직.
    }

    // 이 아래로는 자유롭게 선언하여 사용한 함수입니다.
    makeOutputBuffer(device, port, data) {
        let buffer;
        const value = new Buffer(2);
        const dummy = new Buffer([10]);

        value.writeInt16LE(data);
        buffer = new Buffer([
            255,
            85,
            6,
            0, // sensorIdx
            2,
            device,
            port,
        ]);
        buffer = Buffer.concat([buffer, value, dummy]);

        return buffer;
    };

    getDataByBuffer(buffer) {
        const datas = [];
        let lastIndex = 0;
        buffer.forEach((value, idx) => {
            if (value == 13 && buffer[idx + 1] == 10) {
                datas.push(buffer.subarray(lastIndex, idx));
                lastIndex = idx + 2;
            }
        });

        return datas;
    };
}

module.exports = new Module();