Atmega 162 bizzart fel i if sats tangentbord

[rysshack.se]

Har ett 16 knappars tangentbord, för att testa om det funkar, vill jag skriva ut värden till dioderna på ett stk500
Nu kommer det bizzarra.

Det funkar med alla värden, så länge jag kör en if-satsen likt i koden, och inte testar mer än två värden.
Har avkommenterat delar av satsen i koden nedan.
Någon som har koll på varför det inte funkar med en längre if sats (om jag tar bort avkommenteringen på resten av if satsen)
Det som händer är att det hänger sig... eller endast binärvärdet för 'E' skrivs ut på dioderna.

Kod: Markera allt

#define F_CPU 8000000UL
#include <avr/io.h>
#include <stdio.h>
#include <util/delay.h>

#define zero	0b10111110
#define one 	0b10001000
#define two 	0b01001000
#define three 	0b00101000
#define four 	0b10000100
#define five 	0b01000100
#define six 	        0b00100100
#define seven 	0b10000010
#define eight 	0b01000001
#define nine 	0b00100001
#define letterA    0b00011000
#define letterB    0b00001100
#define letterC    0b00010010
#define letterD    0b00010001
#define star	0b10000001
#define square 	0b00100001

char Test();

int main (void)
{
	DDRC=0xff;
	while(1)
	{
		PORTC=Test();
	}

	return(0);

}

char Test()
{ 	
	char KeyBoardValue,CharValue;
	/*Läser av fyra ben*/
	DDRB=0x0f;
	PORTB=0xf0;
	KeyBoardValue=PINB;
	/*-----------------*/
	
	//_delay_ms (80);
	/*Läser av de andra fyra benen och lägger ihop värdet med hjälp av maskning*/
	DDRB=0xf0;
	PORTB=0x0f;
	KeyBoardValue=(KeyBoardValue&0xf0)|(PINB&0x0f); //Maskar ut värdet
	/*-------------------------------------------------------------------------*/

	if		(KeyBoardValue==one)	{CharValue='1';} 
	else if (KeyBoardValue==two)	{CharValue='2';}
/*	else if (KeyBoardValue==three)	{CharValue='3';}
	else if (KeyBoardValue==four)	{CharValue='4';}
	else if (KeyBoardValue==five)	{CharValue='5';}
	else if (KeyBoardValue==six)	{CharValue='6';}
	else if (KeyBoardValue==seven)	{CharValue='7';}
	else if (KeyBoardValue==eight)	{CharValue='8';}
	else if (KeyBoardValue==nine)	{CharValue='9';}
	else if (KeyBoardValue==letterA){CharValue='A';}
	else if (KeyBoardValue==letterB){CharValue='B';}
	else if (KeyBoardValue==letterC){CharValue='C';}
	else if (KeyBoardValue==letterD){CharValue='D';}	
	else if (KeyBoardValue==star)	{CharValue=0x31;}
	else if (KeyBoardValue==square)	{CharValue=0x31;}*/
	else {CharValue='E';}
	return CharValue;
}

[eqlazer]

Fungerar tangentbordet? Så att den detekterar 1 och 2 korrekt?
Du har inte funderat på att använda switch-sats istället? Inte för att det borde lösa några problem men det är nog vanligare att använda en sån i dessa fall och iaf jag tycker det ser snyggare och mer läsbart ut.

[rysshack.se]

Joo, 1, 2 fungera korrekt. Det gör även de andra tangenterna.
Jag kan byta ut 1 eller 2 mot vilken annan tangent som helst.
Men när jag försöker med fler än två val funkar det inte.

Joo, jag började skriva en switch sats, när inte den ville funka skrev jag ifsatsen istället......

Kod: Markera allt

