Arduino YUN Interrupt

International Italiano Software
1

Ciao a tutti,
è la prima volta che scrivo sul forum e chiedo scusa in anticipo ho sbagliato sezione.
Il problema è legato agli interrupt e non riesco riesco a trovare una soluzione al problema legato all'Arduino YUN e spero che riuscite ad aiutarmi nel problema..
Dunque... sto cercando di intercettare segnali 433Mhz provenienti da Sensori esterni, ma sembra che la l'interrupt in questione (ma li ho provati tutti) non venga sollevato. Premetto che tale codice è correttamente funzionante su Arduino UNO.
Di seguito il codice:

volatile word pulse;

OregonDecoderV2 orscV2;
OregonDecoderV3 orscV3;

void ext_int_1(void) {
    static word last;
    pulse = micros() - last;
    last += pulse;
}


void setup () {
   Serial.begin(115200);
   while (!Serial);
   attachInterrupt(1, ext_int_1, CHANGE);
   Serial.println("Ready");
}

void loop () {
    static int i = 0;
    cli();
    word p = pulse;
    
    pulse = 0;
    sei();
   
    if (p != 0) {
        if (orscV2.nextPulse(p))
            reportSerial("OSV2", orscV2);   //Print data
        if (orscV3.nextPulse(p))
            reportSerial("OSV3", orscV3);   //Print data     
    }
}

Aggiungo che l'interrupt 1 è collegato al PIN 2 dell'Arduino YUN. Mentre sull'Arduino UNO corrisponde al PIN 3.
Ho provato anche ad aggiungere dei delay nel loop sperando di risolvere .. ma senza nessun esito.

Gli interrupt sull'Arduino YUN funzionano in quanto ho testato con un pulsante la cosa. Alla pressione del pulsante accendevo un LED per 1 sec.

Non riesco a trovare ed a capire come mai il codice presentato non funzioni.

Ringraziando in anticipo tutti.

Ciao

2

A parte che mi pare manchi l'inclusione di qualche libreria, perché non so OregonDecoder cosa sia, ma non è che le lib che stai usando sono incompatibili con l'Atmega32U4 della Yun? Ricorda che è un micro diverso dall'Atmega328 della Uno.

3

Ciao e ti ringrazio per la risposta... mi scuso per non aver messo l'intero codice.. eccolo:

#include<Process.h>

class DecodeOOK {
protected:
    byte total_bits, bits, flip, state, pos, data[25];

    virtual char decode (word width) =0;
    
public:

    enum { UNKNOWN, T0, T1, T2, T3, OK, DONE };

    DecodeOOK () { resetDecoder(); }

    bool nextPulse (word width) {
        if (state != DONE)
        
            switch (decode(width)) {
                case -1: resetDecoder(); break;
                case 1:  done(); break;
            }
        return isDone();
    }
    
    bool isDone () const { return state == DONE; }

    const byte* getData (byte& count) const {
        count = pos;
        return data; 
    }
    
    void resetDecoder () {
        total_bits = bits = pos = flip = 0;
        state = UNKNOWN;
    }
    
    // add one bit to the packet data buffer
    
    virtual void gotBit (char value) {
        total_bits++;
        byte *ptr = data + pos;
        *ptr = (*ptr >> 1) | (value << 7);

        if (++bits >= 8) {
            bits = 0;
            if (++pos >= sizeof data) {
                resetDecoder();
                return;
            }
        }
        state = OK;
    }
    
    // store a bit using Manchester encoding
    void manchester (char value) {
        flip ^= value; // manchester code, long pulse flips the bit
        gotBit(flip);
    }
    
    // move bits to the front so that all the bits are aligned to the end
    void alignTail (byte max =0) {
        // align bits
        if (bits != 0) {
            data[pos] >>= 8 - bits;
            for (byte i = 0; i < pos; ++i)
                data[i] = (data[i] >> bits) | (data[i+1] << (8 - bits));
            bits = 0;
        }
        // optionally shift bytes down if there are too many of 'em
        if (max > 0 && pos > max) {
            byte n = pos - max;
            pos = max;
            for (byte i = 0; i < pos; ++i)
                data[i] = data[i+n];
        }
    }
    
    void reverseBits () {
        for (byte i = 0; i < pos; ++i) {
            byte b = data[i];
            for (byte j = 0; j < 8; ++j) {
                data[i] = (data[i] << 1) | (b & 1);
                b >>= 1;
            }
        }
    }
    
    void reverseNibbles () {
        for (byte i = 0; i < pos; ++i)
            data[i] = (data[i] << 4) | (data[i] >> 4);
    }
    
    void done () {
        while (bits)
            gotBit(0); // padding
        state = DONE;
    }
};

// 433 MHz decoders


class OregonDecoderV2 : public DecodeOOK {
public:
    OregonDecoderV2() {}
    
    // add one bit to the packet data buffer
    virtual void gotBit (char value) {
        if(!(total_bits & 0x01))
        {
            data[pos] = (data[pos] >> 1) | (value ? 0x80 : 00);
        }
        total_bits++;
        pos = total_bits >> 4;
        if (pos >= sizeof data) {
            resetDecoder();
            return;
        }
        state = OK;
    }
    
    virtual char decode (word width) {
       if (200 <= width && width < 1200) {
            //Serial.println(width);
            byte w = width >= 700;
 
            switch (state) {
                case UNKNOWN:
                    if (w != 0) {
                        // Long pulse
                        ++flip;
                    } else if (w == 0 && 24 <= flip) {
                        // Short pulse, start bit
                        flip = 0;
                        state = T0;
                    } else {
                        // Reset decoder
                        return -1;
                    }
                    break;
                case OK:
                    if (w == 0) {
                        // Short pulse
                        state = T0;
                    } else {
                        // Long pulse
                        manchester(1);
                    }
                    break;
                case T0:
                    if (w == 0) {
                      // Second short pulse
                        manchester(0);
                    } else {
                        // Reset decoder
                        return -1;
                    }
                    break;
              }
        } else if (width >= 2500  && pos >= 8) {
            return 1;
        } else {
            return -1;
        }
        return 0;
    }
};

void reportSerial (const char* s, class DecodeOOK& decoder)
{
    byte pos;
    const byte* data = decoder.getData(pos);
    Console.print(s);
    Console.print(' ');
    for (byte i = 0; i < pos; ++i) {
        Serial.print(data[i] >> 4, HEX);
        Serial.print(data[i] & 0x0F, HEX);
    }
};

questo prima del codice precedente.

Di nuovo grazie.