@geastack/core 0.1.37 → 0.1.39-uart.1

package/include/display_present.h

@@ -2,6 +2,7 @@
 
 #include "canvas.h"
 #include "display.h"
+#include "image.h"
 
 #include <algorithm>
 #include <array>
@@ -284,6 +285,13 @@ inline void addCommandBounds(const Command &command, Rect *rects, int *count, in
 	addRect(rects, count, capacity, commandBounds(command, width, height), width, height);
 }
 
+// An app-registered buffer (native surface, ImageData565, video frame) is
+// rewritten in place, so equal pointers say nothing about equal pixels.
+inline bool imagePixelsStable(const Command &command)
+{
+	return !gea::framework::graphics::ImageStore::instance().pixelsMayChange(command.pixels);
+}
+
 inline bool commandsEqual(const Command &a, const Command &b)
 {
 	if (a.type != b.type || a.alpha != b.alpha) return false;
@@ -321,15 +329,15 @@ inline bool commandsEqual(const Command &a, const Command &b)
 		                       sizeof(gea::framework::graphics::TriangleEntry)) == 0;
 	}
 	case Type::DrawImage:
-		return a.pixels == b.pixels && a.alphaPixels == b.alphaPixels &&
+		return a.pixels == b.pixels && a.alphaPixels == b.alphaPixels && imagePixelsStable(a) &&
 		       a.srcWidth == b.srcWidth && a.srcHeight == b.srcHeight && a.x == b.x && a.y == b.y;
 	case Type::DrawImageScaled:
 	case Type::DrawImageRotated90CW:
-		return a.pixels == b.pixels && a.alphaPixels == b.alphaPixels &&
+		return a.pixels == b.pixels && a.alphaPixels == b.alphaPixels && imagePixelsStable(a) &&
 		       a.srcWidth == b.srcWidth && a.srcHeight == b.srcHeight &&
 		       a.x == b.x && a.y == b.y && a.w == b.w && a.h == b.h;
 	case Type::DrawImageTiledX:
-		return a.pixels == b.pixels && a.alphaPixels == b.alphaPixels &&
+		return a.pixels == b.pixels && a.alphaPixels == b.alphaPixels && imagePixelsStable(a) &&
 		       a.srcWidth == b.srcWidth && a.srcHeight == b.srcHeight &&
 		       a.x == b.x && a.y == b.y && a.w == b.w;
 	case Type::FillText:
@@ -574,8 +582,17 @@ inline bool frameHasOpaqueBase(const Frame &frame, int width, int height)
 	const Command &first = frame.commands.front();
 	using Type = gea::platform::display::DisplayPresentCommandType;
 	if (first.type == Type::Clear) return true;
-	if (first.type != Type::FillRectRgb565 || first.alpha != 255) return false;
-	const Rect bounds = rectFromBox(first.x, first.y, first.w, first.h);
+	if (first.alpha != 255) return false;
+	Rect bounds;
+	if (first.type == Type::FillRectRgb565) {
+		bounds = rectFromBox(first.x, first.y, first.w, first.h);
+	} else if (first.type == Type::DrawImage && first.alphaPixels == nullptr) {
+		// A full-panel opaque image (putImageData of a whole-screen buffer)
+		// paints every pixel, the same as a full-panel fill.
+		bounds = rectFromBox(first.x, first.y, first.srcWidth, first.srcHeight);
+	} else {
+		return false;
+	}
 	return bounds.x0 <= 0 && bounds.y0 <= 0 && bounds.x1 >= width - 1 && bounds.y1 >= height - 1;
 }
 

package/include/image.h

