2 arrays vergelijken met 4 code inputs op PIC16F690

[Verwijderd]

Ik zou het volgende willen bereiken;

Ik heb in hardcode vastgelegd welke volgorde er in de array CODE zou moeten, namelijk A,B,C,D.
Aan de hand van de input die gegenereerd wordt door 1 van de 4 schakelaars zou er in feite in de array PUSHED een code in moeten komen.
Ik zeg hierbij als ingang RB4 hoog wordt dan komt er de code 'A' in de array, bij RB5 komt de code 'B' , bij RB6 komt de code 'C' en bij bij RB7 komt de code 'D' de volgorde in de array PUSHED moet vastgelegd worden door welke poort er eerst, tweede, derde of als vierde (= index van PUSHED) wordt gebruikt.
De volgorde in de array PUSHED zou het zelfde moeten zijn als in array CODE om PORTC = 0b00001000 te krijgen (wat de 4de led laat branden in dit geval)
Als de array PUSHED gevuld is maar niet zoals in de array CODE dan wordt PORTC = 0b00000001 en brandt bijgevolg mijn eerste led.
het detecteren met een interrupt gebeurd via RA2 (INT).

met andere woorden dit zou een codeklavier moeten voorstellen (in code) met 4 drukknoppen en 4LED's

Het probleem;
Ik krijg het namelijk niet in werking, mijn interrupt kan wel detecteren, maar mijn 4 led's branden willekeurig ookal laat ik de 2 overige leds niet branden toch kunnen ze alle 4 aan gaan bij een interrupt...

C:

__CONFIG(INTIO & WDTDIS & PWRTEN & MCLRDIS & UNPROTECT & UNPROTECT & BORDIS & IESODIS & FCMDIS);

static unsigned char ra2_counter;
const char CODE[4] = {'A', 'B', 'C', 'D'};
static char PUSHED[4];
static int ok = 0; //aantal juiste karakters

static void interrupt isr(void)
        {               
            if(INTF){   // RA2 External Interrupt Occur
                            
                char a = ' ';
                if(RB4 == 1)
                    a = 'A';
                else if(RB5 == 1)
                    a = 'B';
                else if(RB6 == 1)
                    a = 'C';
                else if(RB7 == 1)
                    a = 'D';
                    
                    if(CODE[ra2_counter] == a)
                    {
                        ok++; //Verhoog ok met 1 => aantal 
                                                                                                                   getallen van de code juist
                    }
                    ra2_counter++; //verhoog index wachtend op volgende 
                                                                                                               waarde
                    if(ra2_counter == 4) //Wanneer volledige code dus is 
                                                                                                                   ingegeven
                    {
                        if(ok == 4) // gevuld en juiste volgorde ! 
                        {
                            PORTC = 0b00001000;
                        }
                        else //PUSHED = gevuld maar geen juiste
                                                                                                                               volgorde !
                        {
                            PORTC = 0b00000001;
                        }
                    }

            }//endfi

            else
                return;
            
            INTF = 0;                  // Clear External interrupt flag
       }

main()
{   
    TRISC = 0x00;        // Set All on PORTC as Output
    TRISA = 0x05;       //0b00001111; //RA2 input mode (digital input)
    
    TRISB = 0b11110000; // RB4,5,6,7 zijn inputs ! Is this right?
    
    ANSEL = 0b00000000; // Set PORT AN0 to AN7 digital I/O
    ANSELH = 0;          // Set PORT AN8 to AN11 as Digital I/O  /* Init ADC */
    INTE = 1; //enable RA2/INT interrupts   
    GIE = 1; //enable global interupts
    
    while (1 == 1)
    {
        
    }//endelihw
}

Alvast bedankt. Wim

[NMe]

Waarom is ra2_counter een ander type dan ok? Niet dat dat volgens mij verschil zou mogen maken, maar ik heb wel gekkere dingen gezien met de C-compiler van Microchip. Werk je met zelf in elkaar gezette hardware? Zo ja, dan kun je checken of je alle poorten wel goed hebt aangesloten. Ik heb zelf nog eens weken zitten debuggen op iets vergelijkbaars wat achteraf bleek te komen door het omwisselen van poort 4 en 5 van een DAC op het bordje waar ik aan werkte.

