Node.js環境で動作する宣言的UIによるハードウェア制御ライブラリ「Edison」

import React, { useState } from "react";
import { renderToString } from "react-dom/server";
import { Board, Led } from "edison";

const App: React.FC = () => {
  const [isOn, setIsOn] = useState(false);
  if (!isOn) {
    setIsOn(true);
  }
  return (
    <Board port={"/dev/ttyUSB0"}>
      <Led pin={13} isOn={isOn} />
    </Board>
  );
};

renderToString(<App />);

import { SerialPort, board } from "edison";
import React, { createContext } from "react";

export const BoardContext = createContext<SerialPort | null>(null);

type BoardProps = {
  children: React.ReactNode;
  port: string;
  // onReady: (port: SerialPort) => void /* こういう風に書くと引数増やせる */
};

export const Board: React.FC<BoardProps> = ({ children, port }) => {
  board.connectManual(port);
  return <BoardContext.Provider value={null}>{children}</BoardContext.Provider>;
};

import { renderToString } from "react-dom/server";
import { FC } from "edison";
import { Button } from "./input/Button";
import { Board } from "./lib/Board";
import { Buzzer } from "./lib/Buzzer";
import { useCustomHook, subscribeToStateChange } from "./lib/state";
import React from "react";
const [someState, setSomeState] = useCustomHook(false);

const Test: FC = () => {
  const handlePress = () => {
    setSomeState(true);
  };

  const handleRelease = () => {
    setSomeState(false);
  };

  return (
    <Board port={"/dev/ttyUSB1"}>
      <Button pin={8} onPress={handlePress} onRelease={handleRelease}>
        <Buzzer pin={13} isOn={someState} />
      </Button>
    </Board>
  );
};

// サーバーサイドレンダリングではなく、Node.js環境での実行を想定
console.log(renderToString(<Test />));
subscribeToStateChange((newValue: any) => {
  console.log("new value: ", newValue);
  console.log("State changed to: }");
  console.log(renderToString(<Test />));
});

import React from 'react'
import { useState, useEffect } from 'react'
import { Board } from './utils/Board'
import { Led } from './component/output/uniqueDevice/Led'
import render from './rendere/render'

const App: React.FC = () => {
  const [isOn, setIsOn] = useState(true)

  useEffect(() => {
    setInterval(() => {
      setIsOn((preIson) => !preIson)
    }, 200)
  }, [])

  return (
    <Board port={'/dev/ttyUSB0'}>
      <Led
        pin={13}
        isOn={isOn}
      />
    </Board>
  )
}
render(<App />)

allen@MSI:~/Github/EdisonRun$ npx vite-node tsx/ServoRun.tsx 
The CJS build of Vite's Node API is deprecated. See https://vitejs.dev/guide/troubleshooting.html#vite-cjs-node-api-deprecated for more details.
Warning: Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
1. You might have mismatching versions of React and the renderer (such as React DOM)
2. You might be breaking the Rules of Hooks
3. You might have more than one copy of React in the same app
See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.
Warning: Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
1. You might have mismatching versions of React and the renderer (such as React DOM)
2. You might be breaking the Rules of Hooks
3. You might have more than one copy of React in the same app
See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.
The above error occurred in the <App> component:

    at App (/home/allen/Github/EdisonRun/tsx/ServoRun.tsx:8:51)
    at App (/home/allen/Github/Edison/dist/esm/declarative/components/App.js:10:1)

React will try to recreate this component tree from scratch using the error boundary you provided, InternalApp.

angle 30
App
angle 30
App
angle 40
App
angle 40

import type { SerialPort } from 'serialport'
import { bufferWrite } from '../Utils/bufferWrite'
import type { Observable } from 'rxjs'
import { fromEventPattern } from 'rxjs'
import { filter, map, scan } from 'rxjs/operators'
import { Buffer } from 'node:buffer'

const SET_PIN_MODE = 0xf4
const INPUT_MODE = 0x00
const DIGITAL_CHANGE_MESSAGE = 0xd0

export const setInputState = (
  pin: number,
  port: SerialPort,
): Observable<boolean> => {
  bufferWrite(port, Buffer.from([SET_PIN_MODE, pin, INPUT_MODE]))
  bufferWrite(
    port,
    Buffer.from([DIGITAL_CHANGE_MESSAGE + Math.floor(pin / 8), 1]),
  )

  return fromEventPattern<Buffer>(
    (handler) => port.on('data', handler), // イベントを追加する関数
    (handler) => port.removeListener('data', handler), // イベントを削除する関数
  ).pipe(
    map((data) => (data.length <= 3 ? data : data.subarray(0, 3))),
    scan(
      (
        acc: { preBinary?: Buffer; lastState?: boolean; emit: boolean },
        currentBinary: Buffer,
      ) => {
        if (acc.preBinary && acc.preBinary.equals(currentBinary)) {
          return { ...acc, emit: false }
        }
        if (
          currentBinary.length === 0 ||
          (currentBinary[0] !== 0x90 && currentBinary[0] !== 0x91)
        ) {
          return { ...acc, emit: false }
        }
        const currentState = !!(currentBinary[1] & (1 << pin % 8))
        // console.log(
        //   'acc:',
        //   acc,
        //   'currentBinary:',
        //   currentBinary,
        //   'currentState:',
        //   currentState,
        //   'lastState:',
        //   acc.lastState,
        //   'emit:',
        //   acc.lastState !== currentState,
        // )

        if (acc.emit) {
          console.log('acc', acc)
        }
        return {
          preBinary: currentBinary,
          lastState: currentState,
          emit: acc.lastState !== currentState, // 状態が変わった場合のみemitをtrueに
        }
      },
      { emit: false },
    ),
    filter((acc) => acc.emit),
    map((acc) => acc.lastState as boolean),
  )
}

import type { SerialPort } from 'serialport'
import { setInputState } from '../../helper/Input/setInputState'
import type { Sensor } from '../../types/analog/analog'

export const inputPort = (port: SerialPort) => {
  return (pin: number) => {
    let prevValue: boolean | null = null
    return {
      read: (
        method: Sensor,
        func: () => Promise<void> | Promise<number> | void | number,
      ): void => {
        const observable = setInputState(pin, port)

        observable.subscribe((value: boolean) => {
          if (method === 'change') {
            if (value !== prevValue) {
              prevValue = value
              func()
            }
          } else if (method === 'off' && value && prevValue !== value) {
            prevValue = value
            func()
          } else if (method === 'on' && !value && prevValue !== value) {
            prevValue = value
            func()
          }
        })
      },
    }
  }
}