// Open the LED Device
fd = os.open('/dev/userleds');

// Flip the LED On and wait a while
ret = os.ioctl(fd, ULEDIOC_SETALL, 1);
os.sleep(5000);

// Close the LED Device
os.close(fd);

## Create a Blockly Website in TypeScript
npx @blockly/create-package \
  app nuttx-blockly --typescript

## Test our Blockly Website
cd nuttx-blockly
npm run start

## Deploy to GitHub Pages at `docs`
npm run build \
  && rm -r docs \
  && mv dist docs

// Code Generator for POSIX `Open` Block
forBlock['posix_open'] = function (
  block: Blockly.Block,             // Our Block
  generator: Blockly.CodeGenerator  // Blockly Code Generator
) {
  // Fetch the Filename Parameter
  // from the Block: '/dev/userleds'
  const text = generator.valueToCode(block, 'FILENAME', Order.NONE)
    || "''";  // Default to blank

  // Generate the Function Call for the block:
  // os.open('/dev/userleds')
  const code = `os.open(${text})`;
  return [code, Order.ATOMIC];
};

// Run on Ox64 Emulator
function runEmulator() {

// Save the Generated JavaScript Code to LocalStorage
  const code = javascriptGenerator.workspaceToCode(ws);
  window.localStorage.setItem("runCode", code);

  // Set the Timestamp for Optimistic Locking (later)
  window.localStorage.setItem("runTimestamp", Date.now() + "");

  // Open the Ox64 Emulator. Reuse the same tab.
  window.open("https://lupyuen.github.io/nuttx-tinyemu/blockly/", "Emulator");
}

// Fetch the Generated JavaScript from Local Storage.
// Newlines become Carriage Returns.
const code = window.localStorage.getItem("runCode")
  .split("\n").join("\r")
  .split("\r\r").join("\r");  // Merge multiple newlines

// Append the Generated JavaScript to
// the QuickJS Command 
const cmd = [
  `qjs`,
  code,
  ``
].join("\r");

// Send the command to the Emulator Console
window.setTimeout(()=>{
  send_command(cmd);
}, 5000);  // Wait 5 seconds for NuttX and QuickJS to boot

<!-- Connect Button in HTML -->
<button
  id="connect"
  onclick="control_device();">
  Connect
</button>

// Control Ox64 over UART. Called by the "Connect" Button.
// https://developer.chrome.com/docs/capabilities/serial
async function control_device() {

  // Doesn't work in http://...
  if (!navigator.serial) { const err = "Web Serial API only works with https://... and file://...!"; alert(err); throw new Error(err); }

  // Prompt our Human to select a Serial Port
  const port = await navigator.serial.requestPort();
  term.write("Power on our NuttX Device and we'll wait for \"nsh>\"\r\n");

  // TODO: Get all Serial Ports our Human has previously granted access
  // const ports = await navigator.serial.getPorts();

  // Wait for the Serial Port to open.
  // TODO: Ox64 only connects at 2 Mbps, change this for other devices
  await port.open({ baudRate: 2000000 });

  // Prepare to Write to the Serial Port
  const textEncoder = new TextEncoderStream();
  const writableStreamClosed = textEncoder.readable.pipeTo(port.writable);
  const writer = textEncoder.writable.getWriter();
  
  // Prepare to Read from the Serial Port
  const textDecoder = new TextDecoderStream();
  const readableStreamClosed = port.readable.pipeTo(textDecoder.writable);
  const reader = textDecoder.readable.getReader();

  // Read from the Serial Port
  const { data, done } = await reader.read();

  // Close the Serial Port if we're done
  if (done) { reader.releaseLock(); return; }

  // Print to the Terminal
  term.write(data);

  // Send the QuickJS Command to Serial Port
  await writer.write("qjs\r");

// Define the POSIX Open Block in Blockly
const posixOpen = {

  // Name and Appearance of our Block
  'type': 'posix_open',
  'message0': 'Open Filename %1',

  // Our Block has one Parameter: Filename
  'args0': [
    {
      'type': 'input_value',
      'name': 'FILENAME',
      'check': 'String',
    },
  ],

  // How it looks
  'previousStatement': null,
  'nextStatement': null,
  'output': 'Number',
  'colour': 160,
  'tooltip': '',
  'helpUrl': '',
};

export const toolbox = {
  'kind': 'categoryToolbox',
  'contents': [
    {
      // Category for POSIX Blocks
      'kind': 'category',
      'name': 'POSIX',
      'categorystyle': 'text_category',
      'contents': [
        // POSIX Open Block
        {
          'kind': 'block',
          'type': 'posix_open',
          'inputs': {
            'FILENAME': {
              'shadow': {
                'type': 'text',
                'fields': {
                  'TEXT': '/dev/userleds',
                },
              },
            },
          },
        },
        // Followed by the other POSIX Blocks:
        // Close, IOCtl, Sleep

## Download our Blockly Website
git clone https://github.com/lupyuen/nuttx-blockly

## Test our Blockly Website
cd nuttx-blockly
npm run start

## Deploy to GitHub Pages at `docs`
npm run build \
  && rm -r docs \
  && mv dist docs

// When we Select a Demo...
function selectDemo(ev: Event) {
  const storageKey = 'mainWorkspace';
  const target = ev?.target as HTMLSelectElement;
  const value = target.value;

  // Set the Blocks in our Local Storage
  switch (value) {

    // If we selected LED Blinky, use the Blinky Blocks
    case "LED Blinky":

      // Omitted: Super-long Blocks JSON
      window.localStorage?.setItem(storageKey, '{"blocks": ...}');
      break;

    default: break;
  }

  // Refresh the Workspace Blocks from Local Storage
  // And regenerate the JavaScript
  if (ws) { 
    load(ws); 
    runCode();
  }
}

// Display the Blocks in JSON Format
localStorage.getItem("mainWorkspace");

// Set the Blocks in JSON Format.
// Change `...` to the JSON of the Blocks to be loaded.
localStorage.setItem("mainWorkspace", `...`);

// Control Ox64 over UART. Called by the "Connect" Button.
// https://developer.chrome.com/docs/capabilities/serial
async function control_device() {

  // Omitted: Prompt our Human to select a Serial Port
  // And wait for Serial Port to open
  const port = ...

  // Omitted: Prepare to Read and Write the Serial Port
  const writer = ...
  const reader = ...

  // Wait for "nsh>"
  let nshSpotted = false;
  let termBuffer = "";

  // Listen to data coming from the Serial Device
  while (true) {
    const { data, done } = await reader.read();
    if (done) {
      // Allow the serial port to be closed later.
      reader.releaseLock();
      break;
    }
    // Print to the Terminal
    term.write(data);

    // Wait for "nsh>"
    if (nshSpotted) { continue; }
    termBuffer += data;
    if (termBuffer.indexOf("nsh>") < 0) { continue; }

    // NSH Spotted! We read the Generated JavaScript
    // from the Web Browser's Local Storage.
    // Newlines become Carriage Returns.
    nshSpotted = true;
    const code = window.localStorage.getItem("runCode")
      .split("\n").join("\r")
      .split("\r\r").join("\r");

    // Append the Generated JavaScript to
    // the QuickJS Command 
    const cmd = [
      `qjs`,
      code,
      ``
    ].join("\r");

    // Send the command to the Serial Port
    window.setTimeout(()=>{
      send_command(writer, cmd); }, 
    1000);  // Wait a second
  }
}

// Run on Ox64 Device
function runDevice() {

  // Save the Generated JavaScript Code to LocalStorage
  const code = javascriptGenerator.workspaceToCode(ws);
  window.localStorage.setItem("runCode", code);

  // Set the Timestamp for Optimistic Locking (later)
  window.localStorage.setItem("runTimestamp", Date.now() + "");

  // Open the Web Serial Monitor. Reuse the same tab.
  window.open("https://lupyuen.github.io/nuttx-tinyemu/webserial/", "Device");
}

// Control Ox64 over UART. Called by the "Connect" Button.
// https://developer.chrome.com/docs/capabilities/serial
async function control_device() {

  // Omitted: Prompt our Human to select a Serial Port
  // And wait for Serial Port to open
  const port = ...

  // Omitted: Prepare to Read and Write the Serial Port
  const writer = ...
  const reader = ...

  // Wait for "nsh>"
  let nshSpotted = false;
  let termBuffer = "";

  // Listen to data coming from the Serial Device
  while (true) {

    // Omitted: Wait for "nsh>"
    ...

    // NSH Spotted! We read the Generated JavaScript
    // from the Web Browser's Local Storage.
    // Newlines become Carriage Returns.
    nshSpotted = true;
    const code = window.localStorage.getItem("runCode")
      .split("\n").join("\r")
      .split("\r\r").join("\r");

    // Append the Generated JavaScript to
    // the QuickJS Command 
    const cmd = [
      `qjs`,
      code,
      ``
    ].join("\r");

    // Send the command to the Serial Port
    window.setTimeout(()=>{
      send_command(writer, cmd); }, 
    1000);  // Wait a second
  }
}

// Send a Command to serial port, character by character
async function send_command(writer, cmd) {
  if (cmd !== null) { send_str = cmd; }
  if (send_str.length == 0) { return; }

  // Get the next character
  const ch = send_str.substring(0, 1);
  send_str = send_str.substring(1);

  // Slow down at the end of each line
  const timeout = (ch === "\r")
    ? 3000
    : 10;

  // Send the character
  await writer.write(ch);

  // Wait a while before next character
  window.setTimeout(()=>{
    send_command(writer, null);
  }, timeout);
}

// Command to be sent to Serial Port
let send_str = "";