Controllare stato dei pin

International Italiano Software
41

igor97:
io sto comunque lavorando a questa cosa, quelel funzioni digitalpintoecc non le conoscevo ma ora ho capito come usarle.
la funzione d sl non funziona, mi restituisce sempre 0.
vedo di trovare qualche altra soluzione.

@menniti: ovviamente la risposta che diedi sul DDRx non era approfondita, ma mi aspettavo che l'utente che ha creato il 3d mi dicesse come si usa. in due pagine non ha deto a il ciò vuol dire che o sa gia come fare o non sta sul forum da parechio tempo.

io comunque qualcosa la sto facendo. la libreria è inutile invece pensavo che uno sketch di esempio da aggiungere nelal cartella examples potrebbe aiutare a ricordare la/e funzioni.
vi farò sapere appena concludo qualcosa

@menniti: dovrebbe indicare se è un pin è i/o

prova a modificare da

boolean dentroFuori(int pin) {
	uint8_t bit = digitalPinToBitMask(pin);
	uint8_t port = digitalPinToPort(pin);
        
	return ((*portModeRegister(port) & bit) == 0) ? 0:1;
}

a

int dentroFuori(int pin) {
	uint8_t bit = digitalPinToBitMask(pin);
	uint8_t port = digitalPinToPort(pin);
        
	return *portModeRegister(port) & bit;
}

e printa il risultato (a me è arrivata la imu quindi sto giocherellando, poi sto pomeriggio giocata a softair quindi.. XD )

42

in realtà l'ultimo sketch dovrebbe essere scritto così:

boolean dentroFuori(int pin) {
	uint8_t bit = digitalPinToBitMask(pin);
	uint8_t port = digitalPinToPort(pin);
        
	return ((*portModeRegister(port) & bit) == 0) ? 0:1;
}

void setup() {
  Serial.begin(9600);
  
  for(int i=0; i<=13; i++) {
    pinMode(i, OUTPUT);
    Serial.print(dentroFuori(i));
  }
  Serial.println("");

  for(int i=0; i<=13; i++) {
    pinMode(i, INPUT);
    Serial.print(dentroFuori(i));
  }
  Serial.println("");
  
  for(int i=0; i<=13; i++) {
    pinMode(i, OUTPUT);
    Serial.print(dentroFuori(i));
  }
}

void loop() { }

altrimenti ti partonoo le print all'infinito o quasi. adesso funziona e il risultato è
11111111111111
00000000000000
11111111111111

ti eri dimenticato di mettere nel for che i=0 e non 1; i<=13 e non i=13; i++ e qui ci siamo.

non resta che includere un digital read e poi dare come return non il solito 0 o 1 ma input o output/high o low

43

l'ultimo era +2 e il print era a parte per verificare la "lettura alterna" e vedere se rompeva, comunque hai ragione colpa mia XD

44

4 byte? sono rovinato :grin: . No scherzi a parte, anche l'idea di Ogor non è male, cioè di fare uno sketch d'esempio, però mi piacerebbe molto arrivare ad un unico lavoro che possa dare un quadro istantaneo per come dicevo: singolo pin, intera linea, tutte le linee.
Quindi ora prendo queste informazioni ed al rientro (tra alcuni giorni), dopo aver sbrigato un paio di cose molo importanti, vedrò di lavorarci facendo un po' di prove.
Grazie.

Naturalmente se aggiungere altro codice prendo a piene mani, vi chiedo di aggiungere sempre due parole di spiegazione.

@ IGOR: e perché non fino a 19? così si leggerebbero anche gli altri 6 pin, certo poi bisognerebbe capire se sono usato o meno come input analogici

45

superlol:
l'ultimo era +2 e il print era a parte per verificare la "lettura alterna" e vedere se rompeva, comunque hai ragione colpa mia XD

ah già l'ho tolto io :grin:
vabbè comunque funziona tutto. ora vedo di aggiungere i read degl stati e cambiare i return

@menniti: la funzione di sl ti restituisce lo stato di un singolo pin. lo sketch mette insieme tutti i pin perchè è fatto in quel modo.
certo il conto lo si puo fare fino a 19 bisogna vedere cosa esce. di certo non un valore analogico
ah se èun pin è in modalità pwm la laettura sarà 0 (intendo del valore high low)

46

