Svenska ElektronikForumet

Jajamänsan det blev bingo. de funka.

Mkt bättre med ASM...

då vet man vad som händer,
och man slipper läsa manualen för C-kompilatorn!

Hej.

En fråga, programmet nedan funkar inte riktigt. Den hoppar över den första if satsen så att säga, dvs den känner inte alls av om det är en 1 eller 0 på GP1. Är det ngn alternativ funktion på GP1 jag inte tänkt på att stänga av eller?



void main(){


CMCON = 0x0; //stäng av komparator
TRISIO.F0 = 0; //GP0 är utgång
GPIO.F0 = 0;
TRISIO.F1 = 1; //GP1 är ingång
GPIO.F1 = 1;
TRISIO.F2 = 1; //GP2 är ingång
GPIO.F2 = 1;



while(1){


if (GPIO.F1 == 1){

GPIO.F0 = 0;
delay_ms(500);
GPIO.F0 = 1;
delay_ms(500);
}

else if (GPIO.F2 == 1){

GPIO.F0 = 0;
delay_ms(200);
GPIO.F0 = 1;
delay_ms(200);
}

else {

GPIO.F0 = 0;
delay_ms(1000);
GPIO.F0 = 1;
delay_ms(1000);
}
}

}

Processor ????

> TRISIO.F1 = 1; //GP1 är ingång
> GPIO.F1 = 1;

Varför sätta en pinne som i alla fall är en ingång !!??

Vad är kopplat till pinnarna ??

(Varför tror du att vi ska kunna gissa hälften ??)

12F629

till gp1 o 2 har ska jag koppla brytare som sluter till 5V, utgången ska helt enkelt skicka ut ett puls tåg med olika frekvenser beroende om det är gp1 eller gp2 som är 5V..

Nää det e klart ni inte skall gissa, postade det i all hast innan jag skulle träna, var inte helt genomtänkt

if (GPIO.F1 == 1) är alltid falsk!
Man skrivar antingen:
if(GPIO.F1)
eller
if(GPIO.F1 > 0)
Om du kollar ASM-koden blir det till att GPIO.F1 växlar mellan 0x00 eller 0x02, den KAN alltså aldrig bli 0x01.

> till gp1 o 2 har ska jag koppla brytare som sluter till 5V,

Med pulldown motstånd ?
Det är lite vanligare att man gör tvärtom, pullup motstånd (eventuelt
de inbyggda) och en switch till jord.

> Nää det e klart ni inte skall gissa,...

Eftersom du i tidigare kod (i samma tråd) hade använd en 628A (och PORTx)
så blev det rejält förvirrat när du nu använder GPIO !! Antingen hade du bytt
PIC eller så hade du rört till det ordentligt för dig...

Icecap> Om du kollar ASM-koden blir det till att GPIO.F1 växlar mellan 0x00 eller 0x02

Har har ingen aning om det där stämmer eller inte, men *om* det stämmer
så är det riktigt korkat ! ".F1" är väl så vitt jag förstår till för att "peka ut"
en enskild bit i ett register. Det naturliga vore att den kan vara "0" eller "1".
Vilka värden kan "GPIO.F2" (o.s.v) ha ???

det är 629 jag har, råkade nog skriva fel innan. jag har pulldown ja.

>if(GPIO.F1)

Okey men varför kan man inte skriva som jag har gjort, det verkar ju funka för de övriga satserna dvs att peka ut en bit o kolla om den är etta eller nolla? usccchhh.. nä nu räcker det för ikväll...måste kolla på ugly betty

När man pekar ut en enstaka bit i C ska man kolla om resultatet är '0' eller 'annat'! Ofta sker en sån bitcheck med AND och då allt annat än 0x00 är 'sant' i C räcker detta.

I MikroC läggs det en BTFSx om man skrivar 'if(GPIO.F1)' men skrivar man 'if(GPIO.F1 == 1)' läsas GPIO, lämplig bitmönster AND'as ut och en jämförelse med 1 göras vilket alltså aldrig blir sant.

Javisst, det är spetsfundigheter, krångligt och ologisk men det är samtidig ganska dumt, rent programmeringsmässigt, att kolla om en bit har ett visst värde! Man vill veta om den är sann eller falsk, inget annat.

Och jag håller med om att såna problem undviker man i assembler och hade programmörn här kollat den resulterande kod som kompilern ger hade det snabbt blivit uppenbart vari felet bestod.

Det är i stil med att vissa kollar i loopar att ett visst värde är uppnådd (for...to...next typ). MÅNGA kollar om räknaren når ett exakt värde (med ==), jag kollar ALLTID om värdet ELLER ETT HÖGRE är nådd (med >=). Detta har jag räddad mig med många gånger, speciellt när interrupt har varit inblandat.

