Dartboard e arduino mega

Salve a tutti, ho interfacciato un arduino mega ad un dartboard elettonico, ho però un problema di lettura della matrice, essendo che l'arduino mega deve solo leggere i colpi e non gestire tutto il dartboard (la sua elettronica è e deve rimarere operativa), ho impostato righe e colonne come input (non posso usare la logica di opendart per mantenere l'elettronica originale) e fin qui tutto bene, le colonne me le rileva giuste, mentre le righe le rileva tutte in sequenza tenendo premuto il settore, se premo e rilascio svariate volte segna le righe random (vedasi screenshot, fatto con mega scollegato...)

ecco il codice, spero almeno in un indizio per poter risolvere

#define ROWS 12
#define COLS 7

const int rowPins[ROWS] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
const int colPins[COLS] = {22, 23, 24, 25, 26, 27, 28};

int scoreMatrix[ROWS][COLS] = {
    {85, 86, 87, 88, 89, 90, 91},
    {92, 93, 10, 11, 12, 13, 14},
    {15, 16, 17, 18, 19, 20, 21},
    {22, 23, 24, 25, 26, 27, 28},
    {29, 30, 31, 32, 33, 34, 35},
    {36, 37, 38, 39, 40, 41, 42},
    {43, 44, 45, 46, 47, 48, 49},
    {50, 51, 52, 53, 54, 55, 56},
    {64, 65, 66, 67, 68, 69, 70},
    {71, 72, 73, 74, 75, 76, 77},
    {78, 79, 80, 81, 82, 83, 84},
    {95, 96, 97, 98, 99, 100, 101}
};

bool previousRowState[ROWS];
bool previousColState[COLS];

const unsigned long debounceTime = 150;

unsigned long lastDebounceTime[ROWS + COLS];

void setup() {
    Serial.begin(115200);

    // Configura le RIGHE
    for (int i = 0; i < ROWS; i++) {
        pinMode(rowPins[i], INPUT_PULLUP);
        previousRowState[i] = HIGH;
        lastDebounceTime[i] = 0;
    }

    // Configura le COLONNE
    for (int j = 0; j < COLS; j++) {
        pinMode(colPins[j], INPUT_PULLUP);
        previousColState[j] = HIGH;
        lastDebounceTime[ROWS + j] = 0;
    }
}

void loop() {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            if (digitalRead(rowPins[i]) == LOW && digitalRead(colPins[j]) == LOW
                && (millis() - lastDebounceTime[i] > debounceTime)
                && (millis() - lastDebounceTime[ROWS + j] > debounceTime)) {

                Serial.print("Colpito segmento: R");
                Serial.print(i);
                Serial.print(" C");
                Serial.print(j);
                Serial.print(" - Punti: ");
                Serial.println(scoreMatrix[i][j]);

                lastDebounceTime[i] = millis();
                lastDebounceTime[ROWS + j] = millis();
            }
        }
    }
}

Ciao...ho la senazione che sia un problema hardware...del tipo che se chiudi uno dei nodi in realtà ne chiudi anche altri...

mi fa strano perchè le righe le segna tutte,anche cambiando pins

Io sto con @andreaber e voglio vedere lo schema prima di pronunciarmi

Comunque c'è qualcosa di non chiaro 'anche' nella matrice dei tempi di debounce

Io invece mi chiedo proprio come possa funzionare il software: hai configurato tutti i pin di riga e colonna come ingressi a pullup e quando fai la scansione non li vai ad impostare come uscita.

Come può essere vera la condizione digitalRead(rowPins[i]) == LOW o a condizione digitalRead(colPins[j]) == LOW se lo stato del segnale rimane sempre e comunque a pull-up e quindi a 5V?
Il fatto che tu ottenga dei valori sul monitor seriale, per quanto incoerenti, suggerisce un errore hardware nel cablaggio come ipotizzava @andreaber.

Ti suggerisco di dare un'occhiata a questo post di Nick Gammon che spiega nel dettaglio come funziona l'algoritmo da adottare per fare la scansione della matrice di tasti.

Infine ho un dubbio: quella di non utilizzare librerie già pronte ed ampiamente collaudate come ad esempio keypad.h è una scelta precisa o semplicemente non la conoscevi?

