Modifiche al file hardware/arduino/avr/cores/arduino/wiring_digital.c ignorate

Salve a tutti, ho da poco iniziato a studiare i file delle librerie interne dell'IDE e per fare alcune prove ho anche modificato il file wiring_digital.c
In particolare ho modificato le funzioni pinMode e digitalWrite aggiungendo la riga di codice pin = 13;

void pinMode(uint8_t pin, uint8_t mode) 
 { 
 	pin = 13;
	uint8_t bit = digitalPinToBitMask(pin); 
 	uint8_t port = digitalPinToPort(pin); 
 	volatile uint8_t *reg, *out; 
 

 	if (port == NOT_A_PIN) return; 
 

 	// JWS: can I let the optimizer do this? 
 	reg = portModeRegister(port); 
 	out = portOutputRegister(port); 
 

 	if (mode == INPUT) {  
 		uint8_t oldSREG = SREG; 
                 cli(); 
 		*reg &= ~bit; 
 		*out &= ~bit; 
 		SREG = oldSREG; 
 	} else if (mode == INPUT_PULLUP) { 
 		uint8_t oldSREG = SREG; 
                 cli(); 
 		*reg &= ~bit; 
 		*out |= bit; 
 		SREG = oldSREG; 
 	} else { 
 		uint8_t oldSREG = SREG; 
                 cli(); 
 		*reg |= bit; 
 		SREG = oldSREG; 
 	} 
 }

Lo scopo è quello di far si che nell'esempio blink, indipendentemente dal pin indicato, lampeggi sempre il pin 13 (questo è solo un test perché in seguito vorrei aggiungere del codice personalizzato).
Il mio problema è che compilando e scaricando tutto su Arduino UNO, la modifica viene ignorata.
Ho anche trovato i file oggetto di wiring_digital ricompilati alla data corrente, quindi rigenerati.
La cosa strana è che anche se cancello il file hardware/arduino/avr/cores/arduino/wiring_digital.c l'IDE continua a funzionare correttamente, cosa che non avviene se cancello il file hardware/arduino/avr/cores/arduino/wiring_digital.h
Come ambiente ho usato la versione 1.6.9 da pacchetto zip su Windows 10.
Qualcuno ha qualche idea?
Grazie

Buongiorno e benvenuto sul forum,
essendo il tuo primo post, nel rispetto del regolamento, ti chiedo cortesemente di presentarti QUI (spiegando bene quali conoscenze hai di elettronica e di programmazione ... possibilmente evitando di scrivere solo una riga di saluto) e di leggere con MOLTA attenzione il su citato REGOLAMENTO ... Grazie.

Guglielmo

P.S.: Qui una serie di link utili, NON necessariamente inerenti alla tua domanda:
- serie di schede by xxxPighi per i collegamenti elettronici vari: ABC - Arduino Basic Connections
- pinout delle varie schede by xxxPighi: Pinout
- link generali utili: Link Utili

Toccare i files del core è SEMPRE una pessima idea e ti sconsiglio tali modifiche che, oltretutto, ogni nuova versione occorre ristudiare (visto che a volte vengono apportate modifiche e correzioni anche su vecchi files) e riapplicare.

Fatti delle tue classi e delle tue librerie e richiami quelle o fatti un core personalizzato e salvatelo come se fosse una nuova board ben distinta da selezionare quando lo vuoi usare.

Guglielmo

Ciao, e grazie della risposta e scusa se non mi ero presentato prima.
Sono d'accordo con te per quanto riguarda il non modificare i file originali per non rischiare di perdere tutto in un aggiornamento, ed in realtà avevo già deciso di fare un core mio, ma prima di avventurarmi nell'impresa volevo capire meglio il funzionamento di uno esistente.
Voglio modificare le funzioni originali perché voglio che uno sketch esistente giri senza essere modificato.
Mi andrebbe bene anche un override delle funzioni pinMode e digitalWrite se fosse possibile.
Non sono partito subito con il crearmi un core personalizzato perché ho pensato che se la cosanon funzionava modificando quello base, di sicuro non avrebbe funzionato neanche con il mio.
Grazie dell'aiuto

luigirusso:
... Voglio modificare le funzioni originali perché voglio che uno sketch esistente giri senza essere modificato.

Magari se spieghi meglio questo punto chiarendo bene COSA non ti funziona e COSA e COME vorresti che funzionasse ... riusciamo anche a darti una mano ::slight_smile:

Guglielmo

In pratica voglio che con la modifica delle funzioni pinMode e digitalWrite presenti in hardware/arduino/avr/cores/arduino/wiring_digital.c sia il codice

void setup() {
   pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
   digitalWrite(LED_BUILTIN, HIGH);
   delay(1000);
   digitalWrite(LED_BUILTIN, LOW);
   delay(1000);
}

che il codice

void setup() {
   pinMode(10, OUTPUT);
}

void loop() {
   digitalWrite(10, HIGH);
   delay(1000);
   digitalWrite(10, LOW);
   delay(1000);
}

facciano lampeggiare il led builtin in quanto con le modifiche seguenti (aggiunta della riga pin = 13;)