Weet je ook 100% zeker dat alle interrupts ook echt afgevuurd worden en dat de waarden ervan dan kloppen? Heb je al eens wat breakpoints gezet op strategische plekken in je interrupt handler?

[Coltrui]

Waar wordt die ra2_counter geïnitialiseerd en gereset? En de reset van de value van ok?

[ Voor 24% gewijzigd door Coltrui op 23-01-2010 09:43 ]

[Verwijderd]

NMe;

Wel ik gebruik MpLab en ik moet toegeven dat ik nog niet gevonden heb hoe je daarmee kunt simuleren/debuggen. Als ik dit kon zou ik een beter zicht hebben op het gebeuren, maar ik krijg steeds de error van "PK2Error0028: Unable to enter debug mode" wat mij dus niet toelaat van te debuggen.

code:

static unsigned char ra2_counter;

IPV char moet dit een int zijn ! mijn excuses

Coltrui;
ra2_counter en de value van ok zou ik resetten in het volgende;
Maar u heeft hier ook wel een goed punt, ik laat hem nu wel met andere woorden gevuld.

Net getest op breadboard en geen resultaat, ik heb nu wel dat er geen led brandt. Mijn vermoeden (vermoeden aangezien ik niet in de code kan kijken wat de variabelen krijgen tijdens de test) is dat PUSHED geen juiste waarden binnen krijgt.
De LED's branden allensinds niet meer willekeurig

code:

if(ra2_counter == 4) //Wanneer volledige code dus is  
                                                                                                                   ingegeven 
                    { 
                        if(ok == 4) // gevuld en juiste volgorde !  
                        { 
                            PORTC = 0b00001000; 
                            // hier de reset van ra2_counter en ok
                            ra2_counter = 0;
                            ok = 0;
                        } 
                        else //PUSHED = gevuld maar geen juiste 
                                                                                                                               volgorde ! 
                        { 
                            PORTC = 0b00000001; 
                            // hier de reset van ra2_counter en ok
                            ra2_counter = 0;
                            ok = 0;
                        } 
                    }

[NMe]

Verwijderd schreef op zaterdag 23 januari 2010 @ 11:58:
NMe;

Wel ik gebruik MpLab en ik moet toegeven dat ik nog niet gevonden heb hoe je daarmee kunt simuleren/debuggen. Als ik dit kon zou ik een beter zicht hebben op het gebeuren, maar ik krijg steeds de error van "PK2Error0028: Unable to enter debug mode" wat mij dus niet toelaat van te debuggen.

Heb je wel een hardware debugger zoals de bijvoorbeeld de ICD 2?

code:

static unsigned char ra2_counter;

IPV char moet dit een int zijn ! mijn excuses

Dan nog is de ene signed en de andere unsigned.

[Verwijderd]

Probleem;
Ik krijg nu het probleem dat mijn vierde led (het detecteren van de 4de keer te hebben geduwd) niet meer wilt oplichten, hij springt er blijkbaar over en gaat direct naar null = geen led oplichten (default).

Ik krijg nooit een juiste volgorde in mijn array PUSHED (= RC4 moet oplichten), maar dit kan liggen aan het probleem dat hij over de vierde keer duwen springt (detecteerd maar 3keer geduwd) (=eerste paragraaf).

Uitleg code-aanpassing;
Ik heb de code nu aangepast en de hardware om te zien wanneer er geduwd wordt en dit aan de hand van LED's (aangezien ik niet kan debuggen).
Als de PUSHED nu gelijk is aan de volgorde van CODE dan zal RC4 zijn LED oplichten. (+ 4 LEDS)
Als de volgorde van de twee arrays NIET correct zijn dan zal RC5 zijn LED oplichten. (+ 4 LEDS)
bij elke druk op de interrupt laat ik altijd een led extra branden, dus na vier keer op de knop geduwd te hebben branden er normaal 4 leds dit kun je onderaan in de code zien in de while-loop en tegelijk met deze 4LED's dat branden zal afhankelijk van de volgorde in PUSHED de led in RC4 of RC5 oplichten.