switch (KeyBoardValue)                 
    {	
		case zero:		CharValue=0x30;break;
     	case one: 		CharValue=0x31;break;
		case two: 		CharValue=0x32;break;
		case three: 	CharValue=0x33;break;
		case four: 		CharValue=0x34;break;
		case five: 		CharValue=0x35;break;
		case six: 		CharValue=0x36;break;
		case seven: 	CharValue=0x37;break;
		case eight: 	CharValue=0x38;break;
		case nine: 		CharValue=0x39;break;
		case letterA: 	CharValue=0x41;break;
		case letterB: 	CharValue=0x42;break;
		case letterC: 	CharValue=0x43;break;
		case letterD: 	CharValue=0x44;break;
		case star: 		CharValue=0x31;break;
		case square:	CharValue=0x31;break;

    default: CharValue=0x45;//Ska visa bokstaven E vid fel, eller inget annat nedtryckt
    }

Nu står det inte '1' utan istället hexvärdet, men det bör funka ändå....
Börjar tro att det är någon fuse, som spökar, skall kolla in om jag gjort något stort fail i makefilen.
Alternativt att microcontrollern är skadad.

[Icecap]

Jag ser för mig ett matris-kopplat t-bord utan dioder.

Har du ens testat att läsa ut det värde den läser? Alltså det binära värde som KeyBoardValue blir, det ska ju bli xxxx1111 som jag ser det och det fungerar helt enkelt inte. Om du drar alla kolumner till '1' kan du bara se OM en knapp är aktiverat, inte vilken.

Jag tror att du har glömt dioderna till matrisen men det är ju inte angivit något om detta så du kan ha kopplat alldeles rätt eller total fel, who knows? Och att DU kan vara övertygad om att det är rätt ger inte MIG anledning att tro det samma.

[rysshack.se]

Jepp, har testat ut vad den läser, om jag skriver så här, så får jag ut värdena på de olika tangenterna på dioderna på stk:n
Baserat på det har jag definerat one till #define one 0b10001000 osv.
Jag har tagit hänsyn till att det är den släckta dioden som är 1 på stk plattformen.

Vid test fungerar det sedan att trycka ned knapparna och få den att skriva ut det jag vill på dioderna, med hjälp av if satsen tidigare,
Dock endast då jag anväder max två knappar.

Kod: Markera allt

#define F_CPU 8000000UL
#include <avr/io.h>
#include <stdio.h>
#include <util/delay.h>

char Test();

int main (void)
{
   DDRC=0xff;
   while(1)
   {
      PORTC=Test();
   }

   return(0);

}

char Test()
{    
   char KeyBoardValue,CharValue;
   /*Läser av fyra ben*/
   DDRB=0x0f;
   PORTB=0xf0;
   KeyBoardValue=PINB;
   /*-----------------*/
   
   //_delay_ms (80);
   /*Läser av de andra fyra benen och lägger ihop värdet med hjälp av maskning*/
   DDRB=0xf0;
   PORTB=0x0f;
   KeyBoardValue=(KeyBoardValue&0xf0)|(PINB&0x0f); //Maskar ut värdet
   /*-------------------------------------------------------------------------*/
   return KeyBoardValue;
}

Använder Linjeomvändningsmetoden som är beskriven här under.

Linjeomvändningsmetoden
Till denna metod behöver kopplingen utökas med pullup-motstånd även till de ledningarna som tan¬gent¬bordets rader är anslutna med (om inte kretsen man ansluter tangentbordet till har inbyggt pull¬up).
Denna metod karakteriseras av att omväxlande lägga ut nollor på alla rader och läsa kolumnerna, och lägga ut nollor på alla kolumner och läsa raderna. Unik knappkod för eventuellt nertryckt knapp ges av att kombinera resultaten av de två läsningarna. Metodens steg blir:
a. Som med radavkänningsmetoden börjar man med att initiera de portar som raderna är an¬slutna till som utgångar och de portar som kolumnerna är anslutna till som ingångar.
b. Man skriver 0000 till raderna ocn läser av kolumnerna. En nertryckt knapp kommer att fort¬planta en nolla från sin rad till sin kolumn. Är kolumnkoden 1111, visar det att ingen knapp är nertryckt. Man kan då gå direkt tillbaka till steg a. igen. Men får man träff på en nolla, går man vidare.
c. Riktningen på portarna kastas om: portar till raderna initieras som ingångar och portar till kolumnerna initieras som utgångar.
d. Man skriver 0000 till kolumnerna och läser av raderna. Nu kommer den nertryckta knap¬pen att avslöja sig genom att fortplanta en nolla från sin kolumn till sin rad.
e. Kombinerar man informationen från avlästa kolumner (tex 1011) och avlästa rader (tex 0111) får man knappkoden för en nertryckt knapp (1011 0111).
Sen börjar man om.
För denna metod gäller att vilken avläsning som helst där man får 1111 visar att ingen knapp är ner¬tryckt.)