void pinMode(uint8_t pin, uint8_t mode) 
{ 
	pin = 13;
        uint8_t bit = digitalPinToBitMask(pin); 
	uint8_t port = digitalPinToPort(pin); 
	volatile uint8_t *reg, *out; 


	if (port == NOT_A_PIN) return; 


	// JWS: can I let the optimizer do this? 
	reg = portModeRegister(port); 
	out = portOutputRegister(port); 


	if (mode == INPUT) {  
		uint8_t oldSREG = SREG; 
                cli(); 
		*reg &= ~bit; 
		*out &= ~bit; 
		SREG = oldSREG; 
	} else if (mode == INPUT_PULLUP) { 
		uint8_t oldSREG = SREG; 
                cli(); 
		*reg &= ~bit; 
		*out |= bit; 
		SREG = oldSREG; 
	} else { 
		uint8_t oldSREG = SREG; 
                cli(); 
		*reg |= bit; 
		SREG = oldSREG; 
	} 
}
void digitalWrite(uint8_t pin, uint8_t val) 
{
 	pin = 13;
	uint8_t timer = digitalPinToTimer(pin); 
	uint8_t bit = digitalPinToBitMask(pin); 
	uint8_t port = digitalPinToPort(pin); 
	volatile uint8_t *out; 


	if (port == NOT_A_PIN) return; 


	// If the pin that support PWM output, we need to turn it off 
	// before doing a digital write. 
	if (timer != NOT_ON_TIMER) turnOffPWM(timer); 


	out = portOutputRegister(port); 


	uint8_t oldSREG = SREG; 
	cli(); 


	if (val == LOW) { 
		*out &= ~bit; 
	} else { 
		*out |= bit; 
	} 


	SREG = oldSREG; 
}

le funzioni dovrebbero ignorare il pin passato.
Il mio problema è che ciò non avviene e nel caso della seconda versione di blink (quella con pin 10) fa lampeggiare veramente il pin 10.
Grazie per la pazienza. Spero di essermi riuscito a spiegare e di aver dato tutte le informazioni necessarie

:o :o :o :o ... perdona ... ma il SENSO di tutto questo ? ? ? Usare Arduino con UN SOLO pin ? ? ? ... perché se fissi sempre le funzioni sul 13 ... quello ottieni !

Guglielmo

Lo so che fatto così non ha senso, ma mi serve solo come prova per verificare che sto lavorando sui file giusti.
Quando la prova funziona, nelle funzioni pinMode e digitalWrite non inserirò pin = 13 ma del codice che voglio venga eseguito in aggiunta a quello che già fanno.
In particolare, per certi pin ed in certi cambi di stato, dovrà partire un "messaggio" ad un altro arduino remoto collegato via seriale.

Il problema è che il programma ignora le modifiche. Non fa quello che anche tu giustamente ti aspetti.
Anche dopo le modifiche, arduino continua a gestire i pin come se niente fosse e non come se ci fosse solo il 13

Concordo assolutamente con gpb che quel che stai facendo non ha senso. Se vuoi che parta un messaggio alla modifica di un pin, gestisci questa cosa nello sketch, non nel core.

Comunque le modifiche potrebbero essere ignorate perché forse hai la nuova opzione "Aggressively cache compiled core" abilitata, e dunque il core non viene ricompilato. Guarda bene cosa ti scrive l'IDE.

Ciao,
grazie al vostro aiuto ho risolto.
Il problema era effettivamente nell'opzione "Aggressively cache compiled core" che era abilitata.
Rimuovendo la spunta ha ricompilato il core e visto la modifica.
Mi rendo conto che con l'esempio di codice che ho postato, la modifica sembra non avere senso, ma era solo il primo passo per verificare se stavo imboccando la strada giusta per un progetto che ho in mente.
Vorrei creare un core personalizzato che permetta di mappare i pin come "pin virtuali" che possano corrispondere sia a pin fisici sulla scheda, ma anche a pin remoti su un'altra scheda.
Una sorta di arduino distribuito. Vorrei creare un array nel quale configurare ad usempio una cosa del tipo:
Pin 1 = scheda 2 / pin 3
Lo voglio fare nel core perchè questo mi permette di nascondere tutta la gestione della comunicazione e soprattutto perchè mi permette di non toccare niente di un codice che gira tutto localmente, ma che dopo posso far girare anche in maniera distribuita semplicemente rimappando i pin.
Una sorta di "VirtuIno" (così lo vorrei chiamare) o come si dice oggi "un progetto liquido".
Logicamente dovrò ridefinire anche le funzioni di lettura dei pin e sulle schede remote (slave) ci sarà un firmware standard predisposto per ricevere i comandi.
Avevo pensato anche di mappare più pin remoti su un solo pin virtuale, consentendo così tramite un comando digitalWrite(5, HIGH); di accendere tutti i relè remoti che avevo configurato sul pin virtuale 5. Questo consente di aggiungere o spostare dispositivi remoti senza toccare una riga di codice, ma semplicemente rimappando i pin virtuali.
Spero di essere riuscito a spiegarmi anche perchè l'idea è in fase embrionale e potrei aver descritto tutto in maniera un pò confusa.
Vi ringrazio ancora per il tempo che mi avete dedicato.

Secondo me ha più senso creare dei nuovi comandi che "imitano" quelli già esistenti.
esempio VpinMode(), VdigitalWrite() dove V sta per Virtuale

  1. il core viene aggiornato spesso quindi dovresti tenere una versione bloccata e ti perdi gli aggiornamenti
  2. gli sketch che ottieni non fanno capire che stai usando una virtualizzazione.

Se creo nuovi comandi poi devo anche modificare lo sketch esistente per cambierebbe le istruzioni vecchie con i nuovi comandi. Un'alternativa alla creazione di un nuovo core è quella di creare delle funzioni che vadano in override su quelle del core, ma non so se sia possibile