RC4 en RC5 zijn erbij gekomen om te zien of de PUSHED dezelfde volgorde heeft als CODE

C:

__CONFIG(INTIO & WDTDIS & PWRTEN & MCLRDIS & UNPROTECT & UNPROTECT & BORDIS & IESODIS & FCMDIS);

static unsigned int ra2_counter = 0;
const char CODE[4] = {'A', 'B', 'C', 'D'};
static char PUSHED[4];

static int ok = 0;

static void interrupt isr(void)
        {               
            if(INTF){   // RA2 External Interrupt Occur
                            
                char a = ' '; // elke ingang krijgt zijn eigen code letter
                if(RB4 == 1)
                    a = 'A';
                else if(RB5 == 1)
                    a = 'B';
                else if(RB6 == 1)
                    a = 'C';
                else if(RB7 == 1)
                    a = 'D';
                    
                    if(CODE[ra2_counter] == a)
                    {
                        ok++; //Verhoog ok met 1 => aantal 
                                                                                                               getallen van de code juist   
                    }
                    ra2_counter++; //verhoog index wachtend op volgende 
                                                                                                             waarde
                    if(ra2_counter == 4) //Wanneer volledige code dus is 
                                                                                                                   ingegeven
                    {
                        if(ok == 4)//4 int's = juist!
                        {
                            PORTC = 0b00011111;
                            ra2_counter = 0;
                            ok = 0;
                            //4LED's + RC4 (volgorde = juist)
                        }
                        else
                        {
                            PORTC = 0b00101111;
                            ra2_counter = 0;
                            ok = 0;
                            //4LED's + RC5 (volgorde = fout)                        }
                    }

                //}//endrof
            }//endfi
            else
                return;
            
            INTF = 0;                  // Clear External interrupt flag
       }//end interrupt

main()
{   
    TRISC = 0x00;        // Set All on PORTC as Output
    TRISA = 0x05;           
    TRISB = 0b11110000; // RB4,5,6,7 zijn inputs ! correct ?
    ANSEL = 0b00000000; // Set PORT AN0 to AN7 digital I/O
    ANSELH = 0;          // Set PORT AN8 to AN11 as Digital I/O  /* Init ADC */
    INTE = 1; //enable RA2/INT interrupts   
    GIE = 1; //enable global interupts
    
    while (1 == 1)
    {
        switch(ra2_counter){
            default:
                PORTC = 0x00;   //niets gedrukt = alles uit
                break;
            case 1:
                PORTC = 0x01;   //eerste led brandt
                break;
            case 2:
                PORTC = 0x03;   // 2de led brandt
                break;
            case 3:
                PORTC = 0x07;   // 3de led brandt
                break;
            case 4:
                PORTC = 0x0F;   // 4de led brandt
                break;
            case 5:
                PORTC = 0x00;   //kunt niet 5keer duwen dus = alles uit
                ra2_counter = 0;
                break;
        }//hctiws

        
    }//endelihw
}

[Verwijderd]

NMe schreef op zaterdag 23 januari 2010 @ 12:32:
[...]

Heb je wel een hardware debugger zoals de bijvoorbeeld de ICD 2?

[...]

Dan nog is de ene signed en de andere unsigned.

Verdorie, kijk precies scheef, je hebt gelijk !

[NMe]

Nogal wiedes: na het oplichten van je laatste lampje reset je ra2_counter naar 0. In je main loop kom je vervolgens direct in de conditie aan die op basis daarvan al je LEDs weer uitzet.

[NC83]

C:

__CONFIG(INTIO & WDTDIS & PWRTEN & MCLRDIS & UNPROTECT & UNPROTECT & BORDIS & IESODIS & FCMDIS);

static unsigned int ra2_counter = 0;
const char CODE[4] = {'A', 'B', 'C', 'D'};
static char PUSHED[4];

static int ok = 0;

Het array PUSHED wordt in dit geval nergens gebruikt dus waarom is dat gedeclareerd. En waarom zijn bijna alle variable static terwijle het ook nog eens globals zijn wat ze per definitie de waarde laat onthouden tussen function calls.

Als je een timer in de default case triggered of een for loop van een bepaalde duur kun je wel je LED's zien oplichten.

[ Voor 68% gewijzigd door NC83 op 23-01-2010 14:08 ]

[NMe]

NC83 schreef op zaterdag 23 januari 2010 @ 14:07:
Het array PUSHED wordt in dit geval nergens gebruikt dus waarom is dat gedeclareerd.

In dit stukje code niet (meer) nee, maar ergens anders misschien wel?

En waarom zijn bijna alle variable static terwijle het ook nog eens globals zijn wat ze per definitie de waarde laat onthouden tussen function calls.

Nou:
[quote=http://en.wikipedia.org/wiki/Static_variable]In the C programming language and its descendants, the term static variable has at least three separate meanings, each related to the semantics of C's static keyword:

• Static global variables are declared as "static" at the top level of a source file. Such variables are not visible outside the source file ("file scope"), unlike variables declared as "extern".
• Static local variables are declared inside a function, just like automatic local variables. They have the same scope as normal local variables, differing only in "storage duration": whatever values the function puts into static local variables during one call will still be present when the function is called again.
• C++ has static member variables: in classes, member variables declared as "static" are class variables (as opposed to instance variables).

Dus.

Als je een timer in de default case triggered of een for loop van een bepaalde duur kun je wel je LED's zien oplichten.

De tijd die in het spenderen van die timer zit zou ik liever steken in het oplossen van het probleem door anders te signalen naar de main loop dan nu gedaan wordt.

[Coltrui]

Ik kan me niet van de indruk ontdoen dat wanneer je voor jezelf eens in pseudocode uitschrijft wat je wilt, je al een heel eind zal komen

[ Voor 193% gewijzigd door Coltrui op 23-01-2010 19:05 ]

[Verwijderd]

Ik ga me aan het werk zetten met de nuttige info die ik net gekregen heb.
Ik ga eerst al naar een deftig drukknopje zoeken, want met de hand krijg ik hier bizare resultaten met de interrupt van RA2. (beetje VEEL te gevoelig aan externe detectie)

[Miyamoto]

Heb je rekening gehouden met contact bounce? Dit kan ook hele leuke (onverwachte) effecten geven!

[dwilmer]

Miyamoto schreef op zondag 24 januari 2010 @ 12:42:
Heb je rekening gehouden met contact bounce? Dit kan ook hele leuke (onverwachte) effecten geven!

Het is inderdaad handig om eerst te debouncen. Anders krijg je vaak twee of drie impulsen achter elkaar (of in ieder geval voor de knopjes die we toen bij het practicum gebruikten).

Een beetje googlen zou je hierbij kunnen helpen.

[Verwijderd]

verandering;
Ik heb een externe debounce switch samengesteld die voldoet aan mijn eisen (interrupt doet niet raar meer).
Later ga ik hier code voor schrijven omdat ik met een timer ga werken.

Mijn code is gewijzigt om de twee array's te vergelijken en ook bij het ingeven is er een grotere controle (if).

Probleem;
Bij het aanschakelen van de voeding na hij af stond dus, licht ALTIJD mijn eerste LED op (RC0), wanneer ik niet zie hoe dit kan gebeuren. Ik initialiseer ook mijn portc voor de zekerheid maar toch doet hij dit.

het grootste probleem nu is dat mijn rode led op poort RC5 NIET oplicht bij foute invoer. In plaats daarvan gaat mijn groene led aan (RC4).
De groene led gaat met andere woorden altijd aan en maakt het niet uit welke waarde je in PUSHED steekt!
Er moet wel altijd vier keer en input geweest zijn en dan pas licht hij op. PUSHED leeg ik niet, is dit nodig? Zo ja bestaat er een clear functie om een array te legen in de PIC16F690 of C?

C:

__CONFIG(INTIO & WDTDIS & PWRTEN & MCLRDIS & UNPROTECT & UNPROTECT & BORDIS & IESODIS & FCMDIS);
// gebruik van interne klok van 8MHz

static int ra2_counter = 0;
const char CODE[4] = {'A', 'B', 'C', 'D'};
char PUSHED[4];

static void interrupt isr(void)
        {               
            if(INTF){   // RA2 detecteren van een externe interrupt
                            
                char a = ' ';
                if(RB4 == 1)
                    a = 'A';
                else if(RB5 == 1)
                    a = 'B';
                else if(RB6 == 1)
                    a = 'C';
                else if(RB7 == 1)
                    a = 'D';
                    
                if(a = ' ' && ra2_counter < 5 && (RB4 == 1 || RB5 == 1 || RB6 == 1 || RB7 == 1))
                { //PUSHED enkel vullen als er een ingang hoog staat en a niet leeg is!
                    PUSHED[ra2_counter] == a;
                }
                else // voor de zekerheid a terug legen
                    a = ' ';
                //index verhogen
                ra2_counter++;
            }//endfi
            else
                return;
            
            INTF = 0;                  // externe interrupt flag initialiseren
       }

main()
{   
    TRISC = 0x00;        // alles op PORTC als uitgang zetten
    PORTC = 0x00;        // alle uitgangen van PORTC UIT ZETTEN
    TRISA = 0x05;       //0b00001111; //RA2 input mode (digital input)
    
    TRISB = 0b11110000; // RB4,5,6,7 zijn inputs ! 
    
    ANSEL = 0b00000000; // Set PORT AN0 to AN7 digital I/O
    ANSELH = 0;          // Set PORT AN8 to AN11 as Digital I/O  /* Init ADC */
    INTE = 1; //enable RA2/INT interrupts   
    GIE = 1; //enable global interupts

    
    while (1 == 1)
    {
        switch(ra2_counter){
            case 1:
                PORTC = 0x01;   //first led is on
                break;
            case 2:
                PORTC = 0x03;   // 2 leds on
                break;
            case 3:
                PORTC = 0x07;   // 3 leds on
                break;
            case 4:
                PORTC = 0x0F;   // 4 leds on
                break;
            case 5:
                PORTC = 0x00;   //er is geen 5de invoer, dus alles terug initialiseren
                ra2_counter = 0;
                break;
        }//hctiws
        
        if(ra2_counter == 4 && CODE == PUSHED)// juiste invoer
            {
                //de 4led's aan + een groene op RC4
                PORTC = 0b00101111;
            }
        if(ra2_counter == 4 && CODE != PUSHED)// foute invoer
            {
                //de 4led's aan + een rode op RC5
                PORTC = 0b00011111;
            }       
    }//endelihw
}

[Verwijderd]

Mijn excuses, maar de groene led voor dat alles goed is staat namelijk op RC4 zoals ik had vermeld, maar niet in de toekenning van PORTC namelijk =>

C:

if(ra2_counter == 4 && CODE == PUSHED)// juiste invoer 
            { 
                //de 4led's aan + een groene op RC4 
                PORTC = 0b00011111; 
            } 
        if(ra2_counter == 4 && CODE != PUSHED)// foute invoer 
            { 
                //de 4led's aan + een rode op RC5 
                PORTC = 0b00101111;  //staat omgewisseld met wat ik eerder vermelde (groen was dan rood en omgekeerd)!
            }

[Verwijderd]

Nog rap deze kleine toelichting;
In volgende if komt hij altijd

C:

if(ra2_counter == 4 && CODE != PUSHED)// foute invoer  
            { 
                //de 4led's aan + een rode op RC5 
                PORTC = 0b00101111; 
            }

maar pushed en code komen nooit evereen.

C:

if(ra2_counter == 4 && CODE == PUSHED)// juiste invoer
          {
               //de 4led's aan + een groene op RC4
              PORTC = 0b0011111;
         }

Een positief signaal geven per interrupt doe ik als volgt;

- de 5V op de eerste pin en dan een interrupt veroorzaken op RA2.
- dan hetzelfde voor de volgende inputs
- alle vier gedaan, dan krijg ik direct het rood lapmje ( FOUTE INVOER, terwijl dit juist zou moeten zijn )

[ Voor 4% gewijzigd door Verwijderd op 24-01-2010 20:56 ]

[Miyamoto]

Je initialiseert Poort C terecht als uitgang, met TRISC, waarom probeer je daarna toch "de uitgangen uit te zetten" door PORTC op 0x00 te zetten?

Nog iets 'vreemds':

code:

if(a = ' ' && ra2_counter < 5 && (RB4 == 1 || RB5 == 1 || RB6 == 1 || RB7 == 1))

Het is toch niet noodzakelijk dat de ingangen hier nog steeds hoog zijn? Ze zijn hoog geweest, anders was a leeg. (Dat controleer je al met de if's erboven).

Mogelijk dat comparator 2 problemen geeft bij het opstarten, schakel deze ook eens expliciet uit? (CM2CON0 = 0x80, zie blz 84 van de datasheet)

Mocht het nog allemaal niet werken zou je kunnen overwegen om als test vier variabelen te nemen die je een integer-waarde meegeeft. Afhankelijk van je teller controleer je een van deze variabelen. De mogelijke inputs geef je natuurlijk ook allemaal een waarde.

Het is overigens echt een aanrader om de ICD2 aan te schaffen. Dat scheelt je echt een hoop tijd. Op Ebay zijn namaak-debuggers te krijgen die iets goedkoper zijn dan het origineel. Ik heb er zelf destijds een aangeschaft bij deze ebay-winkel: http://myworld.ebay.nl/sivavath/ Je kunt dan live debuggen en direct zien wat alle poorten en variabelen doen.

Aanvulling
Als je de karakters (PUSHED/CODE) veranderd in binaire waarden, kun je deze ook weergeven op een poort als 'debug' functie. Zo zou je dan onderstaande code kunnen testen:

code:

if(ra2_counter == 4)
PORTB = PUSHED;

Aanvulling2
In de code die je net hierboven plaatst staaat een fout.... Je gebruikt maar 7 ipv 8 symbolen in de 2e if....

[ Voor 22% gewijzigd door Miyamoto op 24-01-2010 21:05 . Reden: Aanvulling2 ]

[farlane]

CODE != PUSHED

Arrays kun je niet op die manier met elkaar vergelijken. Lees nog eens wat meer over arrays en pointers in c want die horen toch echt wel bij de basis.

[NMe]

CODE != PUSHED evalueert inderdaad gek genoeg altijd naar true.

[Verwijderd]

Ik heb mijn code aangepast, maar geeft nog altijd niet juist aan, ik krijg altijd een foute waarde (RODE led) ookal moet die normaal juist zijn. binnen 2 weken is mijn school terug open en kan ik kijken via een debugger naar het "probleem", hier heb ik allensinds mijn code uitgetypt;

C:

__CONFIG(INTIO & WDTDIS & PWRTEN & MCLRDIS & UNPROTECT & UNPROTECT & BORDIS & IESODIS & FCMDIS);

static int ra2_counter = 0;
const int CODE[4] = {1, 2, 3, 4}; // vaste waarde dient om volgorde na te gaan.
char PUSHED[4];     // hier komt de waarde in voor welke toets bedient is geweest
static int ok = 0; // telt hoeveel er juist van volgorde in PUSHED
static int i = 0;  // dient voor de for-loop

static void interrupt isr(void)
        {               
            if(INTF){   // RA2 detecteren van een externe interrupt
                            
                int a = 0;
                if(RB4 == 1 && RB5 != 1 && RB6 != 1 && RB7 != 1)
                    a = 1;
                else if(RB5 == 1 && RB4 != 1 && RB6 != 1 && RB7 != 1)
                    a = 2;
                else if(RB6 == 1 && RB4 != 1 && RB5 != 1 && RB7 != 1)
                    a = 3;
                else if(RB7 == 1 && RB4 != 1 && RB5 != 1 && RB6 != 1)
                    a = 4;
                    
                if(a != 0 && ra2_counter < 5)
                { //PUSHED enkel vullen als er een ingang hoog staat en a niet leeg is!
                    PUSHED[ra2_counter] == a;
                }
                else // voor de zekerheid a terug legen
                    a = 0;
                //index verhogen
                ra2_counter++;
            }//endfi
            else
                return;
            
            INTF = 0;                  // externe interrupt flag initialiseren
       }

main()
{   
    TRISC = 0x00;        // alles op PORTC als uitgang zetten
    TRISA = 0x05;       //0b00001111; //RA2 input mode (digital input)
    TRISB = 0b11110000; // RB4,5,6,7 zijn inputs ! 
    ANSEL = 0b00000000; // Set PORT AN0 to AN7 digital I/O
    ANSELH = 0;          // Set PORT AN8 to AN11 as Digital I/O  /* Init ADC */
    INTE = 1;           //enable RA2/INT interrupts   
    GIE = 1;            //enable global interupts
    CM2CON0 = 0x80;     //zie blz 84 van de datasheet => comperator uitschakelen
    
    while (1 == 1)
    {
        switch(ra2_counter){ //toont of er degelijk gedrukt is geweest en hoeveel keer (max 4)
            case 1:
                PORTC = 0x01;   // eerste led aan
                break;
            case 2:
                PORTC = 0x03;   // twee led's aan
                break;
            case 3:
                PORTC = 0x07;   // drie led's aan
                break;
            case 4:
                PORTC = 0x0F;   // vier led's aan
                break;
            case 5:
                loop(); // werkende vertragingsfunctie van 3seconden
                PORTC = 0x00;   //er is geen 5de invoer, dus alles terug initialiseren
                ra2_counter = 0;
                ok = 0;
                break;
        }//hctiws
        
        if (ra2_counter == 4) // als er vier codes ingegeven zijn
        {
            for(i = 0; i<4; i++) // indexen overlopen en vergelijken
                {
                    if(CODE[i] == PUSHED[i])
                    {
                        ok++; // vier keer juist is gelijk aan correct dus groen led aan op RC4
                    }
            }
        }
            
        if(ra2_counter == 4 && ok == 4)// juiste invoer
            {
                //de 4led's aan + een groene op RC4
                PORTC = 0b00011111;
                loop(); 
                PORTC = 0x00;
                ra2_counter = 0;
                ok = 0;
            }
        
        // hij springt ALTIJD in deze if ...
        if(ra2_counter == 4 && ok != 4)// foute invoer
            {
                //de 4led's aan + een rode led op RC5
                PORTC = 0b00101111;
                loop(); 
                PORTC = 0x00;
                ra2_counter = 0;
                ok = 0;
            }       
    }//endelihw
}

[Miyamoto]

C:

                if(a != 0 && ra2_counter < 5)
                { //PUSHED enkel vullen als er een ingang hoog staat en a niet leeg is!
                    PUSHED[ra2_counter] == a;
                }

Wordt de array PUSHED wel goed gevuld?
Als je inputs op B niet meer hoog zijn ten tijde van de interrupt, gaat het fout.

En weet je zeker dat je niet in case 5 van je switch komt?

Wat ik deed toen ik nog geen debugger had, was de waarde van de variabelen dmv een ledje laten zien.
Zo kun je bijvoorbeeld de waarde van de items van PUSHED laten zien door een LEDje een gelijk aantal keer te laten knipperen.

Je zult het stap voor stap moeten debuggen. Desnoods begin je overnieuw en breid je je code iedere keer uit. Wat als je ipv twee arrays eens begint met twee variabelen? (Dus een code met lengte 1?)

[Verwijderd]

daar heb je een punt, dat moest wel degelijk = en niet == zijn !
Maar heb het net getest en met hetzelfde resultaat.

Zal nog een methode zoeken...

[ Voor 70% gewijzigd door Verwijderd op 29-01-2010 13:33 ]

[Verwijderd]

Beste mensen,

dank u allen voor de hulp.

De software was uiteindelijk wel juist, maar moest in de hardware nog een aanpassing maken bij de ingangen, namelijk een weerstand op de ingang naar de massa plaatsen.