Förstår inte varför du låter nedlåtande Icecap, vad är nyttan med det?

[eqlazer]

Vad använder du för kompilator? Har du kollat lst-filen så att det inte är nått skumt i den genererade koden?

Och hur vet du att den hänger sig? Kan du ta reda på var?

[exile]

Tycker att din jämförelse "tal" ser lite skumma ut.
exempel:

Kod: Markera allt

#define zero 0b10111110
#define one  0b10001000 <-borde den inte se ut 0b01110111

[rysshack.se]

Har winavr, avr-gcc.

Det hänger sig på så sätt att den konstant skriver ut den felkod som den skall skriva ut om jag ej trycker ned någon tangent.
Det har blivit konstiga fel, någon gång tidigare, då man valt för hård optimeringsgrad i makefilen.

Var ligger lst-filen, hittar en lss fil i katalogen som är målkatalog för projektet.

Skarpögt exile, zero är fel där, har maskat ut det så att det skall se ut så här

Kod: Markera allt

#define one        0b10001000
#define two        0b01001000
#define three      0b00101000
#define letterA    0b00011000
#define four        0b10000100
#define five        0b01000100
#define six          0b00100100
#define letterB    0b00001100
#define seven     0b10000010
#define eight      0b01000010
#define nine       0b00100010
#define letterC    0b00010010
#define star        0b10000001
#define zero	0b01000001
#define square 	0b00100001
#define letterD 0b00010001

Även 7, 8 och 9 var fel(fixat), men problemet kvarstår tyvärr.

[exile]

Jag Tror att det är lss filen han syftar på...

Jag tog mig friheten att kompilera din code och jag kan inte se några knepigheter i assembler koden som gcc genererar...

Kod: Markera allt

key_test.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         00000148  00000000  00000000  00000054  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .stab         00000378  00000000  00000000  0000019c  2**2
                  CONTENTS, READONLY, DEBUGGING
  2 .stabstr      00000071  00000000  00000000  00000514  2**0
                  CONTENTS, READONLY, DEBUGGING
  3 .debug_aranges 00000020  00000000  00000000  00000585  2**0
                  CONTENTS, READONLY, DEBUGGING
  4 .debug_pubnames 00000024  00000000  00000000  000005a5  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_info   000000b3  00000000  00000000  000005c9  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_abbrev 00000074  00000000  00000000  0000067c  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_line   000001bf  00000000  00000000  000006f0  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_frame  00000030  00000000  00000000  000008b0  2**2
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_str    00000099  00000000  00000000  000008e0  2**0
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_loc    000000a2  00000000  00000000  00000979  2**0
                  CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:

00000000 <__vectors>:
   0:	0c 94 38 00 	jmp	0x70	; 0x70 <__ctors_end>
   4:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
   8:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
   c:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  10:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  14:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  18:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  1c:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  20:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  24:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  28:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  2c:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  30:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  34:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  38:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  3c:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  40:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  44:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  48:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  4c:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  50:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  54:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  58:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  5c:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  60:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  64:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  68:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>
  6c:	0c 94 55 00 	jmp	0xaa	; 0xaa <__bad_interrupt>

00000070 <__ctors_end>:
  70:	11 24       	eor	r1, r1
  72:	1f be       	out	0x3f, r1	; 63
  74:	cf ef       	ldi	r28, 0xFF	; 255
  76:	d4 e0       	ldi	r29, 0x04	; 4
  78:	de bf       	out	0x3e, r29	; 62
  7a:	cd bf       	out	0x3d, r28	; 61

