149 lines
6.0 KiB
C
149 lines
6.0 KiB
C
/*
|
|
* Автомат UART-клиента логического анализатора Altera: запрос, накопление ответа и контроль
|
|
* времени. Одновременно выполняется одна операция; ARM нельзя безусловно повторять, поскольку
|
|
* повторный запуск меняет состояние захвата.
|
|
*/
|
|
|
|
#include "altera_logic.h"
|
|
#include <string.h>
|
|
typedef struct {
|
|
uint32_t state, error, clock_hz, elapsed, delay;
|
|
uint16_t config[5], channels, depth, trigger, count, offset;
|
|
uint16_t samples[4096];
|
|
uint8_t command, pending, flags, requested, rx[133];
|
|
size_t used;
|
|
} la_context;
|
|
static uint8_t checksum(const uint8_t *p, size_t n) {
|
|
uint8_t x = 0; size_t i;
|
|
for (i = 0; i < n; ++i) x ^= p[i];
|
|
return x;
|
|
}
|
|
static uint16_t u16(const uint8_t *p) {
|
|
return (uint16_t)((uint16_t)p[0] | ((uint16_t)p[1] << 8));
|
|
}
|
|
size_t la_context_size(void) { return sizeof(la_context); }
|
|
void la_init(void *ctx) {
|
|
la_context *s = (la_context *)ctx;
|
|
memset(s, 0, sizeof(*s)); s->command = 1; s->state = LA_CONNECTING;
|
|
}
|
|
void la_fail(void *ctx, uint32_t code) {
|
|
la_context *s = (la_context *)ctx;
|
|
s->state = LA_ERROR; s->error = code; s->pending = 0; s->command = 0;
|
|
}
|
|
int la_start(void *ctx, uint32_t div, uint32_t mask, uint32_t val,
|
|
uint32_t emask, uint32_t eval) {
|
|
la_context *s = (la_context *)ctx;
|
|
if ((s->state != LA_READY && s->state != LA_DONE) ||
|
|
div > 65535 || mask > 65535 || val > 65535 ||
|
|
emask > 65535 || eval > 65535 || ((val ^ eval) & mask & emask))
|
|
return LA_ARGUMENT;
|
|
s->config[0]=(uint16_t)div; s->config[1]=(uint16_t)mask;
|
|
s->config[2]=(uint16_t)val; s->config[3]=(uint16_t)emask;
|
|
s->config[4]=(uint16_t)eval;
|
|
s->state=LA_CAPTURING; s->error=0; s->flags=0; s->count=0;
|
|
s->offset=0; s->command=2; s->delay=0;
|
|
return LA_OK;
|
|
}
|
|
size_t la_next(void *ctx, uint8_t *out, size_t capacity) {
|
|
la_context *s = (la_context *)ctx; uint16_t arg = 0;
|
|
if (!out || capacity < 6 || !s->command || s->pending || s->delay) return 0;
|
|
if (s->command >= 2 && s->command <= 6) arg=s->config[s->command-2];
|
|
if (s->command == 9) {
|
|
arg=s->offset;
|
|
s->requested=(uint8_t)((s->depth-s->offset > 64) ? 64 : s->depth-s->offset);
|
|
}
|
|
out[0]=0xa5; out[1]=s->command; out[2]=(uint8_t)arg;
|
|
out[3]=(uint8_t)(arg >> 8); out[4]=(s->command == 9) ? s->requested : 0;
|
|
out[5]=checksum(out,5);
|
|
s->pending=1; s->elapsed=0; s->used=0;
|
|
return 6;
|
|
}
|
|
static void complete(la_context *s) {
|
|
size_t i;
|
|
if (checksum(s->rx,s->used)) { la_fail(s,LA_CHECKSUM); return; }
|
|
if (s->rx[2]) { la_fail(s,LA_DEVICE_ERROR); return; }
|
|
s->pending=0;
|
|
if (s->command == 1) {
|
|
s->channels=s->rx[3]; s->depth=u16(s->rx+4);
|
|
s->clock_hz=(uint32_t)s->rx[6]*1000000U;
|
|
if (s->channels != 16 || s->depth != 4096 || !s->clock_hz || s->rx[7]!=1) {
|
|
la_fail(s,LA_UNSUPPORTED); return;
|
|
}
|
|
s->state=LA_READY; s->command=0;
|
|
} else if (s->command < 7) ++s->command;
|
|
else if (s->command == 7) { s->command=8; s->delay=25; }
|
|
else if (s->command == 8) {
|
|
s->flags=s->rx[3]; s->trigger=u16(s->rx+4);
|
|
if (s->flags & 4) {
|
|
if (s->trigger >= s->depth || (s->flags & 1)) { la_fail(s,LA_BAD_FRAME); return; }
|
|
s->command=9;
|
|
} else s->delay=25;
|
|
} else {
|
|
for(i=0; i<s->requested; ++i) s->samples[s->offset+i]=u16(s->rx+4+i*2);
|
|
s->offset=(uint16_t)(s->offset+s->requested); s->count=s->offset;
|
|
if(s->offset == s->depth) { s->state=LA_DONE; s->command=0; }
|
|
}
|
|
}
|
|
void la_feed(void *ctx, const uint8_t *data, size_t size) {
|
|
la_context *s = (la_context *)ctx; size_t i, expected;
|
|
if (!data) return;
|
|
for(i=0; i<size; ++i) {
|
|
if(!s->pending || s->used >= sizeof(s->rx)) { la_fail(s,LA_BAD_FRAME); return; }
|
|
s->rx[s->used++]=data[i];
|
|
if(s->rx[0]!=0x5a || (s->used>=2 && s->rx[1]!=(s->command|0x80))) {
|
|
la_fail(s,LA_BAD_FRAME); return;
|
|
}
|
|
if(s->used<3) continue;
|
|
expected=4;
|
|
if(!s->rx[2]) {
|
|
if(s->command==1) expected=9;
|
|
else if(s->command==8) expected=7;
|
|
else if(s->command==9) {
|
|
if(s->used<4) continue;
|
|
if(s->rx[3]!=s->requested) { la_fail(s,LA_BAD_FRAME); return; }
|
|
expected=5U+2U*s->requested;
|
|
}
|
|
}
|
|
if(s->used==expected) complete(s);
|
|
}
|
|
}
|
|
void la_tick(void *ctx, uint32_t ms) {
|
|
la_context *s=(la_context *)ctx;
|
|
if(s->pending) {
|
|
if(ms >= 1000U-s->elapsed) la_fail(s,LA_TIMEOUT);
|
|
else s->elapsed+=ms;
|
|
}
|
|
s->delay=(ms >= s->delay) ? 0 : s->delay-ms;
|
|
}
|
|
uint32_t la_get(const void *ctx, uint32_t field) {
|
|
const la_context *s=(const la_context *)ctx;
|
|
switch(field) {
|
|
case LA_STATE:return s->state; case LA_ERROR_CODE:return s->error;
|
|
case LA_CHANNELS:return s->channels; case LA_DEPTH:return s->depth;
|
|
case LA_CLOCK_HZ:return s->clock_hz; case LA_FLAGS:return s->flags;
|
|
case LA_TRIGGER_INDEX:return s->trigger; case LA_READ_COUNT:return s->count;
|
|
case LA_DIVIDER:return s->config[0]; default:return 0;
|
|
}
|
|
}
|
|
size_t la_samples(const void *ctx, uint16_t *out, size_t capacity) {
|
|
const la_context *s=(const la_context *)ctx;
|
|
if(s->state!=LA_DONE || !out || capacity<s->count) return 0;
|
|
memcpy(out,s->samples,s->count*sizeof(uint16_t)); return s->count;
|
|
}
|
|
void la_demo_init(void *ctx) {
|
|
la_context *s=(la_context *)ctx; la_init(s);
|
|
s->channels=16; s->depth=4096; s->clock_hz=50000000;
|
|
s->state=LA_READY; s->command=0;
|
|
}
|
|
int la_demo_capture(void *ctx, uint32_t divider) {
|
|
la_context *s=(la_context *)ctx; size_t i, bit;
|
|
int rc=la_start(s,divider,0,0,0,0); if(rc) return rc;
|
|
for(i=0;i<4096;++i) {
|
|
uint16_t v=0;
|
|
for(bit=0;bit<16;++bit) if(((i/(4U+bit*7U))&1U)!=0) v|=(uint16_t)(1U<<bit);
|
|
s->samples[i]=v;
|
|
}
|
|
s->trigger=2048; s->flags=6; s->count=4096; s->command=0; s->state=LA_DONE;
|
|
return LA_OK;
|
|
}
|