Re:MIDI Switcher - Progetto

[Hades]

Tralaltro nel c++ sono stati messi appunto notevoli migliorie... considera che ora come ora sono costretto con il c a definire tutte le mie variabili negli header con la clausola "extern" per poi definirle nel .c
..io queste zozzerie non dovevo farle con java!

Vuoi piu' ottimizzazione? Vuoi piu' flessibilita'? Mo' ti becchi pure le sfighe!

Comunque come adattamenti intendevi usare avr-gcc al posto di avr-g++... Ora capisco!

Comunque non ti credere che a livello di prestazioni sia molto superiore, grossomodo le ottimizzazioni che introduce il compilatore del C++ sono a livello di quelle che introduce il compilatore C...

Evviva lo spaghetti-code col C!

[davidefender]

Evviva lo spaghetti-code col C!

quant'è vero....

[Hades]

Davide, come fai a memorizzare lo stato di tutti i loop nella EEPROM?
Mi sembra impossibile creare un array per ogni caso con lo stato di tutti e 16 i loop in ogni array... Impossibile non sbagliare!

Sono un po' stonato... Non riesco a saltarci fuori!

[davidefender]

Ciao hades!

scusa il ritardo, ma sono stato in vacanza! ...cmq, non ho ben capito cosa intendi per "memorizzare tutte le possibili combinazioni". Quello che faccio io (aldilà di avere una libreria che mi permette di scrivere/leggere dalla EEPROM) è far corrispondere ogni patch ad una pagina della eeprom (1 pagina = 64 byte consecutivi). Grazie ai menù e ai comandi imposto a mano come voglio suoni quella patch (ad esempio: 1° effetto ON, 3°OFF, .... poi 1° expression port a 129. 2°...) Una volta soddisfatto salvo la patch (= scrivo la pagina in eeprom), e quando la ricarico rileggo praticamente la pagina scritta in precedenza; quindi l'utente ha la piena libertà di scelta, non è vincolato a NUMPATCH = combinazioneOut. Senza contare che per 16 output, le combinazioni possibili sono 2^16!!!

Improponibile ed inutile Spero di essermi spiegato bene

[Hades]

Si in effetti e' interessante il metodo che hai usato tu.
Io pero' con 512 byte di EEPROM riuscirei a memorizzarne solo 8(!!!) di patch...

Tu hai riscritto la libreria per poter scrivere a piacere byte in eeprom o hai utilizzato la funzione standard di Arduino?

[davidefender]

come vedi da schema io uso una eeprom esterna con protocollo I2C... ho scritto una libreria che usa twi.h per comandarla e a disposizione ho 512Kb.. più che sufficienti!

[Hades]