0000007c <__do_copy_data>:
  7c:	11 e0       	ldi	r17, 0x01	; 1
  7e:	a0 e0       	ldi	r26, 0x00	; 0
  80:	b1 e0       	ldi	r27, 0x01	; 1
  82:	e8 e4       	ldi	r30, 0x48	; 72
  84:	f1 e0       	ldi	r31, 0x01	; 1
  86:	02 c0       	rjmp	.+4      	; 0x8c <.do_copy_data_start>

00000088 <.do_copy_data_loop>:
  88:	05 90       	lpm	r0, Z+
  8a:	0d 92       	st	X+, r0

0000008c <.do_copy_data_start>:
  8c:	a0 30       	cpi	r26, 0x00	; 0
  8e:	b1 07       	cpc	r27, r17
  90:	d9 f7       	brne	.-10     	; 0x88 <.do_copy_data_loop>

00000092 <__do_clear_bss>:
  92:	11 e0       	ldi	r17, 0x01	; 1
  94:	a0 e0       	ldi	r26, 0x00	; 0
  96:	b1 e0       	ldi	r27, 0x01	; 1
  98:	01 c0       	rjmp	.+2      	; 0x9c <.do_clear_bss_start>

0000009a <.do_clear_bss_loop>:
  9a:	1d 92       	st	X+, r1

0000009c <.do_clear_bss_start>:
  9c:	a0 30       	cpi	r26, 0x00	; 0
  9e:	b1 07       	cpc	r27, r17
  a0:	e1 f7       	brne	.-8      	; 0x9a <.do_clear_bss_loop>
  a2:	0e 94 9d 00 	call	0x13a	; 0x13a <main>
  a6:	0c 94 a3 00 	jmp	0x146	; 0x146 <_exit>

000000aa <__bad_interrupt>:
  aa:	0c 94 00 00 	jmp	0	; 0x0 <__vectors>

000000ae <Test>:

}

