Verissimo,ma da volerselo fare a volerlo fare complicato.....
Beh, insomma, non lo vedo così complicato né come cablaggi né come codice.
Se ad esempio volesse fare un tester per cavi di rete potrebbe mettere due connettori Ethernet femmina e collegare gli 8+8 cavi ad altrettanti pin, più lo schermo a GND (per i cavi non schermati si può prendere un conduttore come massa comune per i test).
Come codice penso che io in un'ora lo scrivo da zero. 
Vero,
Ma con un 555, un contatore decadico e una manciata di componenti passivi...
Lo hai già fatto da 30 anni...
docdoc:
Beh, insomma, non lo vedo così complicato né come cablaggi né come codice.
Per te non è complicato, per me è banale, per altri potrebbe essere difficilissimo da implementare.
Tutto dipende dalla preparazione, ma anche dall'esperienza, che si possiede.
Si, certo, ma in ogni caso direi di aspettare le ulteriori risposte ed informazioni del nostro amico che ha chiesto questa cosa, più che parlarci addosso con questioni filosofico-tecniche... 
non pensavo di scatenare tutto questo ma mi fa piacere. Dunque o iniziato a buttare giù qualcosa l' idea come già detto è controllare solo il corto e a quale ingresso corrisponde l' attivazione di una determinata uscita l' idea era all' incirca questa:
int out[] ={2,3};
int in[]= {8,9};
queste sono le mie due uscite e i miei due ingressi per ora.
Ora attivo l' uscita 2 con il ciclo for e vado a leggere a questo punto tutti e 2 gli ingressi cosi da poter verificare anche il cto e qui già mi interrompo... Come dire al programma procedi se tutto ok oppure fermati se sbagliato?
Ma qui mancano elementi di programmazione strutturata...
Fai così:
Metti una variabile globale inizializzata a zero
Un ciclo for per ogni uscita
Dentro un ciclo for per ogni ingresso
Fai il test
Se test non ok metti a 1 la variabile
All'uscita dai for se la variabile globale è a 1
Segnali no good...
Altrimenti segnali good
Però così niente array...
Prova ciclo for per ogni uscita
Dentro un ciclo for per ogni ingresso
Registri nello array lo stato dell'ingresso
Uscito dai cicli for confronti lo array misurato con quello di riferimento
Se vuoi ottimizzarlo, considera anche che ogni volta che controlli un'ingresso, le uscite da controllare si riducono di una ... intendo, metti di avere per semplicita' 4 fili ... collego l'ingresso ad 1, e testo le uscite 1, 2, 3, 4 ... se tutto e' ok, quando poi collego l'ingresso a 2, non mi serve piu testare l'uscita 1, perche' l'ho gia fatto prima (se avessi avuto un corto fra 1 e 2, sarebbe gia stato rilevato, quindi non serve piu testare di nuovo il corto fra 2 ed 1) ... e cosi via ...
Occhio che così popoli solo metà dello array....
Ma per continuita' e corto, non ti serve altro ...
Per impedenze, dispersioni ed intermodulazione, l'hardware richiesto sarebbe molto piu complesso, ma se devi solo verificare se c'e' continuita' e che non ci siano corti, ti basta ... prova a pensare un'attimo ...
attivo ingresso 1
misuro uscita 1 - ok (contatto)
misuro uscita 2 - ok (no contatto = no corto)
misuro uscita 3 - ok (no contatto = no corto)
misuro uscita 4 - ok (no contatto = no corto)
spengo ingresso 1, attivo ingresso 2
(ora non mi serve piu misurare uscita 1, perche' da prima gia so che c'e' continuita' con uscita 1 e nessun corto con 2, 3, 4)
misuro uscita 2 - ok (contatto)
misuro uscita 3 - ok (no contatto = no corto)
misuro uscita 4 - ok (no contatto = no corto)
spengo ingresso 2, attivo ingresso 3
(ora non mi serve piu controllare neppure uscita 2, perche' come prima, ora so che c'e' continuita' con ingresso 2 e nessun corto con 3, 4, e da prima so anche che non c'e' alcun corto con 1)
... e cosi via ... non conta il numero dei fili, ogni uscita controllata e che e' ok, automaticamente elimina la necessita' di ricontrollare sia se stessa che quelle gia controllate, ad ogni cambio di ingresso ... praticamente, quasi dimezzi il numero di cicli di controllo necessari ... se hai pochi fili il risparmio di tempo e' esiguo, ma se ti capita di dover controllare cavi con parecchie decine di conduttori ...
EDIT: Se proprio sei costretto (ma non immagino perche' :D) ad usare un'array "pieno", puoi scrivere le equivalenti posizioni contemporaneamente ... tanto sono complementari (se, ad esempio, non c'e' corto fra 1 e 2, automaticamente non c'e' corto neppure fra 2 ed 1, e cosi via, quindi scrivi entrambi i valori ogni volta)
Io non lo so a cosa serva,
Lo vuole, un array... Dice che così è più semplice....
Io ho idea di semplificato ancora, un test per ogni polo, e basta
2 pin per polo, e fin qui è chiaro
Tutti i pin out alti, con resistenza limitatrice in serie sulla prima serie di pin
Dal primo all'ultimo polo, in un solo for
Primo pin out basso, secondo pin input pullup
Se legge alto delle due l'una
O interrotto, e legge pullup
O in corto con uno qualunque dei pin alti
Un break
L'indice indica che pin è fallato
Meno di così....
Occhio solo a non usare il pin 13 come input pullup, causa led non andrebbe
Pianificare di usare il pin 13 nella prima serie di pin, quelli usati come output
Io proporrei di provare questo codice:
// 18 23
//pin 0 e 1 seriale
//pin 2 input tasto avvio prova, attivo se messo a massa
//pin 3 output led verde prova OK
//pin pari a partire dal 4 al primo connettore senza resistenza di limitazione
//pin dispari a partire dal 5 al secondo connettore con resistenza di limitazione da 1K
//connessi in sequenza 4 e 5 al primo polo 6 e 7 al secondo e via così
#define riservati 4
//numero dei pin riservati prima dell'inizio cablaggio cavo in prova
#define poli 5
// numero dei poli del cavo
// va da se che poli+riservati < numero pin della scheda
int ok = 1;
// se ok vale 0 il cavo è non OK
void setup() {
Serial.begin(9600);
Serial.println(F("Programma di prova per cavi"));
Serial.print(F("Predisposto per provare cavi a: "));
Serial.print(poli);
Serial.println(F(" poli"));
pinMode(2, INPUT_PULLUP);
pinMode(3, OUTPUT);
}
void loop() {
if (digitalRead(2)) {
// tasto non premuto
}
else {
//Ciclo avviato
// Spengo il led di cavo OK
digitalWrite(3, LOW);
// dichiaro uscite tutti i pin
for (int i = riservati; i < riservati + poli; i++) {
pinMode(i, OUTPUT);
pinMode(i + poli, OUTPUT);
digitalWrite(i, HIGH);
digitalWrite(i+poli, HIGH);
}
// do per buon il cavo
ok = 1;
// per tutti i poli
for (int i = 0; i < poli; i++) {
// metto basso il pin dispari
digitalWrite(4 + i * 2 + 1, LOW);
// 4 riservati +2 volte l'indice + 1 per fare dispari
//cambio il modo di funzionamneto del pin pari
pinMode (4 + 2 * i, INPUT_PULLUP);
// aspetto 5 millisecondi per lasciare il tempo di assestamento (forse non serve)
delay(5);
// se input è alto errore nel cablaggio
if (digitalRead(4 + 2 * i)) {
// errore nel cablaggio
Serial.print (F("Cablaggio errato al polo numero: "));
Serial.println(i);
// dichiaro non OK il cavo
ok = 0;
// resetto tutti i pin
for (int j = riservati; j < riservati + poli; j++) {
pinMode(j, OUTPUT);
digitalWrite(j, LOW);
}
//esco dal for
break;
}
else {
// test OK
// rimetto a posto i pin usati
digitalWrite(4 + i * 2 + 1, HIGH);
pinMode (4 + 2 * i, OUTPUT);
digitalWrite(4 + i * 2, HIGH);
}
}
// fuori dal for
//se cavo OK
digitalWrite(3, ok);
}
}
// 18 53
fa più o meno quello che avevo descritto prima
NON usa array, e anche poche variabili
è parametrizzabile
e usa il pin 13 come output
Compilare compila
ma la mia UNO è nell'altra casa
NON lo garantisco, è ancora da dubuggare