@@ -61,6 +61,9 @@ struct ImageSlot {
 	pixel::native_t *pixels = nullptr;
 	std::uint8_t *alpha = nullptr;
 	bool ownsPixels = false;
+	// Registered by the app (registerBuffer): the app writes these pixels in
+	// place between frames, so the same pointer does not mean the same image.
+	bool mutablePixels = false;
 
 	void *gifDecoder = nullptr;
 	std::uint8_t *gifData = nullptr;
@@ -98,6 +101,11 @@ public:
 	// camera capture, which hands over a freshly-allocated RGBA8888 still.
 	int registerBuffer(pixel::native_t *pixels, int width, int height, int preferredSlot = -1, bool takeOwnership = false);
 
+	// True when `pixels` point into a registerBuffer() image, whose content the
+	// app rewrites in place. The present diff never treats such an image as
+	// unchanged from the previous frame.
+	bool pixelsMayChange(const pixel::native_t *pixels) const;
+
 	int width(int id) const;
 	int height(int id) const;
 	int frameCount(int id) const;

package/include/platform/uart.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+// Target-owned implementation. Unsupported platforms report unavailable.
+extern "C" {
+bool gea_uart_open(int port, int tx, int rx, int baud, int rxBytes, int txBytes)
+    __attribute__((weak));
+bool gea_uart_is_open(int port) __attribute__((weak));
+void gea_uart_close(int port) __attribute__((weak));
+int gea_uart_read(int port, void *bytes, std::size_t capacity)
+    __attribute__((weak));
+int gea_uart_write(int port, const void *bytes, std::size_t length)
+    __attribute__((weak));
+int gea_uart_available(int port) __attribute__((weak));
+int gea_uart_writable(int port) __attribute__((weak));
+}
+
+namespace gea::platform::uart {
+struct Config {
+  int tx;
+  int rx;
+  int baudRate;
+  int rxBufferSize = 4096;
+  int txBufferSize = 4096;
+};
+
+class Uart {
+public:
+  static bool open(int port, const Config &config) {
+    return gea_uart_open &&
+           gea_uart_open(port, config.tx, config.rx, config.baudRate,
+                         config.rxBufferSize, config.txBufferSize);
+  }
+  static bool isOpen(int port) {
+    return gea_uart_is_open && gea_uart_is_open(port);
+  }
+  static void close(int port) {
+    if (gea_uart_close)
+      gea_uart_close(port);
+  }
+  // Nonblocking. -1 means unavailable/closed/error; 0 means no progress.
+  static int read(int port, void *bytes, std::size_t capacity) {
+    return gea_uart_read ? gea_uart_read(port, bytes, capacity) : -1;
+  }
+  // Enqueues the complete buffer, or returns 0 if it cannot fit yet.
+  static int write(int port, const void *bytes, std::size_t length) {
+    return gea_uart_write ? gea_uart_write(port, bytes, length) : -1;
+  }
+  static int available(int port) {
+    return gea_uart_available ? gea_uart_available(port) : -1;
+  }
+  static int writable(int port) {
+    return gea_uart_writable ? gea_uart_writable(port) : -1;
+  }
+};
+} // namespace gea::platform::uart

package/index.d.ts

@@ -653,6 +653,13 @@ export interface ImageProps extends DataAttributes {
   onFrame?: (frame: number) => void
 }
 
+export interface ImageData565 {
+  readonly width: number
+  readonly height: number
+  /** Row-major RGB565 pixels, `width * height` long. */
+  readonly data16: Uint16Array
+}
+
 export interface GeaEmbeddedImage {
   readonly width: number
   readonly height: number
@@ -1008,6 +1015,24 @@ export interface CanvasRenderingContext2D {
   drawImageCircle(image: GeaEmbeddedImage, dx: number, dy: number, width: number, height: number): void
   drawImageRotated90CW(image: GeaEmbeddedImage, dx: number, dy: number, width: number, height: number): void
   drawImageTiledX(image: GeaEmbeddedImage, dx: number, dy: number, width: number): void
+  /**
+   * An RGB565 pixel buffer the app writes directly:
+   * `img.data16[i] = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | (b >> 3)`.
+   * Allocate once, write every frame, then draw with `putImageData`.
+   */
+  createImageData565(width: number, height: number): ImageData565
+  /** Draw an `ImageData565` with its top-left corner at (dx, dy): one blit. */
+  putImageData(image: ImageData565, dx: number, dy: number): void
+  /** Draw only the dirty rectangle of an `ImageData565`, at (dx + dirtyX, dy + dirtyY). */
+  putImageData(
+    image: ImageData565,
+    dx: number,
+    dy: number,
+    dirtyX: number,
+    dirtyY: number,
+    dirtyWidth: number,
+    dirtyHeight: number,
+  ): void
   flush(): void
   beginBatch(): void
   endBatch(): void
@@ -1208,6 +1233,33 @@ export interface GpioController {
 
 export declare const Gpio: GpioController
 
+export interface UartOptions {
+  tx: number
+  rx: number
+  baudRate: number
+  /** Receive/transmit queue bytes. Defaults to 4096 each. */
+  rxBufferSize?: number
+  txBufferSize?: number
+}
+
+/** Hardware UART, 8 data bits, no parity, one stop bit (8N1). */
+export interface UartController {
+  /** Claims a free controller and pins. False on conflict/invalid configuration. */
+  open(port: number, options: UartOptions): boolean
+  isOpen(port: number): boolean
+  close(port: number): void
+  /** Nonblocking read into the supplied view; returns bytes read, or -1 on error. */
+  read(port: number, buffer: Uint8Array): number
+  /** Nonblocking whole-buffer enqueue; 0 means backpressure, -1 means error. */
+  write(port: number, buffer: Uint8Array): number
+  /** Queued readable bytes, or -1 when unavailable. */
+  available(port: number): number
+  /** Writable queue capacity, or -1 when unavailable. */
+  writable(port: number): number
+}
+
+export declare const Uart: UartController
+
 export interface LedController {
   // A WS2812/NeoPixel strand on one pin — what "the onboard LED" is on most
   // modern ESP32 modules.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geastack/core",
-  "version": "0.1.37",
+  "version": "0.1.39-uart.1",
   "description": "GeaStack app API, reactivity headers, runtime sources, and type declarations.",
   "license": "Apache-2.0",
   "repository": {
@@ -65,8 +65,8 @@
     "@babel/types": "^7.23.0",
     "@geajs/core": "1.5.1",
     "@geajs/vite-plugin": "1.5.0",
-    "@geastack/compiler": "^1.0.22",
-    "@geastack/geatsc-plugin-gea": "^0.1.19",
+    "@geastack/compiler": "^1.0.25",
+    "@geastack/geatsc-plugin-gea": "0.1.21-uart.1",
     "opentype.js": "^2.0.0",
     "vite": "^8.0.0"
   }

package/runtime/host.ts

@@ -6,6 +6,7 @@
 // fails the representation coverage guard for the whole `Geolocation` literal
 // below. lib.dom's GeolocationPositionError also carries PERMISSION_DENIED /
 // POSITION_UNAVAILABLE / TIMEOUT, which our host object never sets.
+import type { UartOptions } from '../index'
 import type {
   CanvasRenderingContext2D,
   GeolocationCoordinates,
@@ -361,6 +362,15 @@ declare const __gea_Gpio: {
   write(pin: number, level: boolean): boolean
   read(pin: number): boolean
 }
+declare const __gea_Uart: {
+  open(port: number, tx: number, rx: number, baud: number, rxBytes: number, txBytes: number): boolean
+  isOpen(port: number): boolean
+  close(port: number): void
+  read(port: number, buffer: Uint8Array): number
+  write(port: number, buffer: Uint8Array): number
+  available(port: number): number
+  writable(port: number): number
+}
 declare const __gea_Led: {
   // A WS2812/NeoPixel strand on one pin — what "the onboard LED" is on most
   // modern ESP32 modules. set() is the one-call default (attach if needed,
@@ -995,6 +1005,31 @@ export const Gpio = {
     return __gea_Gpio.read(pin)
   }
 }
+export const Uart = {
+  open(port: number, options: UartOptions): boolean {
+    if (typeof __gea_Uart === 'undefined') return false
+    return __gea_Uart.open(port, options.tx, options.rx, options.baudRate,
+      options.rxBufferSize ?? 4096, options.txBufferSize ?? 4096)
+  },
+  isOpen(port: number): boolean {
+    return typeof __gea_Uart !== 'undefined' && __gea_Uart.isOpen(port)
+  },
+  close(port: number): void {
+    if (typeof __gea_Uart !== 'undefined') __gea_Uart.close(port)
+  },
+  read(port: number, buffer: Uint8Array): number {
+    return typeof __gea_Uart !== 'undefined' ? __gea_Uart.read(port, buffer) : -1
+  },
+  write(port: number, buffer: Uint8Array): number {
+    return typeof __gea_Uart !== 'undefined' ? __gea_Uart.write(port, buffer) : -1
+  },
+  available(port: number): number {
+    return typeof __gea_Uart !== 'undefined' ? __gea_Uart.available(port) : -1
+  },
+  writable(port: number): number {
+    return typeof __gea_Uart !== 'undefined' ? __gea_Uart.writable(port) : -1
+  },
+}
 export const Led = {
   set(pin: number, r: number, g: number, b: number): boolean {
     return __gea_Led.set(pin, r, g, b)

package/runtime-surface.ts

@@ -57,6 +57,8 @@ export type {
  * gets today.
  */
 export type {
+  UartOptions,
+  UartController,
   AccelerometerController,
   AccelerometerReading,
   AppsController,
@@ -119,6 +121,7 @@ export type {
   HttpModule,
   HttpRequestHandler,
   HttpServer,
+  ImageData565,
   ImageProps,
   ImageSource,
   IncomingMessage,