char Test()
{    
  ae:	9f e0       	ldi	r25, 0x0F	; 15
  b0:	97 bb       	out	0x17, r25	; 23
   char KeyBoardValue,CharValue;
   /*Läser av fyra ben*/
   DDRB=0x0f;
   PORTB=0xf0;
  b2:	80 ef       	ldi	r24, 0xF0	; 240
  b4:	88 bb       	out	0x18, r24	; 24
   KeyBoardValue=PINB;
  b6:	26 b3       	in	r18, 0x16	; 22
   /*-----------------*/
   
   //_delay_ms (80);
   /*Läser av de andra fyra benen och lägger ihop värdet med hjälp av maskning*/
   DDRB=0xf0;
  b8:	87 bb       	out	0x17, r24	; 23
   PORTB=0x0f;
  ba:	98 bb       	out	0x18, r25	; 24
   KeyBoardValue=(KeyBoardValue&0xf0)|(PINB&0x0f); //Maskar ut värdet
  bc:	86 b3       	in	r24, 0x16	; 22
  be:	20 7f       	andi	r18, 0xF0	; 240
  c0:	8f 70       	andi	r24, 0x0F	; 15
  c2:	28 2b       	or	r18, r24
   /*-------------------------------------------------------------------------*/

   if      (KeyBoardValue==one)   {CharValue='1';}
  c4:	28 38       	cpi	r18, 0x88	; 136
  c6:	b1 f1       	breq	.+108    	; 0x134 <Test+0x86>
   else if (KeyBoardValue==two)   {CharValue='2';}
  c8:	28 34       	cpi	r18, 0x48	; 72
  ca:	11 f4       	brne	.+4      	; 0xd0 <Test+0x22>
  cc:	82 e3       	ldi	r24, 0x32	; 50
  ce:	33 c0       	rjmp	.+102    	; 0x136 <Test+0x88>
   else if (KeyBoardValue==three)   {CharValue='3';}
  d0:	28 32       	cpi	r18, 0x28	; 40
  d2:	11 f4       	brne	.+4      	; 0xd8 <Test+0x2a>
  d4:	83 e3       	ldi	r24, 0x33	; 51
  d6:	2f c0       	rjmp	.+94     	; 0x136 <Test+0x88>
   else if (KeyBoardValue==four)   {CharValue='4';}
  d8:	24 38       	cpi	r18, 0x84	; 132
  da:	11 f4       	brne	.+4      	; 0xe0 <Test+0x32>
  dc:	84 e3       	ldi	r24, 0x34	; 52
  de:	2b c0       	rjmp	.+86     	; 0x136 <Test+0x88>
   else if (KeyBoardValue==five)   {CharValue='5';}
  e0:	24 34       	cpi	r18, 0x44	; 68
  e2:	11 f4       	brne	.+4      	; 0xe8 <Test+0x3a>
  e4:	85 e3       	ldi	r24, 0x35	; 53
  e6:	27 c0       	rjmp	.+78     	; 0x136 <Test+0x88>
   else if (KeyBoardValue==six)   {CharValue='6';}
  e8:	24 32       	cpi	r18, 0x24	; 36
  ea:	11 f4       	brne	.+4      	; 0xf0 <Test+0x42>
  ec:	86 e3       	ldi	r24, 0x36	; 54
  ee:	23 c0       	rjmp	.+70     	; 0x136 <Test+0x88>
   else if (KeyBoardValue==seven)   {CharValue='7';}
  f0:	22 38       	cpi	r18, 0x82	; 130
  f2:	11 f4       	brne	.+4      	; 0xf8 <Test+0x4a>
  f4:	87 e3       	ldi	r24, 0x37	; 55
  f6:	1f c0       	rjmp	.+62     	; 0x136 <Test+0x88>
   else if (KeyBoardValue==eight)   {CharValue='8';}
  f8:	22 34       	cpi	r18, 0x42	; 66
  fa:	11 f4       	brne	.+4      	; 0x100 <Test+0x52>
  fc:	88 e3       	ldi	r24, 0x38	; 56
  fe:	1b c0       	rjmp	.+54     	; 0x136 <Test+0x88>
   else if (KeyBoardValue==nine)   {CharValue='9';}
 100:	22 32       	cpi	r18, 0x22	; 34
 102:	11 f4       	brne	.+4      	; 0x108 <Test+0x5a>
 104:	89 e3       	ldi	r24, 0x39	; 57
 106:	17 c0       	rjmp	.+46     	; 0x136 <Test+0x88>
   else if (KeyBoardValue==letterA){CharValue='A';}
 108:	28 31       	cpi	r18, 0x18	; 24
 10a:	11 f4       	brne	.+4      	; 0x110 <Test+0x62>
 10c:	81 e4       	ldi	r24, 0x41	; 65
 10e:	13 c0       	rjmp	.+38     	; 0x136 <Test+0x88>
   else if (KeyBoardValue==letterB){CharValue='B';}
 110:	2c 30       	cpi	r18, 0x0C	; 12
 112:	11 f4       	brne	.+4      	; 0x118 <Test+0x6a>
 114:	82 e4       	ldi	r24, 0x42	; 66
 116:	0f c0       	rjmp	.+30     	; 0x136 <Test+0x88>
   else if (KeyBoardValue==letterC){CharValue='C';}
 118:	22 31       	cpi	r18, 0x12	; 18
 11a:	11 f4       	brne	.+4      	; 0x120 <Test+0x72>
 11c:	83 e4       	ldi	r24, 0x43	; 67
 11e:	0b c0       	rjmp	.+22     	; 0x136 <Test+0x88>
   else if (KeyBoardValue==letterD){CharValue='D';}   
 120:	21 31       	cpi	r18, 0x11	; 17
 122:	11 f4       	brne	.+4      	; 0x128 <Test+0x7a>
 124:	84 e4       	ldi	r24, 0x44	; 68
 126:	07 c0       	rjmp	.+14     	; 0x136 <Test+0x88>
   else if (KeyBoardValue==star)   {CharValue=0x31;}
 128:	21 38       	cpi	r18, 0x81	; 129
 12a:	21 f0       	breq	.+8      	; 0x134 <Test+0x86>
   else if (KeyBoardValue==square)   {CharValue=0x31;}
 12c:	21 32       	cpi	r18, 0x21	; 33
 12e:	11 f0       	breq	.+4      	; 0x134 <Test+0x86>
 130:	85 e4       	ldi	r24, 0x45	; 69
 132:	01 c0       	rjmp	.+2      	; 0x136 <Test+0x88>
 134:	81 e3       	ldi	r24, 0x31	; 49
   else {CharValue='E';}
   return CharValue;
}
 136:	99 27       	eor	r25, r25
 138:	08 95       	ret