si ho capito come funziona, questa funzione sarebbe la risposta al mio primo quesito, basta predisporla per farle leggere i pin in base al gruppo A-B-C-ecc ed il più è fatto secondo me.

47

non c'è bisogno di predisporre niente. basta dire un qualsiasi pin anche se si lavora con un mega o altro.

boolean dentroFuori(int pin) {
	uint8_t bit = digitalPinToBitMask(pin);
	uint8_t port = digitalPinToPort(pin);
        
        return ((*portModeRegister(port) & bit) == 0) ? 0:1;
}

void setup() {
  delay(2000);
  Serial.begin(115200);
  
  for(int i=0; i<=19; i++) {
    pinMode(i, OUTPUT);
    Serial.print("Tipo pin ");Serial.print(i);Serial.print(" = ");
   if (dentroFuori(i)==0) {
       Serial.println("INPUT");
   }
    else if (dentroFuori(i)==1) {
      Serial.println("OUTPUT");
    }
  }
  Serial.println("");

  for(int i=0; i<=19; i++) {
    pinMode(i, INPUT);
    Serial.print("Tipo pin ");Serial.print(i);Serial.print(" = ");
       if (dentroFuori(i)==0) {
       Serial.println("INPUT");
   }
    else if (dentroFuori(i)==1) {
      Serial.println("OUTPUT");
    }
  }
  Serial.println("");
  
  for(int i=0; i<=19; i++) {
    pinMode(i, OUTPUT);
    Serial.print("Tipo pin ");Serial.print(i);Serial.print(" = ");
       if (dentroFuori(i)==0) {
       Serial.println("INPUT");
   }
    else if (dentroFuori(i)==1) {
      Serial.println("OUTPUT");
    }
  }
}

void loop() { }

qusto è piu divertente. ovviamnte alla fine quando ho/abbiamo finito mettiamo i commenti, e pubblichiamo

48

scherzo, così si fa prima:

char* modeWritten(uint8_t pin) {                    // set function that say mode of pin requested
	uint8_t bit = digitalPinToBitMask(pin);     // set BitMask(bit that corresponds to the pin requested)
	uint8_t port = digitalPinToPort(pin);       // set Port(port that corresponds to the pin requested)
        
        int mode= (*portModeRegister(port) & bit);  //set the mode of the pin requested, then 
        if (mode==0) {                              // set the return of the function (INPUT or OUTPUT)
          return "INPUT";
        }
        else {
          return "OUTPUT";
        }          
}

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

  for(int i=0; i<=13; i++) {                        // sets all digital pins as outputs
    pinMode(i, OUTPUT);
    Serial.print("Mode Pin ");Serial.print(i);Serial.print(" = "); //Print mode of each pin
     Serial.println(modeWritten(i));
  }
  
  Serial.println("");

  for(int i=0; i<=13; i++) {                        // sets all digital pins as inputs
    pinMode(i, INPUT);
    Serial.print("Mode Pin ");Serial.print(i);Serial.print(" = "); //Print mode of each pin
     Serial.println(modeWritten(i));
  }

void loop() {/* your program */}

comunque, secondo me fare uan funzione per leggere low/high di un pin è inutile. se c'è già il digitalRead o anche l'analogRead.
EDIT: ho aggiunto i commenti. è tutto in inglese ora

49

igor97:
scherzo, così si fa prima:

char* modeWritten(uint8_t pin) {                    // set function that say mode of pin requested

uint8_t bit = digitalPinToBitMask(pin);     // set BitMask(bit that corresponds to the pin requested)
uint8_t port = digitalPinToPort(pin);       // set Port(port that corresponds to the pin requested)

int mode= (*portModeRegister(port) & bit);  //set the mode of the pin requested, then
        if (mode==0) {                              // set the return of the function (INPUT or OUTPUT)
          return "INPUT";
        }
        else {
          return "OUTPUT";
        }         
}

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

for(int i=0; i<=13; i++) {                        // sets all digital pins as outputs
    pinMode(i, OUTPUT);
    Serial.print("Mode Pin ");Serial.print(i);Serial.print(" = "); //Print mode of each pin
     Serial.println(modeWritten(i));
  }
 
  Serial.println("");

for(int i=0; i<=13; i++) {                        // sets all digital pins as inputs
    pinMode(i, INPUT);
    Serial.print("Mode Pin ");Serial.print(i);Serial.print(" = "); //Print mode of each pin
     Serial.println(modeWritten(i));
  }