För att svara på din fråga:
Om man kollar 'if(GPIO.F2 == 1)' kommer 'GPIO.F2' att växla mellan 0x00 och 0x04. Sett från ett C-synspunkt är detta helt OK, resultatet är antingen 'sant' (!= 0x00) eller falskt (== 0x00).

I C...

Jag provade båda varianterna dvs if (GPIO.F1>0), if (GPIO.F1)men det går ändå inte. Och jag kan inte asm....

Det vore intressant att se ASM filen från kompilatorn...

; ASM code generated by mikroVirtualMachine for PIC - V. 6.2.0.0
; Date/Time: 2006-11-24 14:28:05
; Info: http://www.mikroelektronika.co.yu


; ADDRESS OPCODE ASM
; ----------------------------------------------
$0000 $2804 GOTO _main
$0004 $ _main:
;Servostyr.c,5 :: void main(){
;Servostyr.c,8 :: CMCON = 0x0; //stäng av komparator
$0004 $1303 BCF STATUS, RP1
$0005 $1283 BCF STATUS, RP0
$0006 $0199 CLRF CMCON, 1
;Servostyr.c,9 :: TRISIO.F0 = 0; //GP0 är utgång
$0007 $1683 BSF STATUS, RP0
$0008 $1005 BCF TRISIO, 0
;Servostyr.c,10 :: GPIO.F0 = 0;
$0009 $1283 BCF STATUS, RP0
$000A $1005 BCF GPIO, 0
;Servostyr.c,11 :: TRISIO.F1 = 1; //GP1 är ingång
$000B $1683 BSF STATUS, RP0
$000C $1485 BSF TRISIO, 1
;Servostyr.c,12 :: GPIO.F1 = 1;
$000D $1283 BCF STATUS, RP0
$000E $1485 BSF GPIO, 1
;Servostyr.c,13 :: TRISIO.F2 = 1; //GP2 är ingång
$000F $1683 BSF STATUS, RP0
$0010 $1505 BSF TRISIO, 2
;Servostyr.c,14 :: GPIO.F2 = 1;
$0011 $1283 BCF STATUS, RP0
$0012 $1505 BSF GPIO, 2
;Servostyr.c,18 :: while(1){
$0013 $ L_main_0:
;Servostyr.c,21 :: if (GPIO.F1){
$0013 $1C85 BTFSS GPIO, 1
$0014 $2856 GOTO L_main_2
;Servostyr.c,23 :: GPIO.F0 = 0;
$0015 $1005 BCF GPIO, 0
;Servostyr.c,24 :: delay_ms(500);
$0016 $3003 MOVLW 3
$0017 $00DC MOVWF STACK_12
$0018 $30FF MOVLW 255
$0019 $00DB MOVWF STACK_11
$001A $30FF MOVLW 255
$001B $00DA MOVWF STACK_10
$001C $0BDC DECFSZ STACK_12, F
$001D $281F GOTO $+2
$001E $2826 GOTO $+8
$001F $0BDB DECFSZ STACK_11, F
$0020 $2822 GOTO $+2
$0021 $2825 GOTO $+4
$0022 $0BDA DECFSZ STACK_10, F
$0023 $2822 GOTO $-1
$0024 $281F GOTO $-5
$0025 $281C GOTO $-9
$0026 $308C MOVLW 140
$0027 $00DB MOVWF STACK_11
$0028 $30FF MOVLW 255
$0029 $00DA MOVWF STACK_10
$002A $0BDB DECFSZ STACK_11, F
$002B $282D GOTO $+2
$002C $2830 GOTO $+4
$002D $0BDA DECFSZ STACK_10, F
$002E $282D GOTO $-1
$002F $282A GOTO $-5
$0030 $30A1 MOVLW 161
$0031 $00DA MOVWF STACK_10
$0032 $0BDA DECFSZ STACK_10, F
$0033 $2832 GOTO $-1
$0034 $0000 NOP
;Servostyr.c,25 :: GPIO.F0 = 1;
$0035 $1405 BSF GPIO, 0
;Servostyr.c,26 :: delay_ms(500);
$0036 $3003 MOVLW 3
$0037 $00DC MOVWF STACK_12
$0038 $30FF MOVLW 255
$0039 $00DB MOVWF STACK_11
$003A $30FF MOVLW 255
$003B $00DA MOVWF STACK_10
$003C $0BDC DECFSZ STACK_12, F
$003D $283F GOTO $+2
$003E $2846 GOTO $+8
$003F $0BDB DECFSZ STACK_11, F
$0040 $2842 GOTO $+2
$0041 $2845 GOTO $+4
$0042 $0BDA DECFSZ STACK_10, F
$0043 $2842 GOTO $-1
$0044 $283F GOTO $-5
$0045 $283C GOTO $-9
$0046 $308C MOVLW 140
$0047 $00DB MOVWF STACK_11
$0048 $30FF MOVLW 255
$0049 $00DA MOVWF STACK_10
$004A $0BDB DECFSZ STACK_11, F
$004B $284D GOTO $+2
$004C $2850 GOTO $+4
$004D $0BDA DECFSZ STACK_10, F
$004E $284D GOTO $-1
$004F $284A GOTO $-5
$0050 $30A1 MOVLW 161
$0051 $00DA MOVWF STACK_10
$0052 $0BDA DECFSZ STACK_10, F
$0053 $2852 GOTO $-1
$0054 $0000 NOP
;Servostyr.c,27 :: }
$0055 $28DB GOTO L_main_3
$0056 $ L_main_2:
;Servostyr.c,29 :: else if (GPIO.F2 == 1){
$0056 $3000 MOVLW 0
$0057 $1905 BTFSC GPIO, 2
$0058 $3001 MOVLW 1
$0059 $00D1 MOVWF STACK_1
$005A $0851 MOVF STACK_1, 0
$005B $3A01 XORLW 1
$005C $1D03 BTFSS STATUS, Z
$005D $289D GOTO L_main_4
;Servostyr.c,31 :: GPIO.F0 = 0;
$005E $1005 BCF GPIO, 0
;Servostyr.c,32 :: delay_ms(200);
$005F $3002 MOVLW 2
$0060 $00DC MOVWF STACK_12
$0061 $30FF MOVLW 255
$0062 $00DB MOVWF STACK_11
$0063 $30FF MOVLW 255
$0064 $00DA MOVWF STACK_10
$0065 $0BDC DECFSZ STACK_12, F
$0066 $2868 GOTO $+2
$0067 $286F GOTO $+8
$0068 $0BDB DECFSZ STACK_11, F
$0069 $286B GOTO $+2
$006A $286E GOTO $+4
$006B $0BDA DECFSZ STACK_10, F
$006C $286B GOTO $-1
$006D $2868 GOTO $-5
$006E $2865 GOTO $-9
$006F $3006 MOVLW 6
$0070 $00DB MOVWF STACK_11
$0071 $30FF MOVLW 255
$0072 $00DA MOVWF STACK_10
$0073 $0BDB DECFSZ STACK_11, F
$0074 $2876 GOTO $+2
$0075 $2879 GOTO $+4
$0076 $0BDA DECFSZ STACK_10, F
$0077 $2876 GOTO $-1
$0078 $2873 GOTO $-5
$0079 $300A MOVLW 10
$007A $00DA MOVWF STACK_10
$007B $0BDA DECFSZ STACK_10, F
$007C $287B GOTO $-1
;Servostyr.c,33 :: GPIO.F0 = 1;
$007D $1405 BSF GPIO, 0
;Servostyr.c,34 :: delay_ms(200);
$007E $3002 MOVLW 2
$007F $00DC MOVWF STACK_12
$0080 $30FF MOVLW 255
$0081 $00DB MOVWF STACK_11
$0082 $30FF MOVLW 255
$0083 $00DA MOVWF STACK_10
$0084 $0BDC DECFSZ STACK_12, F
$0085 $2887 GOTO $+2
$0086 $288E GOTO $+8
$0087 $0BDB DECFSZ STACK_11, F
$0088 $288A GOTO $+2
$0089 $288D GOTO $+4
$008A $0BDA DECFSZ STACK_10, F
$008B $288A GOTO $-1
$008C $2887 GOTO $-5
$008D $2884 GOTO $-9
$008E $3006 MOVLW 6
$008F $00DB MOVWF STACK_11
$0090 $30FF MOVLW 255
$0091 $00DA MOVWF STACK_10
$0092 $0BDB DECFSZ STACK_11, F
$0093 $2895 GOTO $+2
$0094 $2898 GOTO $+4
$0095 $0BDA DECFSZ STACK_10, F
$0096 $2895 GOTO $-1
$0097 $2892 GOTO $-5
$0098 $300A MOVLW 10
$0099 $00DA MOVWF STACK_10
$009A $0BDA DECFSZ STACK_10, F
$009B $289A GOTO $-1
;Servostyr.c,35 :: }
$009C $28DB GOTO L_main_5
$009D $ L_main_4:
;Servostyr.c,39 :: GPIO.F0 = 0;
$009D $1005 BCF GPIO, 0
;Servostyr.c,40 :: delay_ms(1000);
$009E $3006 MOVLW 6
$009F $00DC MOVWF STACK_12
$00A0 $30FF MOVLW 255
$00A1 $00DB MOVWF STACK_11
$00A2 $30FF MOVLW 255
$00A3 $00DA MOVWF STACK_10
$00A4 $0BDC DECFSZ STACK_12, F
$00A5 $28A7 GOTO $+2
$00A6 $28AE GOTO $+8
$00A7 $0BDB DECFSZ STACK_11, F
$00A8 $28AA GOTO $+2
$00A9 $28AD GOTO $+4
$00AA $0BDA DECFSZ STACK_10, F
$00AB $28AA GOTO $-1
$00AC $28A7 GOTO $-5
$00AD $28A4 GOTO $-9
$00AE $301A MOVLW 26
$00AF $00DB MOVWF STACK_11
$00B0 $30FF MOVLW 255
$00B1 $00DA MOVWF STACK_10
$00B2 $0BDB DECFSZ STACK_11, F
$00B3 $28B5 GOTO $+2
$00B4 $28B8 GOTO $+4
$00B5 $0BDA DECFSZ STACK_10, F
$00B6 $28B5 GOTO $-1
$00B7 $28B2 GOTO $-5
$00B8 $3042 MOVLW 66
$00B9 $00DA MOVWF STACK_10
$00BA $0BDA DECFSZ STACK_10, F
$00BB $28BA GOTO $-1
;Servostyr.c,41 :: GPIO.F0 = 1;
$00BC $1405 BSF GPIO, 0
;Servostyr.c,42 :: delay_ms(1000);
$00BD $3006 MOVLW 6
$00BE $00DC MOVWF STACK_12
$00BF $30FF MOVLW 255
$00C0 $00DB MOVWF STACK_11
$00C1 $30FF MOVLW 255
$00C2 $00DA MOVWF STACK_10
$00C3 $0BDC DECFSZ STACK_12, F
$00C4 $28C6 GOTO $+2
$00C5 $28CD GOTO $+8
$00C6 $0BDB DECFSZ STACK_11, F
$00C7 $28C9 GOTO $+2
$00C8 $28CC GOTO $+4
$00C9 $0BDA DECFSZ STACK_10, F
$00CA $28C9 GOTO $-1
$00CB $28C6 GOTO $-5
$00CC $28C3 GOTO $-9
$00CD $301A MOVLW 26
$00CE $00DB MOVWF STACK_11
$00CF $30FF MOVLW 255
$00D0 $00DA MOVWF STACK_10
$00D1 $0BDB DECFSZ STACK_11, F
$00D2 $28D4 GOTO $+2
$00D3 $28D7 GOTO $+4
$00D4 $0BDA DECFSZ STACK_10, F
$00D5 $28D4 GOTO $-1
$00D6 $28D1 GOTO $-5
$00D7 $3042 MOVLW 66
$00D8 $00DA MOVWF STACK_10
$00D9 $0BDA DECFSZ STACK_10, F
$00DA $28D9 GOTO $-1
;Servostyr.c,43 :: }
$00DB $ L_main_5:
$00DB $ L_main_3:
;Servostyr.c,44 :: }
$00DB $2813 GOTO L_main_0
;Servostyr.c,46 :: }
$00DC $28DC GOTO $

OK.

> ;Servostyr.c,21 :: if (GPIO.F1){
> $0013 $1C85 BTFSS GPIO, 1
> $0014 $2856 GOTO L_main_2

Ser väl OK ut. Återstår att ta reda på varför GPIO, 1 inte är "1" (om det är det problemet du har).

> ;Servostyr.c,29 :: else if (GPIO.F2 == 1){
> $0056 $3000 MOVLW 0
> $0057 $1905 BTFSC GPIO, 2
> $0058 $3001 MOVLW 1
> $0059 $00D1 MOVWF STACK_1
> $005A $0851 MOVF STACK_1, 0
> $005B $3A01 XORLW 1
> $005C $1D03 BTFSS STATUS, Z
> $005D $289D GOTO L_main_4

Även dett ser OK ut, även om det istället för en logisk bit-test blir en test
mot det numeriska värdet 1 istället. Skulle bli lite mindra kod med
"if (GPIO.F2)" även här.

Notera också hur ineffektivt delay_ms() med inline-kod istället för ett CALL...

Så summan blir att *koden* ser OK ut...

Det är väl dags att klippa lite kod bort och göra följande: Detta vill få GPIO.F0 at följa GPIO.F1.