0000013a <main>:
 13a:	8f ef       	ldi	r24, 0xFF	; 255
 13c:	84 bb       	out	0x14, r24	; 20
 13e:	0e 94 57 00 	call	0xae	; 0xae <Test>
 142:	85 bb       	out	0x15, r24	; 21
 144:	fc cf       	rjmp	.-8      	; 0x13e <main+0x4>

00000146 <_exit>:
 146:	ff cf       	rjmp	.-2      	; 0x146 <_exit>

Men bör inte konstanten vara inverterad eller tänker jag fel nu
Om du har pull-up och du läser av en rad som är nedtryckt borde det inte bli typ 0b1110 0000, 0b1101 0000, 0b1011 0000 och 0b0111 0000.
Och samma med kolumnen, fast de fyra bitarna har bytt plats...

Jag kan tyvärr inte komma på något mer för tillfället......

[eqlazer]

Japp lss är det visst den heter, har suttit med ett PPC-projekt de senaste månaderna och där heter filen .lst så jag har blivit lite skadad

[anrhm]

Borde det inte se ut så här:

Kod: Markera allt

#define one        0b11101110
#define two        0b11101101

Osv. om det är kopplat enligt din bild.
Minst signifikanta biten till höger och en nolla indikerar nedtryck tangent...

[Icecap]

Jag är inte nedlåtande, jag ser bara det typiska felet här med.

OK, det kan sannolikt fungera att dekoda på det sätt men om du trycker in 2 (eller fler) knappar samtidig kopplas dels 2 utgångar ihop (med rätt kombination) vilket jag ser som ett fel och dels ser jag inte någon väntperiod mellan växlingen av porten och avläsningen, detta behövs för att kapacitanser ska "hinna med". Det behöver inte vara mer än några NOP eller liknande men lite tid ska det åt.

Och sedan är det standard att man först skriver ut de värden som rent faktisk avläsas, dels med alla knappar inaktiva och dels med en knapp åt gången. Resultatet skriver man ner och kollar om samma kod finns på olika knappar osv. Om man inte ser något stabilt mönster kan man sedan börja fråga här.

Detta tycker jag iaf borde vara arbetsgången.

Och att du sedan har bytt ut till switch har faktisk ingen betydelse, resultatet blir faktisk oerhört lika. När switch-värden är en sekvens (typ 1-2-3-4-5-6-7...) kan den indexera i en tabell och då kan det gå snabbt men är det "slumpmässiga" värden "omvandlas" det i realiteten till just if()´...; else if()...; else...

Men jag tycker dock att switch kan vara snyggare att läsa i programmet.

[rysshack.se]

Tack för alla råd!
Icacap, med två korta delayer, så lästes portarna av korrekt. Då med omvänd ordning på definitionerna som anrhm skarpögt uppmärksammat.

Det som förbryllar var att det inverterade definerade värdena faktiskt fungerade att läsa av i två fall när man körde utan delayerna, samt att om
man tog de inscannade värdena direkt, och la ut dem till lysdioderna på en av portarna (utan delayerna) så visade de inversen av de korrekta värdena.