ElectroYou

Salve a tutti
Come sapete Arduino ha reso semplice la vita a molti scansafatiche come me.
Tutto grazie a delle librerie che permettono con dei comandi molto intuitivi di controllare cose del micro che richiederebbero magari alcune linee di codice e un po' più di attenzione.
Mi chiedevo però dove fosse possibile trovare i "codici" di queste librerie.
Vorrei sapere insomma qual è il corrispettivo codice C che viene compilato quando io scrivo "digitalWrite(pin,LOW)" o gli altri comandi tipici di Arduino.
Ho cercato ma non ho trovato nulla

Immagino, non sapendolo, che sia know-how che si tengono ben nascosto nei loro cassetti, chiusi a chiave.

Beh, a me risulta che l'IDE è opensource https://github.com/arduino/Arduino/tree/1.6.9 dove leggi anche

"Arduino uses GNU avr-gcc toolchain, GCC ARM Embedded toolchain, avr-libc, avrdude, bossac, openOCD and code from Processing and Wiring."

Magari comincia da qui o dalla community che lavora sulle fork.

paofanello perché non provi ad approfondire il concetto di layer di astrazione dell'hardware?
Una volta capito il concetto non avrai bisogno di sbirciare i sorgenti di arduino o di qualsiasi altro sistema, ma avrai una visione più corretta di come organizzare un programma ben scritto.

O.T.: Guardare il codice altrui non e` sempre un male.
Tanti anni fa, guardai il codice di come si calcolano le quattro funzioni trigonometriche con un micro che di suo eseguiva solo somme e sotrazioni...
Un algoritmo interessante che non conoscevo.

Quello che dici è vero.
Tuttavia paofanello ha menzionato una funzione che rientra nel concetto di astrazione del hardware (anche se lascia molto a desiderare per motivi che non dirò).
A questo punto, perché girarci intorno invece di affrontare la cosa di petto?

Candy ha scritto:O.T.: Guardare il codice altrui non e` sempre un male.
Tanti anni fa, guardai il codice di come si calcolano le quattro funzioni trigonometriche con un micro che di suo eseguiva solo somme e sotrazioni...
Un algoritmo interessante che non conoscevo.

No, infatti. Guardare il codice altrui è, secondo me, un ottimo esercizio. Fonte di grande ispirazione e istruzione. Soprattutto se è stato scritto da professionisti.

Consideriamo sempre che in informatica per ogni problema ci possono essere centinaia di soluzioni, dunque...

Mi sa che il fatto di avere le idee poco chiare mi ha portato sulla cattiva strada.
Pensavo, analizzando i codici sorgenti di Arduino, di poter velocizzare qualche comando dato al micro senza però studiarmi per bene come andrebbe fatto veramente.
Non che non possa essere fatto, ma non mi piace la sensazione di ignoranza che mi sta dando quest'approccio.
Penso che seguirò l'esempio di Sjuanez e inizierò un libro sull'argomento, così da fare le cose con calma e metodo, poi magari mi darò un'occhiata ai sorgenti di Arduino per vedere come funzionano le sue librerie. E non il contrario.
Scusate se vi ho fatto perdere un po' del vostro tempo, però vi assicuro che qualcosa mi avete fatto capire: che ho troppo da capire

il cassetto si chiama wiring_digital.c
ed è di pubblico dominio

questa è digitalWrite()

Codice: Seleziona tutto

void digitalWrite(uint8_t pin, uint8_t val)
{
        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;
}

e le sue dipendenze

Codice: Seleziona tutto

const uint8_t PROGMEM digital_pin_to_timer_PGM[] = {
        NOT_ON_TIMER, /* 0 - port D */
        NOT_ON_TIMER,
        NOT_ON_TIMER,
        TIMER2B,
        NOT_ON_TIMER,
        TIMER0B,
        TIMER0A,
        NOT_ON_TIMER,
        NOT_ON_TIMER, /* 8 - port B */
        TIMER1A,
        TIMER1B,
        TIMER2A,
        NOT_ON_TIMER,
        NOT_ON_TIMER,
        NOT_ON_TIMER,
        NOT_ON_TIMER, /* 14 - port C */
        NOT_ON_TIMER,
        NOT_ON_TIMER,
        NOT_ON_TIMER,
        NOT_ON_TIMER,
};


const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[] = {
        _BV(0), /* 0, port D */
        _BV(1),
        _BV(2),
        _BV(3),
        _BV(4),
        _BV(5),
        _BV(6),
        _BV(7),
        _BV(0), /* 8, port B */
        _BV(1),
        _BV(2),
        _BV(3),
        _BV(4),
        _BV(5),
        _BV(0), /* 14, port C */
        _BV(1),
        _BV(2),
        _BV(3),
        _BV(4),
        _BV(5),
};

const uint8_t PROGMEM digital_pin_to_port_PGM[] = {
        PD, /* 0 */
        PD,
        PD,
        PD,
        PD,
        PD,
        PD,
        PD,
        PB, /* 8 */
        PB,
        PB,
        PB,
        PB,
        PB,
        PC, /* 14 */
        PC,
        PC,
        PC,
        PC,
        PC,
};

static void turnOffPWM(uint8_t timer)
{
        switch (timer)
        {
                case TIMER1A:   cbi(TCCR1A, COM1A1);    break;
                case TIMER1B:   cbi(TCCR1A, COM1B1);    break;
                case  TIMER0A:  cbi(TCCR0A, COM0A1);    break;
                case  TIMER0B:  cbi(TCCR0A, COM0B1);    break;
                case  TIMER2A:  cbi(TCCR2A, COM2A1);    break;
                case  TIMER2B:  cbi(TCCR2A, COM2B1);    break;
        }
}

const uint16_t PROGMEM port_to_output_PGM[] = {
        NOT_A_PORT,
        NOT_A_PORT,
        (uint16_t) &PORTB,
        (uint16_t) &PORTC,
        (uint16_t) &PORTD,
};

se sei interessato al C ti consiglio di programmare Arduino con le avr-libc,
ti basterebbe una riga di codice per attivare/azzerare un pin. Es.:

Codice: Seleziona tutto

PORTB &= ~(1 << PB1);  // PB1=0
PORTB |=  (1 << PB1);  //  PB1=1