void loop() {/* your program */}




comunque, secondo me fare uan funzione per leggere low/high di un pin è inutile. se c'è già il digitalRead o anche l'analogRead.
EDIT: ho aggiunto i commenti. è tutto in inglese ora

attento che stai facendo un return di una stringa, a parte il fatto che è inutile di per se, occupa molte risorse.

metti return INPUT e return OUTPUT direttamente e lascia come boolean il valore, input output valgono come 1 e 0, stessa cosa high e low

50

superlol:
attento che stai facendo un return di una stringa, a parte il fatto che è inutile di per se, occupa molte risorse.
metti return INPUT e return OUTPUT direttamente e lascia come boolean il valore, input output valgono come 1 e 0, stessa cosa high e low

eh gia. l'ho pensato anche io. adesso cambio tutto. era solo a livello di estetica.
comunque chi lo pubblica dei due il codice? a me non piace prendere il merito di ltri solo per aver fatto dell modifiche stupide. al limite quandotutto sarà finito ci mettiamo d'accordo

boolean modeWritten(uint8_t pin) {                    // set function that say mode of pin requested
	uint8_t bit = digitalPinToBitMask(pin);     // set BitMask(bit that corresponds to the pin requested)
	uint8_t port = digitalPinToPort(pin);       // set Port(port that corresponds to the pin requested)
        
        return ((*portModeRegister(port) & bit) == 0) ? 0:1;  ////the return is 0 for input mode, 1 for output
      }

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

  for(int i=0; i<=13; i++) {                        // sets all digital pins as outputs
    pinMode(i, OUTPUT);
    Serial.print("Mode Pin ");Serial.print(i);Serial.print(" = "); //Print mode of each pin
     Serial.println(modeWritten(i));
  }
  
  Serial.println("");

  for(int i=0; i<=13; i++) {                        // sets all digital pins as inputs
    pinMode(i, INPUT);
    Serial.print("Mode Pin ");Serial.print(i);Serial.print(" = "); //Print mode of each pin
     Serial.println(modeWritten(i));
  }
}
void loop() {/* your program */}

ora l'ho cambiato.

51

igor97:

superlol:
attento che stai facendo un return di una stringa, a parte il fatto che è inutile di per se, occupa molte risorse.
metti return INPUT e return OUTPUT direttamente e lascia come boolean il valore, input output valgono come 1 e 0, stessa cosa high e low

eh gia. l'ho pensato anche io. adesso cambio tutto. era solo a livello di estetica.
comunque chi lo pubblica dei due il codice? a me non piace prendere il merito di ltri solo per aver fatto dell modifiche stupide. al limite quandotutto sarà finito ci mettiamo d'accordo

boolean modeWritten(uint8_t pin) {                    // set function that say mode of pin requested

uint8_t bit = digitalPinToBitMask(pin);     // set BitMask(bit that corresponds to the pin requested)
uint8_t port = digitalPinToPort(pin);       // set Port(port that corresponds to the pin requested)

return ((*portModeRegister(port) & bit) == 0) ? 0:1;  ////the return is 0 for input mode, 1 for output
      }

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

for(int i=0; i<=13; i++) {                        // sets all digital pins as outputs
    pinMode(i, OUTPUT);
    Serial.print("Mode Pin ");Serial.print(i);Serial.print(" = "); //Print mode of each pin
     Serial.println(modeWritten(i));
  }
 
  Serial.println("");

for(int i=0; i<=13; i++) {                        // sets all digital pins as inputs
    pinMode(i, INPUT);
    Serial.print("Mode Pin ");Serial.print(i);Serial.print(" = "); //Print mode of each pin
     Serial.println(modeWritten(i));
  }
}
void loop() {/* your program */}



ora l'ho cambiato.

a me non piace prendere meriti in generale quindi pubblica tu XD ti riconosco la proprietà intellettuale :stuck_out_tongue:

52

superlol:
a me non piace prendere meriti in generale quindi pubblica tu XD ti riconosco la proprietà intellettuale :stuck_out_tongue:

tanto scriverò
idea di Michele Menniti
sviuppo : Superlol e Igor97

:stuck_out_tongue: così siamo pace

prima di pubblicare però voglio sentire menniti e leo che dicono

53

