138 lines
3.3 KiB
Dart
138 lines
3.3 KiB
Dart
import 'dart:typed_data';
|
|
|
|
import 'package:abawo_bt_app/model/shifter_types.dart';
|
|
|
|
const int _startPayloadLength = 11;
|
|
|
|
class DfuStartPayload {
|
|
const DfuStartPayload({
|
|
required this.totalLength,
|
|
required this.imageCrc32,
|
|
required this.sessionId,
|
|
required this.flags,
|
|
});
|
|
|
|
final int totalLength;
|
|
final int imageCrc32;
|
|
final int sessionId;
|
|
final int flags;
|
|
}
|
|
|
|
class DfuDataFrame {
|
|
const DfuDataFrame({
|
|
required this.sequence,
|
|
required this.offset,
|
|
required this.payloadLength,
|
|
required this.bytes,
|
|
});
|
|
|
|
final int sequence;
|
|
final int offset;
|
|
final int payloadLength;
|
|
final Uint8List bytes;
|
|
}
|
|
|
|
class DfuProtocol {
|
|
const DfuProtocol._();
|
|
|
|
static Uint8List encodeStartPayload(DfuStartPayload payload) {
|
|
final data = ByteData(_startPayloadLength);
|
|
data.setUint8(0, universalShifterDfuOpcodeStart);
|
|
data.setUint32(1, payload.totalLength, Endian.little);
|
|
data.setUint32(5, payload.imageCrc32, Endian.little);
|
|
data.setUint8(9, payload.sessionId);
|
|
data.setUint8(10, payload.flags);
|
|
return data.buffer.asUint8List();
|
|
}
|
|
|
|
static Uint8List encodeFinishPayload() {
|
|
return Uint8List.fromList([universalShifterDfuOpcodeFinish]);
|
|
}
|
|
|
|
static Uint8List encodeAbortPayload() {
|
|
return Uint8List.fromList([universalShifterDfuOpcodeAbort]);
|
|
}
|
|
|
|
static List<DfuDataFrame> buildDataFrames(
|
|
List<int> imageBytes, {
|
|
int startSequence = 0,
|
|
}) {
|
|
final frames = <DfuDataFrame>[];
|
|
var seq = _asU8(startSequence);
|
|
var offset = 0;
|
|
while (offset < imageBytes.length) {
|
|
final remaining = imageBytes.length - offset;
|
|
final chunkLength = remaining < universalShifterDfuFramePayloadSizeBytes
|
|
? remaining
|
|
: universalShifterDfuFramePayloadSizeBytes;
|
|
|
|
final frame = Uint8List(universalShifterDfuFrameSizeBytes);
|
|
frame[0] = seq;
|
|
frame.setRange(1, 1 + chunkLength, imageBytes, offset);
|
|
|
|
frames.add(
|
|
DfuDataFrame(
|
|
sequence: seq,
|
|
offset: offset,
|
|
payloadLength: chunkLength,
|
|
bytes: frame,
|
|
),
|
|
);
|
|
|
|
offset += chunkLength;
|
|
seq = nextSequence(seq);
|
|
}
|
|
|
|
return frames;
|
|
}
|
|
|
|
static int nextSequence(int sequence) {
|
|
return _asU8(sequence + 1);
|
|
}
|
|
|
|
static int rewindSequenceFromAck(int acknowledgedSequence) {
|
|
return nextSequence(acknowledgedSequence);
|
|
}
|
|
|
|
static int sequenceDistance(int from, int to) {
|
|
return _asU8(to - from);
|
|
}
|
|
|
|
static int parseAckPayload(List<int> payload) {
|
|
if (payload.length != 1) {
|
|
throw const FormatException('ACK payload must be exactly 1 byte.');
|
|
}
|
|
return _asU8(payload.first);
|
|
}
|
|
|
|
static const int crc32Initial = 0xFFFFFFFF;
|
|
static const int _crc32PolynomialReflected = 0xEDB88320;
|
|
|
|
static int crc32Update(int crc, List<int> bytes) {
|
|
var next = crc & 0xFFFFFFFF;
|
|
for (final byte in bytes) {
|
|
next ^= byte;
|
|
for (var bit = 0; bit < 8; bit++) {
|
|
if ((next & 0x1) != 0) {
|
|
next = (next >> 1) ^ _crc32PolynomialReflected;
|
|
} else {
|
|
next >>= 1;
|
|
}
|
|
}
|
|
}
|
|
return next & 0xFFFFFFFF;
|
|
}
|
|
|
|
static int crc32Finalize(int crc) {
|
|
return (crc ^ 0xFFFFFFFF) & 0xFFFFFFFF;
|
|
}
|
|
|
|
static int crc32(List<int> bytes) {
|
|
return crc32Finalize(crc32Update(crc32Initial, bytes));
|
|
}
|
|
|
|
static int _asU8(int value) {
|
|
return value & 0xFF;
|
|
}
|
|
}
|