#define S11_RAW 0 // 1 habilita log RAW; nao altera a aquisicao
// S11 GERADA por ferramentas/gerar_matriz19_eletrica.py
#define DUPLEX88 1
#include <Arduino.h>
// firmware/core/curva_velocity.h
// GERADO por gerar_midi_roll.py: log 500..120000 us, gamma=1.0.
// Limiar inteiro de arredondamento: sem log/pow/float no caminho RP2040.
#ifndef CURVA_VELOCITY_H
#define CURVA_VELOCITY_H
#include <stdint.h>
static const uint32_t curva_limite[128]={
0,120000,117418,112420,107635,103053,98667,94467,
90446,86596,82910,79381,76002,72767,69670,66705,
63865,61147,58544,56052,53666,51382,49195,47101,
45096,43177,41339,39579,37894,36281,34737,33259,
31843,30487,29190,27947,26758,25619,24528,23484,
22485,21528,20611,19734,18894,18090,17320,16582,
15877,15201,14554,13934,13341,12773,12230,11709,
11211,10733,10276,9839,9420,9019,8635,8268,
7916,7579,7256,6947,6652,6368,6097,5838,
5589,5351,5124,4905,4697,4497,4305,4122,
3947,3779,3618,3464,3316,3175,3040,2910,
2787,2668,2554,2446,2341,2242,2146,2055,
1967,1884,1804,1727,1653,1583,1515,1451,
1389,1330,1273,1219,1167,1118,1070,1024,
981,939,899,861,824,789,755,723,
692,663,635,608,582,557,533,510,
};
static const uint32_t curva_inversa[128]={
0,120000,114892,110002,105320,100837,96545,92435,
88501,84734,81127,77674,74368,71202,68172,65270,
62492,59832,57285,54847,52512,50277,48137,46088,
44126,42248,40450,38728,37080,35501,33990,32544,
31158,29832,28562,27347,26183,25068,24001,22979,
22001,21065,20168,19310,18488,17701,16948,16226,
15535,14874,14241,13635,13055,12499,11967,11458,
10970,10503,10056,9628,9218,8826,8450,8090,
7746,7416,7101,6798,6509,6232,5967,5713,
5470,5237,5014,4800,4596,4400,4213,4034,
3862,3698,3540,3390,3245,3107,2975,2848,
2727,2611,2500,2393,2292,2194,2101,2011,
1926,1844,1765,1690,1618,1549,1483,1420,
1360,1302,1246,1193,1143,1094,1047,1003,
960,919,880,843,807,772,740,708,
678,649,621,595,570,545,522,500,
};
static inline uint8_t curva_velocity(uint32_t dt){
if(dt<=500)return 127;if(dt>=120000)return 1;
unsigned lo=1,hi=127;
while(lo<hi){unsigned mid=(lo+hi+1)/2;if(dt<=curva_limite[mid])lo=mid;else hi=mid-1;}
return lo;
}
static inline uint32_t curva_tempo(uint8_t v){if(v<1)v=1;if(v>127)v=127;return curva_inversa[v];}
#endif
// firmware/core/tecla_log.h
#include <stdint.h>
// Contatos normalizados: bit 0=C1, bit 1=C2; 1 significa fechado.
// Nenhuma dependência de GPIO, matriz, Arduino ou transporte.
namespace piano {
constexpr uint32_t CONFIRMA_US = 200; // hipótese para simulação, não debounce medido
constexpr uint32_t TIMEOUT_US = 2000000;
enum class Estado : uint8_t { ESPERA_ABERTURA, PRONTA, PERCURSO,
CONFIRMA_ATAQUE, PRESSIONADA, CONFIRMA_SOLTURA, RETORNO };
enum class Tipo : uint8_t { NENHUM, ON, OFF, FALHA, OFF_FALHA };
struct Evento { Tipo tipo=Tipo::NENHUM; uint32_t dt=0; uint8_t velocity=0; };
// Curva S7: 0,5..120ms, logaritmica, gerada em tabela inteira.
// Mesma FSM S1, sem alterar as referencias anteriores. Calibracao ainda hipotetica.
inline uint8_t velocity(uint32_t dt) { return curva_velocity(dt); }
struct Tecla {
Estado estado=Estado::ESPERA_ABERTURA;
uint32_t mudou=0,t1=0,t2=0,soltou=0;
uint8_t anterior=255;
Evento ler(uint8_t raw,uint32_t agora) {
raw &= 3;
if(raw!=anterior) { anterior=raw; mudou=agora; }
const bool estavel=uint32_t(agora-mudou)>=CONFIRMA_US;
Evento e;
switch(estado) {
case Estado::ESPERA_ABERTURA:
case Estado::RETORNO:
if(raw==0 && estavel) estado=Estado::PRONTA;
break;
case Estado::PRONTA:
if(raw==1) {t1=agora; estado=Estado::PERCURSO;}
else if(raw) {estado=Estado::ESPERA_ABERTURA; e.tipo=Tipo::FALHA;}
break;
case Estado::PERCURSO:
if(raw==0) estado=Estado::ESPERA_ABERTURA;
else if(raw==2 || uint32_t(agora-t1)>=TIMEOUT_US) {
estado=Estado::ESPERA_ABERTURA; e.tipo=Tipo::FALHA;
} else if(raw==3) {t2=agora; estado=Estado::CONFIRMA_ATAQUE;}
break;
case Estado::CONFIRMA_ATAQUE:
if(raw==1) estado=Estado::PERCURSO;
else if(raw!=3) {estado=Estado::ESPERA_ABERTURA; e.tipo=Tipo::FALHA;}
else if(estavel) {
e.dt=uint32_t(t2-t1);
if(e.dt==0 || e.dt>=TIMEOUT_US) {
e.tipo=Tipo::FALHA; estado=Estado::ESPERA_ABERTURA;
} else {e.tipo=Tipo::ON; e.velocity=velocity(e.dt); estado=Estado::PRESSIONADA;}
}
break;
case Estado::PRESSIONADA:
if(raw==2) {e.tipo=Tipo::OFF_FALHA; estado=Estado::RETORNO;}
else if(!(raw&2)) {soltou=agora; estado=Estado::CONFIRMA_SOLTURA;}
break;
case Estado::CONFIRMA_SOLTURA:
if(raw==3) estado=Estado::PRESSIONADA;
else if(raw==2) {e.tipo=Tipo::OFF_FALHA; estado=Estado::RETORNO;}
else if(uint32_t(agora-soltou)>=CONFIRMA_US) {
e.tipo=Tipo::OFF; e.velocity=64; estado=Estado::RETORNO;
}
break;
}
return e;
}
};
// Pula apenas leituras que nao alteram estado nem timestamp de estabilidade.
inline bool leituraEstavelSemPrazo(const Tecla &k,uint8_t raw){
return (raw==0 && k.estado==Estado::PRONTA) || (raw==3 && k.estado==Estado::PRESSIONADA) ||
(raw!=0 && raw==k.anterior && (k.estado==Estado::ESPERA_ABERTURA || k.estado==Estado::RETORNO));
}
struct Mensagem { uint8_t b[3]; };
// Único produtor/consumidor no foreground. Cada ON admitido reserva seu OFF.
template<unsigned CAP=256> struct Midi {
Mensagem fila[CAP]{};
bool ativas[128]{};
bool pedal=false;
unsigned inicio=0,fim=0,n=0,reservas=0,rejeitadas=0;
void inserir(uint8_t a,uint8_t b,uint8_t c) {
fila[fim]={{a,b,c}}; fim=(fim+1)%CAP; ++n;
}
bool on(uint8_t nota,uint8_t vel) {
if(nota>127 || ativas[nota] || n+reservas+2>CAP) {++rejeitadas;return false;}
inserir(0x90,nota,vel); ativas[nota]=true; ++reservas; return true;
}
bool off(uint8_t nota) {
if(nota>127 || !ativas[nota]) return false;
--reservas; inserir(0x80,nota,64); ativas[nota]=false; return true;
}
bool sustain(bool novo) {
if(novo==pedal) return true;
if(novo) {
if(n+reservas+2>CAP) {++rejeitadas;return false;}
inserir(0xB0,64,127); ++reservas; pedal=true;
} else { --reservas; inserir(0xB0,64,0); pedal=false; }
return true;
}
void panico() { for(unsigned i=0;i<128;++i) off(i); sustain(false); }
bool retirar(Mensagem &m) {
if(!n) return false;
m=fila[inicio]; inicio=(inicio+1)%CAP; --n; return true;
}
};
} // namespace piano
// firmware/core/testes_log.h
// Executa o mesmo módulo usado nos GPIO. Relógio sintético só nestes testes.
namespace piano {
struct ResultadoTestes { unsigned passou=0,falhou=0; };
inline ResultadoTestes testar() {
ResultadoTestes r;
auto check=[&](bool ok) { if(ok) ++r.passou; else ++r.falhou; };
auto preparar=[](Tecla &k,uint32_t t=0) { k.ler(0,t); k.ler(0,t+200); };
Tecla k; preparar(k);
check(k.estado==Estado::PRONTA);
k.ler(1,1000); k.ler(3,4000);
check(k.ler(3,4150).tipo==Tipo::NENHUM);
auto e=k.ler(3,4200);
check(e.tipo==Tipo::ON && e.dt==3000 && e.velocity==86);
check(k.ler(3,5000).tipo==Tipo::NENHUM);
k.ler(1,5100); check(k.ler(1,5300).tipo==Tipo::OFF);
k.ler(3,5400); check(k.ler(3,6000).tipo==Tipo::NENHUM);
k.ler(0,6100); k.ler(0,6300); check(k.estado==Estado::PRONTA);
check(k.ler(3,7000).tipo==Tipo::FALHA); // salto 00->11
preparar(k,8000); check(k.ler(2,9000).tipo==Tipo::FALHA);
k=Tecla{}; k.ler(3,0); check(k.ler(3,10000).tipo==Tipo::NENHUM);
preparar(k,11000); k.ler(1,12000); k.ler(0,12050);
check(k.ler(3,13000).tipo==Tipo::NENHUM); // ataque abortado não reaproveita t1
k=Tecla{}; preparar(k); k.ler(1,1000); k.ler(3,3000);
k.ler(1,3050); k.ler(3,4000); e=k.ler(3,4200);
check(e.tipo==Tipo::ON && e.dt==3000); // C2 pulsou: usa novo candidato
check(k.ler(2,5000).tipo==Tipo::OFF_FALHA);
k=Tecla{}; preparar(k); k.ler(1,1000);
check(k.ler(1,2001000).tipo==Tipo::FALHA);
k=Tecla{}; preparar(k,0xfffff000u);
k.ler(1,0xffffff00u); k.ler(3,0x00000ab8u); e=k.ler(3,0x00000b80u);
check(e.tipo==Tipo::ON && e.dt==3000); // wrap 32 bits
check(velocity(0)==127 && velocity(120001)==1);
bool monotona=true; for(uint32_t t=1;t<130000;++t)
if(velocity(t)>velocity(t-1) || velocity(t)==0) monotona=false;
check(monotona);
Midi<8> q;
for(unsigned i=0;i<4;++i) check(q.on(60+i,100));
check(!q.on(70,100) && q.reservas==4);
for(unsigned i=0;i<4;++i) check(q.off(60+i));
check(q.n==8 && q.reservas==0);
Mensagem m; bool ordem=true;
for(unsigned i=0;i<8;++i) {
if(!q.retirar(m) || m.b[0]!=(i<4?0x90:0x80) || m.b[1]!=60+i%4) ordem=false;
}
check(ordem && q.n==0);
check(q.sustain(true)); q.panico();
check(!q.pedal && q.reservas==0 && q.n==2);
// 88 estados independentes + FIFO dimensionada; não mede carga de CPU.
Tecla todas[88]; Midi<> grande; bool oitenta=true;
for(unsigned i=0;i<88;++i) {
preparar(todas[i]); todas[i].ler(1,1000); todas[i].ler(3,9000);
e=todas[i].ler(3,9200);
if(e.tipo!=Tipo::ON || !grande.on(21+i,e.velocity)) oitenta=false;
}
grande.panico();
check(oitenta && grande.n==176 && grande.reservas==0);
return r;
}
} // namespace piano
// firmware/core/tecla_faseada.h
// Adaptador S4: confirma por quadros completos, preserva instantes por contato.
// Não altera o núcleo nem as referências S1/S2/S3.
namespace piano {
struct TeclaFaseada {
Tecla nucleo;
uint32_t quadroT1=0,quadroT2=0;
Evento ler(uint8_t raw,uint32_t fim,uint32_t tC1,uint32_t tC2) {
Estado antes=nucleo.estado;
Evento e=nucleo.ler(raw,fim);
if(antes==Estado::PRONTA && nucleo.estado==Estado::PERCURSO) {
nucleo.t1=tC1;quadroT1=fim;
}
if(antes==Estado::PERCURSO && nucleo.estado==Estado::CONFIRMA_ATAQUE) {
nucleo.t2=tC2;quadroT2=fim;
}
return e;
}
};
inline ResultadoTestes testarFaseada() {
ResultadoTestes r;TeclaFaseada k;
k.ler(0,60,0,40);k.ler(0,300,240,280);
k.ler(1,1060,1000,1040); // C1 foi lido 60us antes de concluir o quadro
k.ler(3,4100,4040,4080); // C2 foi lido 20us antes de concluir o quadro
Evento e=k.ler(3,4340,4280,4320);
bool ok=e.tipo==Tipo::ON && e.dt==3080 && k.quadroT2-k.quadroT1==3040;
if(ok)++r.passou;else ++r.falhou;
k.ler(1,4420,4360,4400);e=k.ler(0,4660,4600,4640);
if(e.tipo==Tipo::OFF)++r.passou;else ++r.falhou;
// Mesmo teste atravessando wrap uint32_t de microssegundos.
k=TeclaFaseada{};k.ler(0,0xfffff000u,0xffffefc4u,0xffffefecu);
k.ler(0,0xfffff100u,0xfffff0c4u,0xfffff0ecu);
k.ler(1,0xffffff3cu,0xffffff00u,0xffffff28u);
k.ler(3,0x00000b30u,0x00000af4u,0x00000b1cu);
e=k.ler(3,0x00000c20u,0x00000be4u,0x00000c0cu);
if(e.tipo==Tipo::ON && e.dt==3100)++r.passou;else ++r.falhou;
return r;
}
} // namespace piano
// firmware/pio/matriz19_eletrica.h
#include <hardware/pio.h>
#include <hardware/pio_instructions.h>
#include <hardware/dma.h>
#include <hardware/clocks.h>
#include <hardware/regs/pio.h>
#include <hardware/regs/dma.h>
#include <hardware/sync.h>
#include <pico/time.h>
namespace captura {
constexpr uint32_t PERIODO_US=7,FASE_LEITURA_US=5,FASE_LEITURA_NS=5200;
constexpr uint32_t LIMITE_DMA=0xfffffffeu,MASCARA_NOS=(1u<<19)-1;
constexpr unsigned TAM=4096,FASES=32;
alignas(16384) volatile uint32_t dados[TAM];
PIO pio=pio0;int sm=-1,canal=-1;unsigned offset=0;
uint32_t consumidas=0,epoca=0,janelaEpoca=0,maiorBacklog=0;
uint32_t recuperacoes=0,overruns=0,stalls=0,fins=0,pacotes=0;
bool pronta=false;
// As 20 instrucoes correspondem a matriz19_direta.pio.
const uint16_t instrucoes[]={
uint16_t(pio_encode_mov_not(pio_y,pio_null)|pio_encode_sideset(1,1)),
uint16_t(pio_encode_set(pio_x,1)|pio_encode_sideset(1,1)),
uint16_t(pio_encode_mov(pio_osr,pio_null)|pio_encode_sideset(1,1)),
uint16_t(pio_encode_out(pio_pindirs,19)|pio_encode_sideset(1,1)),
uint16_t(pio_encode_nop()|pio_encode_sideset(1,1)|pio_encode_delay(4)),
uint16_t(pio_encode_mov(pio_osr,pio_x)|pio_encode_sideset(1,1)),
uint16_t(pio_encode_out(pio_pindirs,19)),
uint16_t(pio_encode_nop()|pio_encode_delay(13)),
uint16_t(pio_encode_mov(pio_isr,pio_y)),
uint16_t(pio_encode_push(false,true)),
uint16_t(pio_encode_set(pio_pins,1)),
uint16_t(pio_encode_mov(pio_isr,pio_pins)),
uint16_t(pio_encode_push(false,true)),
uint16_t(pio_encode_set(pio_pins,0)),
uint16_t(pio_encode_mov(pio_osr,pio_x)),
uint16_t(pio_encode_out(pio_null,31)),
uint16_t(pio_encode_mov(pio_isr,pio_x)),
uint16_t(pio_encode_in(pio_osr,1)),
uint16_t(pio_encode_mov(pio_x,pio_isr)),
uint16_t(pio_encode_jmp_y_dec(2))
};
const pio_program programa={instrucoes,20,-1};
pio_sm_config cfg;dma_channel_config dcfg;
inline uint32_t produzidas(){
uint32_t n=LIMITE_DMA-dma_channel_hw_addr(canal)->transfer_count;__dmb();return n;
}
inline void reiniciar(){
pio_sm_set_enabled(pio,sm,false);dma_channel_abort(canal);
pio_sm_init(pio,sm,offset,&cfg);pio_sm_clear_fifos(pio,sm);
// Todos os latches de dados permanecem LOW. So PINDIRS seleciona um sink.
pio_sm_set_pins_with_mask(pio,sm,1u<<19,MASCARA_NOS|(1u<<19)|(1u<<22));
pio_sm_set_consecutive_pindirs(pio,sm,0,19,false);
pio_sm_set_consecutive_pindirs(pio,sm,19,1,true);
pio_sm_set_consecutive_pindirs(pio,sm,22,1,true);
pio->fdebug=1u<<(PIO_FDEBUG_RXSTALL_LSB+sm);consumidas=0;
dma_channel_configure(canal,&dcfg,(void*)dados,&pio->rxf[sm],LIMITE_DMA,true);
pio_sm_clkdiv_restart(pio,sm);epoca=time_us_32();pio_sm_set_enabled(pio,sm,true);
janelaEpoca=time_us_32()-epoca+5;
}
inline bool iniciar(){
sm=pio_claim_unused_sm(pio,false);canal=dma_claim_unused_channel(false);
if(sm<0||canal<0||!pio_can_add_program(pio,&programa))return false;
offset=pio_add_program(pio,&programa);cfg=pio_get_default_sm_config();
sm_config_set_wrap(&cfg,offset+2,offset+19);
sm_config_set_out_pins(&cfg,0,19);sm_config_set_out_shift(&cfg,true,false,32);
sm_config_set_in_pins(&cfg,0);sm_config_set_in_shift(&cfg,false,false,32);
sm_config_set_set_pins(&cfg,22,1);
sm_config_set_sideset(&cfg,1,false,false);sm_config_set_sideset_pins(&cfg,19);
sm_config_set_fifo_join(&cfg,PIO_FIFO_JOIN_RX);
sm_config_set_clkdiv(&cfg,float(clock_get_hz(clk_sys))/5000000.0f);
for(unsigned p=0;p<=19;++p){pio_gpio_init(pio,p);if(p<19)gpio_disable_pulls(p);}
pio_gpio_init(pio,22);
dcfg=dma_channel_get_default_config(canal);
channel_config_set_transfer_data_size(&dcfg,DMA_SIZE_32);
channel_config_set_read_increment(&dcfg,false);channel_config_set_write_increment(&dcfg,true);
channel_config_set_ring(&dcfg,true,14);channel_config_set_dreq(&dcfg,pio_get_dreq(pio,sm,false));
reiniciar();pronta=true;return true;
}
inline unsigned falha(){
if(!pronta)return 0;
uint32_t pendentes=produzidas()-consumidas;if(pendentes>maiorBacklog)maiorBacklog=pendentes;
if(pio->fdebug&(1u<<(PIO_FDEBUG_RXSTALL_LSB+sm)))return 2;
if(dma_channel_hw_addr(canal)->ctrl_trig&DMA_CH0_CTRL_TRIG_AHB_ERROR_BITS)return 4;
if(!dma_channel_hw_addr(canal)->transfer_count)return 3;
if(pendentes>=TAM-2)return 1;return 0;
}
inline bool retirar(uint32_t &tick,uint32_t &gpio){
if(!pronta||produzidas()-consumidas<2)return false;
uint32_t c=consumidas,y=dados[c&(TAM-1)];gpio=dados[(c+1)&(TAM-1)];__dmb();
if(produzidas()-c>=TAM-2)return false;
tick=~y;consumidas=c+2;++pacotes;return true;
}
} // namespace captura
// firmware/pico_matriz19_eletrica.cpp
// S11: 19 nos fisicos duplex; toda selecao/direcao/temporizacao pertence a PIO.
#include <Arduino.h>
#include <hardware/uart.h>
#include <pico/time.h>
#include <stdarg.h>
#include <stdio.h>
piano::TeclaFaseada teclas[88];piano::Midi<> midi;
uint32_t q[32]={},tq[32]={},ultimoTick=0,quadros=0;
uint32_t onTotal=0,offTotal=0,invalidas=0,dropLog=0;
uint32_t proximoStatus=0;bool temTick=false;
uint32_t rawAnterior[32]={};bool rawValida[32]={};
bool pRaw=false,pOld=false;uint32_t pDesde=0;
bool coberturaOn[88]={},coberturaOff[88]={};
char logs[16384];unsigned li=0,lo=0;
void logLinha(const char *fmt,...) {
char s[200];va_list a;va_start(a,fmt);int n=vsnprintf(s,sizeof(s),fmt,a);va_end(a);
if(n<=0)return;unsigned z=unsigned(n)<sizeof(s)?n:sizeof(s)-1;
if(z>(lo+sizeof(logs)-li-1)%sizeof(logs)){++dropLog;return;}
for(unsigned i=0;i<z;++i){logs[li]=s[i];li=(li+1)%sizeof(logs);}
}
void servicos() {
static piano::Mensagem m;static unsigned pos=3;
if(pos==3 && midi.retirar(m))pos=0;
while(pos<3 && uart_is_writable(uart1))uart_putc_raw(uart1,m.b[pos++]);
for(unsigned i=0;i<32 && lo!=li && uart_is_writable(uart0);++i){uart_putc_raw(uart0,logs[lo]);lo=(lo+1)%sizeof(logs);}
}
void cancelar() {
for(unsigned k=0;k<88;++k)if(midi.ativas[21+k]){++offTotal;coberturaOff[k]=true;}
midi.panico();pRaw=pOld=false;pDesde=0;for(auto &k:teclas)k=piano::TeclaFaseada{};
}
void quadro() {
++quadros;uint8_t raw[90]={};uint32_t t1[88],t2[88];
// Sem divisao inteira por tecla: evita custo repetido de divisao no Cortex-M0+ (RP2040 tem divisor SIO).
for(unsigned r=0,k=0;r<(DUPLEX88?9u:15u);++r){
for(unsigned c=0;c<(DUPLEX88?10u:6u);++c,++k){
#if DUPLEX88
raw[k]=((!(q[r]&(1u<<(9+c))))?1:0)|((!(q[9+c]&(1u<<r)))?2:0);
if(k<88){t1[k]=tq[r];t2[k]=tq[9+c];}
#else
if(k<88){raw[k]=((~q[r])>>(2*c))&3;t1[k]=t2[k]=tq[r];}
#endif
}
}
uint32_t fim=tq[captura::FASES-1];
// Todos os pares observados seguem para a FSM, sem veto por combinacao de teclas.
for(unsigned k=0;k<88;++k){
// Estado estavel: nao ha prazo pendente nem mudanca a processar.
if(piano::leituraEstavelSemPrazo(teclas[k].nucleo,raw[k]))continue;
auto e=teclas[k].ler(raw[k],fim,t1[k],t2[k]);
if(e.tipo==piano::Tipo::ON){bool ok=midi.on(21+k,e.velocity);if(ok){++onTotal;coberturaOn[k]=true;}
logLinha("ON n=%u dt=%lu v=%u ok=%u t1=%lu t2=%lu\n",21+k,(unsigned long)e.dt,e.velocity,ok,(unsigned long)teclas[k].nucleo.t1,(unsigned long)teclas[k].nucleo.t2);
}else if(e.tipo==piano::Tipo::OFF || e.tipo==piano::Tipo::OFF_FALHA){if(midi.off(21+k)){++offTotal;coberturaOff[k]=true;}logLinha("OFF n=%u t=%lu\n",21+k,(unsigned long)fim);}
if(e.tipo==piano::Tipo::FALHA || e.tipo==piano::Tipo::OFF_FALHA){++invalidas;logLinha("INVALIDA n=%u raw=%u\n",21+k,raw[k]);}
}
// IN_BASE=0: GP21 aparece no bit21, independentemente da direcao dos nos.
bool p=!(q[captura::FASES-1]&(1u<<21));if(p!=pRaw){pRaw=p;pDesde=fim;}
if(p!=pOld && uint32_t(fim-pDesde)>=5000 && midi.sustain(p)){pOld=p;logLinha("CC64=%u\n",p?127:0);}
}
void status() {
unsigned nOn=0,nOff=0,ativas=0;for(unsigned k=0;k<88;++k){nOn+=coberturaOn[k];nOff+=coberturaOff[k];ativas+=midi.ativas[21+k];}
logLinha("STAT ON=%lu OFF=%lu cobertura=%u/%u ativas=%u inv=%lu rec=%lu stall=%lu back=%lu dropON=%u dropLOG=%lu frames=%lu\n",
(unsigned long)onTotal,(unsigned long)offTotal,nOn,nOff,ativas,(unsigned long)invalidas,
(unsigned long)captura::recuperacoes,(unsigned long)captura::stalls,(unsigned long)captura::maiorBacklog,midi.rejeitadas,(unsigned long)dropLog,(unsigned long)quadros);
}
void setup() {
set_sys_clock_khz(125000,true);uart_init(uart0,115200);gpio_set_function(28,GPIO_FUNC_UART); // GP0..18 pertencem exclusivamente a PIO
uart_init(uart1,31250);gpio_set_function(20,GPIO_FUNC_UART);uart_set_format(uart1,8,1,UART_PARITY_NONE);uart_set_fifo_enabled(uart1,false);
gpio_init(21);gpio_pull_up(21);gpio_init(25);gpio_set_dir(25,GPIO_OUT);
logLinha("S11 MODELO DC 3V3 4K VF650: RAW recebe circuito calculado; limiar nominal configuravel; sem veto topologico\n");
auto r=piano::testar();auto f=piano::testarFaseada();
logLinha("PIANO 88 %s / 176 contatos internos / modelo logico C\n",DUPLEX88?"S11 DUPLEX MODELO DC 3V3 4K VF650":"S8 NAO UTILIZADO");
logLinha("SELFTEST core=%u/%u faseada=%u/%u\n",r.passou,r.falhou,f.passou,f.falhou);
logLinha("CURVA log gamma=1: 500us=127, 120000us=1; MIDI 1..127; estimativa de velocidade\n");
if(!captura::iniciar())logLinha("FALHA_FATAL PIO/DMA\n");
logLinha("PIO: 1 SM, 20 instrucoes, 5MHz, 35 ciclos/passo=7us, %u fases=%uus; captura=7*tick+5.2us; CPU usa offset inteiro 5us; DMA 16KiB; IRQ/amostra=0\n",captura::FASES,captura::FASES*captura::PERIODO_US);
logLinha("GP0..18=nos LOW/Hi-Z; GP19=BLANK; GP22=SAMPLE; GP28=log TX; sem decoder. FSM/velocity/MIDI na CPU; USB e hardware pendentes.\n");
proximoStatus=time_us_32()+1000000;
}
void loop() {
unsigned erro=captura::falha();
if(erro){if(erro==1)++captura::overruns;if(erro==2)++captura::stalls;if(erro==3)++captura::fins;cancelar();temTick=false;++captura::recuperacoes;logLinha("RECUPERACAO erro=%u\n",erro);captura::reiniciar();}
for(unsigned i=0;i<64 && !captura::falha();++i){
uint32_t tick,g;if(!captura::retirar(tick,g))break;
unsigned fase=tick&(captura::FASES-1);
if((temTick && tick!=ultimoTick+1) || ((fase<19)?bool(g&(1u<<fase)):((g&captura::MASCARA_NOS)!=captura::MASCARA_NOS))){cancelar();temTick=false;++captura::recuperacoes;logLinha("RECUPERACAO sequencia\n");captura::reiniciar();break;}
uint32_t low=(~g)&captura::MASCARA_NOS;
if(fase<19)low&=~(1u<<fase); // retirar somente o sink, preservando as leituras propagadas
if(S11_RAW && fase<19 && (!rawValida[fase] || rawAnterior[fase]!=low))
logLinha("RAW fase=%u low=%05lx tick=%lu\n",fase,(unsigned long)low,(unsigned long)tick);
rawValida[fase]=true;rawAnterior[fase]=low;
q[fase]=g;tq[fase]=tick*captura::PERIODO_US+captura::FASE_LEITURA_US;ultimoTick=tick;temTick=true;if(fase==captura::FASES-1)quadro();
}
servicos();bool ativa=false;for(unsigned k=21;k<=108;++k)ativa|=midi.ativas[k];gpio_put(25,ativa);
uint32_t agora=time_us_32(); // Log somente TX: sem entrada serial nos pinos da matriz.
if(int32_t(agora-proximoStatus)>=0){status();proximoStatus=agora+1000000;}
}