Mannaggia... Io dovrei comandare 4 relay SPST memorizzando lo stato di ogni relay nella patch (piu' eventualmente il tipo di switching (fisso o momentaneo))... Come posso fare?
Momentaneamente mi sono fatto un array bidimensionale di bool:

#define ON true
#define OFF false
typedef bool STATUS[4];

STATUS ZERO = {OFF, OFF, OFF, OFF};
STATUS UNO = {ON, OFF, OFF, OFF};
STATUS DUE = {ON, ON, OFF, OFF};
STATUS TRE = {ON, ON, ON, OFF};
STATUS QUATTRO = {ON, ON, ON, ON};
STATUS CINQUE = {OFF, ON, OFF, OFF};
STATUS SEI = {OFF, ON, ON, OFF};
STATUS SETTE = {OFF, ON, ON, ON};
STATUS OTTO = {OFF, OFF, ON, OFF};
STATUS NOVE = {ON, OFF, ON, OFF};
STATUS DIECI = {ON, OFF, ON, ON};
STATUS UNDICI = {OFF, OFF, OFF, ON};
STATUS DODICI = {ON, OFF, OFF, ON};
STATUS TREDICI = {ON, ON, OFF, ON};
STATUS QUATTORDICI = {OFF, ON, OFF, ON};
STATUS QUINDICI = {ON, ON, ON, ON};

static bool cases[16][4] = {ZERO, UNO, DUE, TRE, QUATTRO, CINQUE, SEI, SETTE, OTTO, NOVE, DIECI, UNDICI, DODICI, TREDICI, QUATTORDICI, QUINDICI};

In attesa di implementazioni migliori... Tu che consigli (a parte la EEPROM esterna che non voglio utilizzare)?

[davidefender]

Ciao!

mmm ma quindi a te ad un program change corrisponde UNA ed una sola (hard coded) configurazione.. giusto?
Cioè, non posso scegliermi che sulla ZERO ci voglio ON,ON,OFF,ON ..vero?
Io ti suggerirei di fare esattamente come ho fatto io! considera che la memoria che devi occupare tu, è ridicola! 4 bit Allora, ammettendo che da patch a patch non cambia lo stato delle uscite (momentary o meno), il che è plausibile perché non è che da una configurazione all'altra cambiano gli effetti.. se prima c'era un effetto momentary, quello rimarrà, a te per memorizzare una patch bastano 4 bit! cioè lo stato (ON/OFF) di ogni singolo loop.

un byte sulla eeprom corrispondono così a 2 patch (4+4 bit) ma tu mascheri la parte che non ti serve... ad esempio se vuoi la terza patch, fai una cosa del genere:

uint8_t val = EEPROM.read(1);
val = (val & 0xF0) >> 4

uint8_t ef1 = val & 1
uint8_t ef2 = val & 2
uint8_t ef3 = val & 4
uint8_t ef4 = val & 8

if (ef1) //accendi loop 1
if (ef2) //accendi loop 2
if (ef3) //accendi loop 3
if (ef4) //accendi loop 4

quindi avresti a disposizione 512*2 = 1024 patch!!! diciamo che un byte lo usi per memorizzarti lo stato (momentary o no) dunque hai la bellezza di 511*2 = 1022 patch.. un'enormità!

Se invece vuoi che ogni patch abbia con se le info riguardanti lo stato, allora una patch è un byte dove (ad esempio) i primi 4 bit fanno riferimento allo stato, e gli ultimi 4 a ON o OFF. comunque avresti 512 patch.. mica poche!
Il vantaggio di questa soluzione è che ti puoi scegliere TU quali effetti accendere o spegnere per ogni patch, e non sono assolutamente fisse

[Hades]

Io (programmando in C++) ho creato l'oggetto 'relay' che porta con se il pin a cui e' assegnato e lo status del momento, piu' le funzioni per settare/leggere lo status e accendere/spegnere il relay, o fare il toggle momentaneo se serve lo switching momentaneo.

Ho un'altra classe che fa il check dello status di ogni relay e lo confronta con i vari status preimpostati: io, avendo solo 4 relay ho solo 16 casi possibili.
Potendo con le funzioni incluse in Arduino scrivere solo un byte alla volta, ho pesato di ottimizzare la memoria a scapito della velocita' di elaborazione (che non mi serve a nulla in fondo, soprattutto in scrittura: chi memorizza le patch durante il concerto???? ): scrivo all'indirizzo di memoria corrispondente alla patch (da 0 a 511), al cui interno sta il valore da 0 a 255 che corrisponde al caso da ZERO (0) a QUINDICI (15).

In poche parole, richiamando una patch richiamo l'indirizzo in memoria che contiene il valore del caso da richiamare (es 15 corrisponde ovviamente a QUINDICI).

Contorto, mi piace poco, ma funge. Si puo' migliorare, di DEVE migliorare.

Il momentary/fix lo metto con un SPST per cui va cambiato manualmente e non richiede uno stato in memoria, alla fine io avrei bisogno solo di 4 bit per patch, un bit ogni relay.
Ho controllato e la EEPROM dell'Atmega328P e' di 1024 bytes, per cui servendo a me solo un nibble avrei 2048 patch!
Ma che libreria mi conviene usare per scrivere bit singoli nella EEPROM dell'arduino?

[davidefender]

ora credo di aver capito il funzionamento! Ma mi sembra troppo scomodo.. non tanto per la lettura, ma per la scrittura: praticamente l'utente cambia a suo piacimento lo status dei 4 loop e tu ad ogni cambio devi andare a capire quale sia la combinazione e dunque il numero da memorizzare nella patch... corretto? mi sembra un pò inutile Anche perchè il numero binario già di per se identifica una combinazione: il nibble 1011 significa 1° acceso, 2° spento, 3° e 4° acceso. Non serve una tabella di corrispondenza, basta ricavare il valore booleano con un & bit a bit (come ti avevo mostrato nel vecchio post).

Per il discorso della scrittura del bit, purtroppo questo non è possibile, non hai una grana di bit (lo spazio di indirizzamento sarebbe gigante, ci pensi?)ma solo di byte. Premessa: io ti consigliuo di scrivere in eeprom solo quando l'utente decide che va bene (tipo con un messaggio :"salvare la patch corrente?") questo per evitare inutili scritture che oltre che rallentare l'esecuzione.. esauriscono la eeprom (come sai non si può scrivere quanto si vuole, ma esiste un limite).

Detto questo tu andresti a salvare non un solo bit, ma tutto il nibble ogni volta ricavandolo dallo stato dei 4 relay. Ora si pone ovviamente il problema: io devo scrivere 4 bit, ma ho una grana di un solo byte.. cancello gli altri 4 bit!!
le soluzioni possono essere due:

1 - usi un byte per ogni patch. Pro: molto semplice e veloce Contro: sprechi la metà della eeprom! quindi avresti solo 1024 patch (SOLO è un eufemismo )
2 - fai precedere ogni scrittura da una lettura del byte che devi sovrascrivere:
(mettiamo che vuoi salvare il 4* nibble)
uint8_t val = EEPROM.read(1)
val = val & 0xF0 //cancelli il quarto nibble mentre lasci invariato il terzo
val = val | (4° nibble) //imposti solamente gli ultimi 4 bit
EEPROM.write(val, 1)
Pro: nessuno spreco di spazio Contro: sono due righe di codice in più

[Hades]

Vada per l'utilizzo del byte intero per lo storage della memoria.

Come lo costruisco il byte partendo dai 4 booleani?
Mannaggia, a non usarli mai ti dimentichi come utilizzare gli operatori bitwise...

[davidefender]

se on ti ricordi come si usano.. puoi anche farne a meno! del resto.. sono numeri

uint8_t nibble = 0;
if (ef1) nibble += 1;
if (ef2) nibble += 2;
if (ef3) nibble += 4;
if (ef4) nibble += 8;

EEPROM.write(nibble, address);

ti torna?

[Hades]

relayStatus[] e' un array di bool che contiene lo status dei 4 relay, dato che li si puo' accendere/spegnere anche on-the-fly e senza memorizzare la patch.
Ho deciso di utilizzare l'intero byte, ma di memorizzare solo il primo nibble lasciando il secondo a 0, magari implementando qualcos'altro piu' avanti...

#define RL1 0x80
#define RL2 0x40
#define RL3 0x20
#define RL4 0x10


void Memory::writePatch(int PatchNumber, bool relayStatus[]) {

// Start byte is set to 0
uint8_t bin = 0x00;

// check relay 1, if ON write LSB bit to 1, else leave 0
if (relayStatus[0] == true) {
bin = bin | RL1;
}
// check relay 2, if ON write bit (LSB - 1) to 1, else leave 0
if (relayStatus[1] == true) {
bin = bin | RL2;
}
// check relay 3, if ON write bit (LSB - 2) to 1, else leave 0
if (relayStatus[2] == true) {
bin = bin | RL3;
}
// check relay 4, if ON write bit (LSB - 3) to 1, else leave 0
if (relayStatus[3] == true) {
bin = bin | RL4;
}

EEPROM.write(PatchNumber, bin);
}

Se il bit iniziale e' a zero, faccio l'OR bit a bit:
- se bit1 = 1 e bit2 = 0 --> bit1 | bit2 = 1
- se bit1 = 0 e bit2 = 0 --> bit1 | bit2 = 0

Giusto no?

[davidefender]

QUASI tutto giusto..

#define RL1 0x08
#define RL2 0x04
#define RL3 0x02
#define RL4 0x01

attento!

correggo, va bene anche come hai fatto tu, usi i bit più significativi, è uguale!

[Hades]

In realta' ho sbagliato nel commento a citare il Least Significant Bit, in realta' parto dal MSB per comodita' di immagazzinamento mentale delle nozioni, da SX a DX come sul libricino...

Bene, procedo col lavoro... Poi sposto tutti i post non relativi al tuo lavoro in un altro topic, cosi' tutto rimane piu' pulito!