l'idea di Michele Menniti è quella di poter, a scelta, leggere:
1 - un pin qualsiasi avendo per ognuno I oppure OL/OH (ma naturalmente l'attribuzione delle sigle finali è facilmente implementabile, l'importnte è lo status)
2 - gli 8 pin contemporaneamente di una porta qualsiasi (quindi 8 tra I/OL/OH)
3 - tutti i pin di un micro, organizzati per porte (PortA: 8 tra I/OL/OH, PortB: 8 tra I/OL/OH, ecc. ecc.)

Se quel programma fa tutto ciò avete la mia benedizione; se legge solo un pin per volta, allora l'idea è di ha aperto questo Topic che, se non erro, è svanito (ferie? :D), 3 giorni di assenza su questo Forum significa la prescrizione di qualsiasi cosa, anche dell'idea :stuck_out_tongue_closed_eyes:.
Leo ovviamente potrà dare il suo sanissimo contributo al programma, ma poi sarà giusto citarlo :wink:

Io sono dell'avviso che se si arriva a fare ciò che è la mia idea si fa un lavoro coi czz, e poi mi darete riscontro nel tempo se è gradito o meno :wink:
Concordo che sia inutile inventarsi l'acqua fredda:
A mio avviso la procedura glbale (il punto 3) dovrebbe:
leggere lo status dei pin, se è INPUT, nel caso dei soli digitali, discorso chiuso, si indica con I, invece nel caso degli analogici bisogna capire se è INPUT analogico o digitale, nel primo caso basta indicare con IA. Se è OUTPUT si legge con digitalRead lo status H/L (in questo caso vale anche per gli analogici, in quanto in OUT sono solo digitali. Bisognerebbe solo, al limite, riuscire a stabilire se un pin OUT di quelli pwm è impostato appunto con analogWite o meno, e sarebbe perfetto.
Alla fine gli avrete fatto la risonanza magnetica al micro XD

54

altro che risonanza :grin:

allora il punto principale è che fare tutto quello che vuoi occupa parecchio spazio poichè si dovranno usare sicuramente array a roba varia.
certo è che l'idea la si fa lo stesso

ora elenco i punti e mi dici se ho capito bene
1: avere in uscita dalla funzione o quel che sarà, lo status dei pin. io li dico dimmi lo stato del pin 1 e lui mi dice IH-IL/OH-OL naturalmente è possibile sapere anche low e high su un input ( ma va :grin:)

2: intendi una specie di stringa contenente per esempio IL-OH-IH-OL-IH-OL-IL-OH-OL però così significa usare un array molto pesante.
3: un array contenete la stessa cosa del punto 2 ma per tutte le porte.

ok la questione è: un neofita è a conoscenza del port mapping? al 70% no quindi che senso ha fare le cose complicate? a sto punto facciamo sempre questa cosa e aggiungiamo quel semplice funzione di superlol.

per la pubblicazione è meglio se mi date uan dritta visto che lo devo fare io. non voglio meriti inutili. voglio includere i meriti di tutti.
ditemi voi che siete piu esperti :wink:

mi metto all'opera

55

i 3 punti sono implementabili facilmente il problema è:
che cosa deve ritornare?

intendo deve ritornare un array? un char?

prima di tutto dobbiamo sapere questo, poi possiamo passare alla programmazione.

per farti capire io per il primo punto metterei dei define di questo tipo

#define OL 10
#define OH 11
#define IL 00
#define IH 01

così la parte nel codice diventa

uint8_t modeWritten(uint8_t pin) {                    // set function that say mode of pin requested
	uint8_t bit = digitalPinToBitMask(pin);     // set BitMask(bit that corresponds to the pin requested)
	uint8_t port = digitalPinToPort(pin);       // set Port(port that corresponds to the pin requested)
        

        if((*portModeRegister(port) & bit) == 0) { // input mode, check pin status
               if(digitalRead(pin) == HIGH) return IH;
               else return IL;
        }
        else {
               if(digitalRead(pin) == HIGH) return OH;
               else return OL;
        }
        }

e una è fatta

seconda parte

uint8_t modeWrittenPort(uint8_t pin) {                    // set function that say mode of pin requested
	uint8_t port = digitalPinToPort(pin);       // set Port(port that corresponds to the pin requested)
        uint8_t toreturn[8];

        for(int bit=0; bit<=7; bit++;) {
               if((*portModeRegister(port) << bit) == 0) { // input mode, check pin status
                      if((*portModeRegister(port) << bit) == 1) toreturn[i] = IH;
                      else toreturn[i] = IL;
               }
               else { // input mode, check pin status
                      if((*portModeRegister(port) << bit) == 1) toreturn[i] = OH;
                      else toreturn[i] = OL;
               }
        }
        return toreturn;
       }

ultima funzione:

uint8_t readAllPins() {
      uint8_t toreturn[];
      for(int i=0; i<=13; i++) {
           toreturn[i] = modeWritten(i);
      }
      return toreturn;
}

mmmh.. potrebbe anche funzionare XD

sono tutte da testare e le ho scritte così ad occhio, nel caso della lettura di un'intera porta bisogna inserire il numero di un pin che sia all'interno della porta

56

igor97:

[quote author=Michele Menniti link=topic=120097.msg906740#msg906740 date=1346171909]
l'idea di Michele Menniti è quella di poter, a scelta, leggere:
1 - un pin qualsiasi avendo per ognuno I oppure OL/OH (ma naturalmente l'attribuzione delle sigle finali è facilmente implementabile, l'importnte è lo status)
2 - gli 8 pin contemporaneamente di una porta qualsiasi (quindi 8 tra I/OL/OH)
3 - tutti i pin di un micro, organizzati per porte (PortA: 8 tra I/OL/OH, PortB: 8 tra I/OL/OH, ecc. ecc.)

Se quel programma fa tutto ciò avete la mia benedizione; se legge solo un pin per volta, allora l'idea è di ha aperto questo Topic che, se non erro, è svanito (ferie? :D), 3 giorni di assenza su questo Forum significa la prescrizione di qualsiasi cosa, anche dell'idea :stuck_out_tongue_closed_eyes:.
Leo ovviamente potrà dare il suo sanissimo contributo al programma, ma poi sarà giusto citarlo :wink:

Io sono dell'avviso che se si arriva a fare ciò che è la mia idea si fa un lavoro coi czz, e poi mi darete riscontro nel tempo se è gradito o meno :wink:
Concordo che sia inutile inventarsi l'acqua fredda:
A mio avviso la procedura glbale (il punto 3) dovrebbe:
leggere lo status dei pin, se è INPUT, nel caso dei soli digitali, discorso chiuso, si indica con I, invece nel caso degli analogici bisogna capire se è INPUT analogico o digitale, nel primo caso basta indicare con IA. Se è OUTPUT si legge con digitalRead lo status H/L (in questo caso vale anche per gli analogici, in quanto in OUT sono solo digitali. Bisognerebbe solo, al limite, riuscire a stabilire se un pin OUT di quelli pwm è impostato appunto con analogWite o meno, e sarebbe perfetto.
Alla fine gli avrete fatto la risonanza magnetica al micro XD

altro che risonanza :grin:

allora il punto principale è che fare tutto quello che vuoi occupa parecchio spazio poichè si dovranno usare sicuramente array a roba varia.
certo è che l'idea la si fa lo stesso

ora elenco i punti e mi dici se ho capito bene
1: avere in uscita dalla funzione o quel che sarà, lo status dei pin. io li dico dimmi lo stato del pin 1 e lui mi dice IH-IL/OH-OL naturalmente è possibile sapere anche low e high su un input ( ma va :grin:)

2: intendi una specie di stringa contenente per esempio IL-OH-IH-OL-IH-OL-IL-OH-OL però così significa usare un array molto pesante.
3: un array contenete la stessa cosa del punto 2 ma per tutte le porte.

ok la questione è: un neofita è a conoscenza del port mapping? al 70% no quindi che senso ha fare le cose complicate? a sto punto facciamo sempre questa cosa e aggiungiamo quel semplice funzione di superlol.

per la pubblicazione è meglio se mi date uan dritta visto che lo devo fare io. non voglio meriti inutili. voglio includere i meriti di tutti.
ditemi voi che siete piu esperti :wink:

mi metto all'opera
[/quote]
dai giù a testare, io scrivo tu testi XD

57

igor97:
allora il punto principale è che fare tutto quello che vuoi occupa parecchio spazio poichè si dovranno usare sicuramente array a roba varia.
certo è che l'idea la si fa lo stesso

ti passo definitivamente tra gli eletti del Forum (mia Personal White List) XD

ora elenco i punti e mi dici se ho capito bene
1: avere in uscita dalla funzione o quel che sarà, lo status dei pin. io li dico dimmi lo stato del pin 1 e lui mi dice IH-IL/OH-OL naturalmente è possibile sapere anche low e high su un input ( ma va :grin:);

non capisco le sigle: per IH/IL cosa intendi la differenza tra digitale e analogico?
tieni presente che non operiamo solo con Arduino, ecco perché devo poter indicare il PORT oltre al pin, ma penso che tutti i core prevedano una numerazione continua, anche per i 644/1284 (Leo!?!?!? non me lo ricordo più tu hai messo mano al core e lo sai)

2: intendi una specie di stringa contenente per esempio IL-OH-IH-OL-IH-OL-IL-OH-OL però così significa usare un array molto pesante.

intendo proprio questo ma la forma la scegli tu, il dato NON va memorizzato ma semplicemente mostrato; se è più comodo si possono fare 8 letture ripetute e buttarle lì l'importante è avere l'elenco con una sola richiesta e non con 8.

3: un array contenete la stessa cosa del punto 2 ma per tutte le porte.

yes, ma come sopra, approfondisco sul tuo commento successivo.

ok la questione è: un neofita è a conoscenza del port mapping? al 70% no quindi che senso ha fare le cose complicate? a sto punto facciamo sempre questa cosa e aggiungiamo quel semplice funzione di superlol.

questo lavoro a mio avviso aiuterà più gli esperti (pensa ad un'interrograzione istantanea di un circuito di domotica durante una fase di test) che i neofiti. In realtà basterebbe implementare una lettura del file opportuno (ti dirà Leo) del core attualmente selezionato per stabilire quanti PORT hanno i vari micro o quanti pin hanno. Peraltro non mi pare che la sequenza numerica dei pin rispetti pienamente quella dei PORT, ma questo si approfondisce.....

per la pubblicazione è meglio se mi date uan dritta visto che lo devo fare io. non voglio meriti inutili. voglio includere i meriti di tutti.
ditemi voi che siete piu esperti :wink:

la pubblicazione la fate a nome di Voi due, su questo non ci piove, visto che ora SL certamente ti darà ancora una mano.
Eventuali aiuti esterni che vi daranno qualche dritta sw dovranno essere ringraziati per il contributo fornito.
Le idee non si ringraziano, a meno che tu alla fine non ritenga di aver fatto un lavoro soddisfacente e voglia dare merito a Tizio che se non vi avesse fatto due p... così non l'avreste mai realizzata :grin:

Buon lavoro ad entrambi!
Michele

58

@menniti
allora sul fatti di sapere quanti port e pin ci sono in un micro ci sto gia lavorando. tutto si basa sul file pins_arduino.h che cambia in base alla board scelta.
sto un po vedendo come interrogae questo header.

per la questione IL IH intendo Input-HIGH/Input-Low per i pin digitali
per gli analogici la questioen si fa più difficile perchè si deve vedere se i pin sono settati come digitali ecc ecc

per la whitelist :* ti ringrazio ma mi devi ancora mettere alla prova

@sl: le tue funzioni le hai fatte proprio coi piedi :grin: quanti errori. sto lavorando cmq

59

igor97:
@menniti
allora sul fatti di sapere quanti port e pin ci sono in un micro ci sto gia lavorando. tutto si basa sul file pins_arduino.h che cambia in base alla board scelta.
sto un po vedendo come interrogae questo header.

per la questione IL IH intendo Input-HIGH/Input-Low per i pin digitali
per gli analogici la questioen si fa più difficile perchè si deve vedere se i pin sono settati come digitali ecc ecc

per la whitelist :* ti ringrazio ma mi devi ancora mettere alla prova

@sl: le tue funzioni le hai fatte proprio coi piedi :grin: quanti errori. sto lavorando cmq

tranquillo che ce la fai XD; sugli analogici mi rendo conto che non è facile ma forse si può interrogare qualche registro; anche stabilire se un OUT è digitale o PWM non sarà facilissimo, ma ritengo che alcuni registri abbiano costantemente memorizzato lo stato dei vari PORT.

60

menniti, piu vado avanti e piu mi accorgo che si puo semplificare di molto il utto.

mi devi però dire: il return delle funzioni dovrà essere un intero o un char? perchè il discorso cambia.