Lo schema è semplice, 19 pin matrice - - > 19 resistenze 10k in serie - - > arduino

Stavo pensando che siccome devo usare sia righe che colonne come input e le righe del dartboard sono in stato low nella sua elettronica e non posso impostarli in questo modo con arduino avendo le pullup attive, se uso un hex inverter tipo un 74hc04 per farli rilevare ad arduino come high, può essere una soluzione?

Allora adesso mettilo complesso
Perchè dal tuo 'semplice' non si capisce nulla

Rimango in attesa di uno schema serio

Senza uno schema completo stai solo scrivendo parole a caso

Mi era sfuggito che il tuo circuito è in parallelo al circuito già presente sulla dartboard...
Allora lo schema elettrico disegnato a dovere è d'obbligo per capire cosa succede.

Scusami ma vedo di quale schema serio hai bisogno, ogni pin della matrice si collega ai pin di arduino, tra questi due c'è una resistenza in serie per ogni pin

Libero di continuare a non inquadrare il tuo problema

Io sono a posto

Esatto è in parallelo. Ci sono solo delle resistenze in serie tra la matrice ed arduino per limitare l'amperaggio. Se ti riferisci allo schema del dartboard non ce l'ho, so solo che la sua elettronica gestisce come high le colonne (4.2volt) e low le righe (1.95v) ed ogni pin della matrice si collega separatanente alla sua mcu (gplb25b), arduino l'ho collegato in parallelo alla matrice solo ed esclusivamente per leggere i valori, per questo sono input sia righe che colonne.

Se poi serve lo schema lo faccio anche ma non mi sembra un circuito cosi difficoltoso da comprendere

Ho fatto al volo un circuitino che cerca di simulare il tuo progetto (in realtà si tratta di copia/incolla di altro trovato online), ma ho omesso le resistenze che secondo me sono ridondanti.

Gli switch simulano la "scansione" fatta dalla dashboard che quindi porta a LOW tutta la serie di contatti.
Sembra funzionare tutto come dovrebbe, sia scansionando sulle colonne che sulle righe, il che riporta in pole position il problema hardware.

Grazie.Pensi possa essere il mio arduino mega defunto?

No, non credo. Io proverei ad eliminare le resistenze.

Provo... Comunque notavo una cosa nella tua simulazione, se attivo due o più switch sulle righe, da il problema che ho io, quando scansiona rileva la singola colonna e tutte le righe (tenendo premuto) .

Due o tre cose non mi quadrano

Il debounce secondo me è inutile e complica molto le cose

Inutile perché non stiamo leggendo pulsanti puri
Stiamo leggendo una scansione
O il pulsante è premuto nello stesso istante in cui la scansione passa da lui oppure non è premuto
Inutile farsi pippe con il debounce, se c'è segnale il pulsante è premuto, se non c'è non è premuto
Un nientesimo di secondo dopo la scansione è andata oltre; non esiste nemmeno più la possibilità di un bounce

Poi
Il circuito di cotestant non è aderente alla realtà
Li la scansione la fa lui a mano, e lentamente

Nella realtà la scansione la fa un processore, in automatico; e velocemente

Intanto Arduino si legge le sue tensioni sui pin
E se legge bassa una colonna e poi una riga crede di aver trovato un tasto premuto

Cosa ci garantisce che le letture di arduino siano sincrone con le scansioni del processore preesistente?
Cosa ci garantisce quindi che la lettura della riga sia nello stesso ciclo di scansione della lettura della colonna?

Domanda

Cosa succede se in Arduino invertiamo i due cicli? Cicliamo prima le colonne e poi le righe ?

La sincronia credi sia rilevante? Potrei sbagliarmi ma essendo tutta la matrice in input su arduino non dovrebbe interferire... Anche perché se premo un pulsante, quel pulsante è chiuso in una sola determinata riga e colonna.

Stasera farò delle prove disattivando il debounce.
Provo anche ad invertire i cicli e vedo cosa succede :+1:t2:

Certo

Pensaci

Fosse questo il caso, un eventuale soluzione? Così stasera so su cosa lavorare :sweat_smile: