@johntalton/ftdi 1.1.0 → 1.1.2

package/src/ftdi.ts

@@ -1,4 +1,4 @@
-/** biome-ignore-all lint/style/noNestedTernary: <explanation> */
+/** biome-ignore-all lint/style/noNestedTernary: makes code better */
 import type { BitMode, ModemControl, RequestType } from './consts.ts'
 import { REQUESTS, RESET_USB } from './consts.ts'
 import { MPSSE } from './mpsse/mpsse.ts'
@@ -112,16 +112,16 @@ export class FTDIDevice {
 	}
 
 	async getModemStatus(): Promise<DeviceStatusInfo|undefined> {
-		const status = await this.#requestIn(REQUESTS.POLL_MODEM_STATUS, STATUS_PREFIX_LENGTH)
-		if(status.status !== USB_TRANSFER_OK) { throw new Error('status not ok') }
-		if(status.data === undefined) { throw new Error('undefined data') }
-		assertDataViewNotShared(status.data)
-		return DeviceStatus.parse(status.data)
+		const result = await this.#requestIn(REQUESTS.POLL_MODEM_STATUS, STATUS_PREFIX_LENGTH)
+		if(result.status !== USB_TRANSFER_OK) { throw new Error(`unexpected status: ${result.status}`) }
+		if(result.data === undefined) { throw new Error('undefined data') }
+		assertDataViewNotShared(result.data)
+		return DeviceStatus.parse(result.data)
 	}
 
 	async getLatencyTimer(): Promise<number> {
 		const result = await this.#requestIn(REQUESTS.GET_LATENCY_TIMER, 1)
-		if(result.status !== USB_TRANSFER_OK) { throw new Error('status not ok') }
+		if(result.status !== USB_TRANSFER_OK) { throw new Error(`unexpected status: ${result.status}`) }
 		if(result.data === undefined) { throw new Error('undefined data') }
 
 		const latency = result.data.getUint8(0)
@@ -133,12 +133,12 @@ export class FTDIDevice {
 		if(latency < 0 || latency > 255) { throw new RangeError('latency out of range') }
 
 		const result = await this.#requestOut(REQUESTS.SET_LATENCY_TIMER, latency)
-		if(result.status !== USB_TRANSFER_OK) { throw new Error('status not ok') }
+		if(result.status !== USB_TRANSFER_OK) { throw new Error(`unexpected status: ${result.status}`) }
 	}
 
 	async readPins(): Promise<number> {
 		const result = await this.#requestIn(REQUESTS.READ_PINS, 1)
-		if(result.status !== USB_TRANSFER_OK) { throw new Error('status not ok') }
+		if(result.status !== USB_TRANSFER_OK) { throw new Error(`unexpected status: ${result.status}`) }
 		if(result.data === undefined) { throw new Error('undefined data') }
 		return result.data.getUint8(0)
 	}
@@ -157,7 +157,7 @@ export class FTDIDevice {
 		const value = dtrValue | rtsValue
 
 		const result = await this.#requestOut(REQUESTS.SET_MODEM_CTRL, value)
-		if(result.status !== USB_TRANSFER_OK) { throw new Error('status not ok') }
+		if(result.status !== USB_TRANSFER_OK) { throw new Error(`unexpected status: ${result.status}`) }
 	}
 
 	async setEventChar(data: number, enable = true): Promise<void> {
@@ -166,7 +166,7 @@ export class FTDIDevice {
 		const value = enable ? ENABLE_BIT | data : data
 
 		const result = await this.#requestOut(REQUESTS.SET_EVENT_CHAR, value)
-		if(result.status !== USB_TRANSFER_OK) { throw new Error('status not ok') }
+		if(result.status !== USB_TRANSFER_OK) { throw new Error(`unexpected status: ${result.status}`) }
 	}
 
 	async setErrorChar(data: number, enable = true): Promise<void> {
@@ -175,20 +175,19 @@ export class FTDIDevice {
 		const value = enable ? ENABLE_BIT | data : data
 
 		const result = await this.#requestOut(REQUESTS.SET_ERROR_CHAR, value)
-		if(result.status !== USB_TRANSFER_OK) { throw new Error('status not ok') }
+		if(result.status !== USB_TRANSFER_OK) { throw new Error(`unexpected status: ${result.status}`) }
 
 	}
 
-
   async sendData(data: BufferSource): Promise<number> {
     const result = await this.#device.transferOut(this.#endpointBulkOut, data)
-		if(result.status !== USB_TRANSFER_OK) { throw new Error('failure sending data') }
+		if(result.status !== USB_TRANSFER_OK) { throw new Error(`unexpected status sending data: ${result.status}`) }
 		return result.bytesWritten
   }
 
 	async readData(length: number): Promise<DataView<ArrayBuffer>> {
 		const result = await this.#device.transferIn(this.#endpointBulkIn, length)
-		if(result.status !== USB_TRANSFER_OK) { throw new Error('failure to read data') }
+		if(result.status !== USB_TRANSFER_OK) { throw new Error(`unexpected status reading data: ${result.status}`) }
 		if(result.data === undefined) { throw new Error('result data undefined') }
 		assertDataViewNotShared(result.data)
 		return result.data
@@ -196,7 +195,7 @@ export class FTDIDevice {
 
 	async readEEPROM(address: number, length: number): Promise<DataView<ArrayBuffer>> {
 		const result = await this.#requestIn(REQUESTS.READ_EEPROM, length, address)
-		if(result.status !== USB_TRANSFER_OK) { throw new Error('failure to read eeprom') }
+		if(result.status !== USB_TRANSFER_OK) { throw new Error(`unexpected status reading eeprom: ${result.status}`) }
 		if(result.data === undefined) { throw new Error('result data undefined') }
 		assertDataViewNotShared(result.data)
 
@@ -205,7 +204,7 @@ export class FTDIDevice {
 
 	async writeEEPROM(address: number, value: number): Promise<number> {
 		const result = await this.#requestOut(REQUESTS.WRITE_EEPROM, value, address)
-		if(result.status !== USB_TRANSFER_OK) { throw new Error('failure to read eeprom') }
+		if(result.status !== USB_TRANSFER_OK) { throw new Error(`unexpected status writing eeprom: ${result.status}`) }
 		return result.bytesWritten
 	}
 

package/src/i2c/i2c-template.ts

@@ -1,4 +1,4 @@
-/** biome-ignore-all lint/style/useConsistentArrayType: <explanation> */
+/** biome-ignore-all lint/style/useConsistentArrayType: miss-classified */
 import {
 	CLOCK_BASE_12,
 	CLOCK_BASE_60,
@@ -14,20 +14,37 @@ import {
 } from '../mpsse/command.ts'
 import { MPSSETemplate } from '../mpsse/mpsse-template.ts'
 
-const SDA_PIN_MASK = 0b0000_0010
-const SCL_PIN_MASK = 0b0000_0001
+export const SCL_PIN_MASK = 0b0000_0001 // D0
+export const SDA_PIN_MASK = 0b0000_0010 // D1
+export const TX_PIN_MASK = 0b0010_0000 // D5
+export const RX_PIN_MASK = 0b0100_0000 // D6
 
-const SCL_HIGH_SDA_HIGH: number = SDA_PIN_MASK | SCL_PIN_MASK
-const SCL_HIGH_SDA_LOW: number = SCL_PIN_MASK
-const SCL_LOW_SDA_HIGH: number = SDA_PIN_MASK
-const SCL_LOW_SDA_LOW = 0
 
-const SDA_DIRECTION_OUT = 0b0000_0010
-const SCL_DIRECTION_OUT = 0b0000_0001
-const SDA_SCL_DIRECTION_OUT: number = SDA_DIRECTION_OUT | SCL_DIRECTION_OUT
 
-const OPEN_DRAIN_LOW_PIN_MASK = 0b0000_0111
-const OPEN_DRAIN_HIGH_PIN_MASK = 0b0000_0000
+export const TX_LOW_RX_LOW = 0
+export const TX_LOW_RX_HIGH: number = RX_PIN_MASK
+export const TX_HIGH_RX_LOW: number = TX_PIN_MASK
+export const TX_HIGH_RX_HIGH: number = RX_PIN_MASK | TX_PIN_MASK
+
+
+export const SCL_HIGH_SDA_HIGH: number = SDA_PIN_MASK | SCL_PIN_MASK | TX_HIGH_RX_HIGH
+export const SCL_HIGH_SDA_LOW: number = SCL_PIN_MASK | TX_HIGH_RX_HIGH
+export const SCL_LOW_SDA_HIGH: number = SDA_PIN_MASK | TX_HIGH_RX_HIGH
+export const SCL_LOW_SDA_LOW: number = 0 | TX_HIGH_RX_HIGH
+
+// export const SCL_LOW_SDA_HIGH_RX: number = SDA_PIN_MASK | TX_HIGH_RX_LOW
+// export const SCL_LOW_SDA_HIGH_TX: number = SDA_PIN_MASK | TX_LOW_RX_HIGH
+
+
+
+
+export const SDA_DIRECTION_OUT = 0b0000_0010
+export const SCL_DIRECTION_OUT = 0b0000_0001
+export const RX_TX_DIRECTION = 0b0110_0000
+export const SDA_SCL_DIRECTION_OUT: number = SDA_DIRECTION_OUT | SCL_DIRECTION_OUT | RX_TX_DIRECTION
+
+export const OPEN_DRAIN_LOW_PIN_MASK = 0b0110_0111
+export const OPEN_DRAIN_HIGH_PIN_MASK = 0b0000_0000
 
 export class I2CTemplate {
 	static initI2C(targetHertz: number, enableClockDivideBy5 = false): Uint8Array<ArrayBuffer> {
@@ -98,7 +115,9 @@ export class I2CTemplate {
 
 	static writeByte(data: number): Uint8Array<ArrayBuffer> {
 		return Uint8Array.from([
+			// ...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_HIGH_TX, SDA_SCL_DIRECTION_OUT),
 			...MPSSETemplate.shiftOutByte(SHIFT_COMMAND.OUT_MSB_BYTES_NEGATIVE_VE, 1, data),
+			// ...MPSSETemplate.gpioSetLow(SCL_LOW_SDA_LOW, SDA_SCL_DIRECTION_OUT),
 			...I2CTemplate.#consumeAck(),
 			HOST_AND_MPSSE_MODE_COMMANDS.SEND_IMMEDIATE
 		])
@@ -116,7 +135,7 @@ export class I2CTemplate {
 		])
 	}
 
-	static readData(ack = true): Uint8Array<ArrayBuffer> {
+	static readData(ack: boolean): Uint8Array<ArrayBuffer> {
 		const MSB_ACK_BIT = 0x00
 		const MSB_NACK_BIT = 0x80
 		const data = ack ? MSB_ACK_BIT : MSB_NACK_BIT

package/src/i2c/i2c.ts

@@ -1,6 +1,6 @@
 /** biome-ignore-all lint/style/noNestedTernary: preserve const assign */
 /** biome-ignore-all lint/performance/noAwaitInLoops: simplify impl */
-/** biome-ignore-all lint/style/useConsistentArrayType: <explanation> */
+/** biome-ignore-all lint/style/useConsistentArrayType: miss-classified */
 import type {
 	I2CAddress,
 	I2CBufferSource,
@@ -40,9 +40,6 @@ export async function readData(device: FTDIDevice, length: number, targetBuffer?
 			new Uint8Array(targetBuffer.buffer, targetBuffer.byteOffset, length) :
 			new Uint8Array(targetBuffer, 0, length))
 
-	// c0 low - RX-LED-emulation
-	// await device.mpsse.setGpioHigh(0b0000_0000, 0b0000_0001)
-
 	for(let offset = 0; offset < length; offset += 1) {
 		const ack = offset + 1 < length // is last byte
 
@@ -53,9 +50,6 @@ export async function readData(device: FTDIDevice, length: number, targetBuffer?
 		buffer.set(new Uint8Array(byteReadResponse.buffer, byteReadResponse.byteOffset, 1), offset)
 	}
 
-	// c0 high - RX-LED-emulation
-	// await device.mpsse.setGpioHigh(0b0000_0001, 0b0000_0001)
-
 	return buffer
 }
 
@@ -99,8 +93,8 @@ export class FT232HBus implements I2CBus {
 		this.#device = device
 	}
 
-	// biome-ignore lint/nursery/useThisInClassMethods: close is a noop
-	close(): void {
+	// biome-ignore lint/style/useThisInClassMethods: close is a noop
+		close(): void {
 		// noop
 	}
 
@@ -121,9 +115,18 @@ export class FT232HBus implements I2CBus {
 		return result
 	}
 
-	// biome-ignore lint/nursery/useThisInClassMethods: no impl
-	async sendByte(_address: I2CAddress, _byteValue: number): Promise<void> {
-		throw new Error('Method not implemented.')
+	async sendByte(address: I2CAddress, byteValue: number): Promise<void> {
+
+		//
+		const startAck = await sendAndReadACK(this.#device, I2CTemplate.startWithAddress(address, true))
+		if(!startAck) { throw new Error('start with address nack') }
+
+		//
+		const writeAck = await sendAndReadACK(this.#device, I2CTemplate.writeByte(byteValue))
+		if(!writeAck) { throw new Error('write data nack') }
+
+		//
+		await this.#device.sendData(I2CTemplate.stop())
 	}
 
 	async readI2cBlock(address: I2CAddress, cmd: I2CCommand, length: number, targetBuffer?: I2CBufferSource): Promise<I2CReadResult> {

package/src/mpsse/command.ts

@@ -14,7 +14,7 @@ export const SHIFT_COMMANDS_DEFINITION = {
 
 export type ShiftCommand = number
 
-export const SHIFT_COMMAND = {
+export const SHIFT_COMMAND = /** @type {const} */ ({
 	OUT_MSB_BYTES_POSITIVE_VE: 0x10, // WRITE_TDI
 	OUT_MSB_BYTES_NEGATIVE_VE: 0x11, // WRITE_TDI | WRITE_NEGATIVE_EDGE
 	OUT_MSB_BITS_POSITIVE_VE:  0x12, // WRITE_TDI | BIT_MODE
@@ -45,8 +45,7 @@ export const SHIFT_COMMAND = {
 	IN_OUT_LSB_BYTES_OUT_POSITIVE_IN_NEGATIVE_VE: 0x3C,
 	IN_OUT_LSB_BITS_OUT_NEGATIVE_IN_POSITIVE_VE: 0x3B,
 	IN_OUT_LSB_BITS_OUT_POSITIVE_IN_NEGATIVE_VE: 0x3E,
-
-}
+})
 
 // export const LSB_FIRST_TMS_COMMANDS = {
 // 	CLOCK_DATA_NO_READ_POSITIVE_VE: 0x4A,

package/src/mpsse/mpsse-template.ts

@@ -1,4 +1,5 @@
-/** biome-ignore-all lint/style/useConsistentArrayType: <explanation> */
+/** biome-ignore-all lint/style/useConsistentArrayType: miss-classified */
+/** biome-ignore-all lint/nursery/noMisleadingReturnType: false-positive */
 import {
 	CLOCK_DIVISOR_COMMANDS,
 	FT232H_ONLY_COMMANDS,
@@ -11,23 +12,39 @@ import {
 
 export class MPSSETemplate {
 	static shiftOutByte(command: ShiftCommand, length: number, data: number): Array<number> {
-		const lengthL = (length - 1) & 0x0F
-		const lengthH = ((length - 1) & 0xF0) >> 8
+		if(length <= 0) { throw new RangeError('can not read zero length') }
+		const lengthMinusOne = length - 1
+		const lengthL = lengthMinusOne & 0xFF
+		const lengthH = (lengthMinusOne >> 8) & 0xFF
 		return [ command, lengthL, lengthH, data ]
 	}
 
+	static shiftOutBytes(command: ShiftCommand, length: number, data: Array<number>): Array<number> {
+		if(length <= 0) { throw new RangeError('can not read zero length') }
+		const lengthMinusOne = length - 1
+		const lengthL = lengthMinusOne & 0xFF
+		const lengthH = (lengthMinusOne >> 8) & 0xFF
+		return [ command, lengthL, lengthH, ...data ]
+	}
+
 	static shiftInByte(command: ShiftCommand, length: number): Array<number> {
-		const lengthL = (length - 1) & 0x0F
-		const lengthH = ((length - 1) & 0xF0) >> 8
+		if(length <= 0) { throw new RangeError('can not read zero length') }
+		const lengthMinusOne = length - 1
+		const lengthL = lengthMinusOne & 0xFF
+		const lengthH = (lengthMinusOne >> 8) & 0xFF
 		return [ command, lengthL, lengthH ]
 	}
 
 	static shiftOutBits(command: ShiftCommand, length: number, data: number): Array<number> {
-		return [ command, length - 1, data ]
+		if(length <= 0) { throw new RangeError('can not read zero length') }
+		const lengthMinusOne = length - 1
+		return [ command, lengthMinusOne, data ]
 	}
 
 	static shiftInBits(command: ShiftCommand, length: number): Array<number> {
-		return [ command, length - 1 ]
+		if(length <= 0) { throw new RangeError('can not read zero length') }
+		const lengthMinusOne = length - 1
+		return [ command, lengthMinusOne ]
 	}
 
 	static gpioSetHigh(pins: number, directions: number): Array<number> {
@@ -54,9 +71,9 @@ export class MPSSETemplate {
 		return [ PIN_STATE_COMMANDS.READ_DATA_BITS_LOW_BYTE ]
 	}
 
-	static setClockDivisor(divider: number): Array<number> {
-		const divisorL = divider & 0xFF
-		const divisorH = (divider >> 8) & 0xFF
+	static setClockDivisor(divisor: number): Array<number> {
+		const divisorL = divisor & 0xFF
+		const divisorH = (divisor >> 8) & 0xFF
 
 		return [
 			CLOCK_DIVISOR_COMMANDS.SET_CLK_DIVISOR,

package/src/mpsse/mpsse.ts

@@ -1,4 +1,4 @@
-/** biome-ignore-all lint/style/useConsistentArrayType: <explanation> */
+/** biome-ignore-all lint/style/useConsistentArrayType: miss-classified */
 import type { FTDIDevice } from '../ftdi.ts'
 import { Util } from '../util.ts'
 import { BAD_COMMAND, BAD_COMMAND_RESPONSE } from './command.ts'
@@ -49,8 +49,8 @@ export class MPSSE {
 	}
 
 
-	async setClockDivisor(divider: number): Promise<void> {
-		const command = MPSSETemplate.setClockDivisor(divider)
+	async setClockDivisor(divisor: number): Promise<void> {
+		const command = MPSSETemplate.setClockDivisor(divisor)
 		return this.executeCommands(command)
 	}
 

package/src/spi/index.ts

@@ -0,0 +1,113 @@
+/** biome-ignore-all lint/style/noNestedTernary: we like them */
+import type {
+	SPIBus,
+	SPIOptions,
+	TransferRequest,
+	TransferResult,
+} from '@johntalton/and-other-delights'
+import { DEFAULT_SPI_MODE, MODE_0 } from '@johntalton/and-other-delights'
+import type { FTDIDevice } from '../ftdi.ts'
+import {
+	CLOCK_BASE_60,
+	CLOCK_DEFAULT_STANDARD_MODE_100_kHz,
+	Clock
+} from '../mpsse/clock.ts'
+import { H_COMMANDS, HOST_AND_MPSSE_MODE_COMMANDS, SHIFT_COMMAND } from '../mpsse/command.ts'
+import { MPSSETemplate } from '../mpsse/mpsse-template.ts'
+import { Util } from '../util.ts'
+
+
+// const CLOCK_PIN_MASK = 0b0000_0001
+// const MOSI_PIN_MASK =  0b0000_0010 // host out
+// const MISO_PIN_MASK =  0b0000_0100 // host in
+const CS0_PIN_MASK =   0b0000_1000
+
+// const CS1_PIN_MASK =    0b0001_0000
+// const LED_TX_PIN_MASK = 0b0010_0000
+// const LED_RX_PIN_MASK = 0b0100_0000
+// const CLOCK_MONITOR_PIN_MASK =   0b1000_0000
+
+const SPI_PIN_DIRECTION = 0b0000_1011
+
+export const delayMs = (ms: number): Promise<void> => new Promise(resolve => setTimeout(resolve, ms))
+
+export interface FT232HSPIOptions extends SPIOptions {
+	chipSelect1?: [boolean]
+	ledRxTx?: [boolean]
+}
+
+export class FTDISPIBus implements SPIBus {
+	readonly #device: FTDIDevice
+	readonly #options: Partial<FT232HSPIOptions>
+
+	constructor(device: FTDIDevice, options?: Partial<FT232HSPIOptions>) {
+		this.#device = device
+		this.#options = options ?? {}
+	}
+
+	async transfer(request: TransferRequest, options?: Partial<FT232HSPIOptions>): Promise<TransferResult> {
+		const {
+			mode, speedHz
+		} = {
+			mode: DEFAULT_SPI_MODE,
+			speedHz: CLOCK_DEFAULT_STANDARD_MODE_100_kHz,
+			...this.#options,
+			...(options ?? {})
+		}
+
+		const {
+			sendBuffer,
+			receiveBufferLength
+		} = request
+
+		if(mode !== MODE_0) { throw new Error('currently mode 0 only') }
+
+		const writeLength = sendBuffer?.byteLength ?? 0
+		const sendBufferU8 = (sendBuffer === undefined) ?
+			[] :
+			ArrayBuffer.isView(sendBuffer) ?
+				new Uint8Array(sendBuffer.buffer, sendBuffer.byteOffset, sendBuffer.byteLength) :
+				new Uint8Array(sendBuffer)
+
+		// calc clock divider for non-div-5
+		const divisor = Clock.clockDivisor(speedHz, CLOCK_BASE_60)
+
+		const totalBytesWritten = await this.#device.sendData(Uint8Array.from([
+			// preamble to set state
+			H_COMMANDS.DISABLE_CLOCK_DIVIDE_BY_FIVE,
+			...MPSSETemplate.setClockDivisor(divisor),
+			H_COMMANDS.DISABLE_THREE_PHASE_CLOCKING,
+			H_COMMANDS.DISABLE_ADAPTIVE_CLOCKING,
+
+			// prep pins
+			...MPSSETemplate.gpioSetLow(CS0_PIN_MASK, SPI_PIN_DIRECTION), // CS High / Clock Low
+			...MPSSETemplate.gpioSetLow(0, SPI_PIN_DIRECTION), // CS Low / Clock Low
+
+			// transfer data
+			...MPSSETemplate.shiftOutBytes(SHIFT_COMMAND.OUT_MSB_BYTES_NEGATIVE_VE, writeLength, [ ...sendBufferU8 ]),
+			...((receiveBufferLength === 0) ? [] : MPSSETemplate.shiftInByte(SHIFT_COMMAND.IN_MSB_BYTES_POSITIVE_VE, receiveBufferLength)),
+
+			// return pins to idle state
+			...MPSSETemplate.gpioSetLow(CS0_PIN_MASK, SPI_PIN_DIRECTION), // CS high / Clock Low
+
+			HOST_AND_MPSSE_MODE_COMMANDS.SEND_IMMEDIATE // do it now
+		]))
+
+		if(totalBytesWritten === 0) { throw new Error('no bytes written') }
+
+		if(receiveBufferLength === 0) {
+			return {
+				bytesWritten: writeLength
+			}
+		}
+
+		// consume buffer
+		const result = await Util.pollData(this.#device, receiveBufferLength)
+
+		return {
+			bytesWritten: writeLength,
+			readBuffer: result
+		}
+	}
+
+}

package/src/util.ts

@@ -1,7 +1,7 @@
-/** biome-ignore-all lint/performance/noAwaitInLoops: <explanation> */
-/** biome-ignore-all lint/style/useConsistentArrayType: <explanation> */
-import type { FTDIDevice } from "./ftdi.ts"
-import { STATUS_PREFIX_LENGTH } from "./status.ts"
+/** biome-ignore-all lint/performance/noAwaitInLoops: simplifies code */
+/** biome-ignore-all lint/style/useConsistentArrayType: miss-classified */
+import type { FTDIDevice } from './ftdi.ts'
+import { STATUS_PREFIX_LENGTH } from './status.ts'
 
 export interface ChipInfo {
 	major: number
@@ -57,14 +57,15 @@ export class Util {
 		return info
 	}
 
-	static async pollData(device: FTDIDevice, attempts = DEFAULT_MAX_POLL_ATTEMPTS): Promise<Uint8Array<ArrayBuffer>> {
+	static async pollData(device: FTDIDevice, length = DEFAULT_DATA_READ_SIZE, attempts = DEFAULT_MAX_POLL_ATTEMPTS): Promise<Uint8Array<ArrayBuffer>> {
+		// console.log('pollData', length)
 		for(let i = 0; i < attempts; i += 1) {
-			const response = await device.readData(DEFAULT_DATA_READ_SIZE)
-			if(response.byteLength === STATUS_PREFIX_LENGTH) { continue }
+			const response = await device.readData(STATUS_PREFIX_LENGTH + length)
 			if(response === undefined) { throw new Error('no response') }
+			if(response.byteLength === STATUS_PREFIX_LENGTH) { continue }
 			// const status = DeviceStatus.parse(response)
-			// console.log('attempts', i)
-			return new Uint8Array(response.buffer, STATUS_PREFIX_LENGTH)
+			// console.log('attempts', i, status)
+			return new Uint8Array(response.buffer, response.byteOffset + STATUS_PREFIX_LENGTH)
 		}
 
 		throw new Error('no valid data acquired')