# Secuencia Fibonacci con formula en lenguaje ensamblador



## packs (Sep 21, 2013)

*Saludos colegas,
me encargaron un pequeño proyecto de secuencia de luces en mplab que simule el siguiente patrón:*

10000000
11000000
11100000
11110000
11111000
11111100
11111110
11111111
01111111
00111111
00011111
00001111
00000111
00000011
00000001
00000011
00000111
00001111
00011111
00111111
01111111
11111111

*pero no poniendo cada valor a mano en el mplab, sino por formula, hasta el momento tengo esto:*

```
LisT P=18F452
			
			include "P18F452.inc"
			
			
					
					MULTIPLO	EQU	0X20
					PAST		EQU	0X21
					
					ORG		0X0000
					CLRF		TRISB					;SALIDA
					CLRF		PORTB
					
					MOVLW		d\'1\'						;CARGAR EN W UN "1"
					MOVWF		MULTIPLO				;MOVER UNA COPIA DEL REGISTRO W A LA VARIABLE "MULTIPLO"
					MOVWF		PORTB					;MOVER UNA COPIA DEL REGISTRO  W AL PUERTO B
					MOVLW		d\'2\'						;CARGAR EN EL REGISTRO W UN "2"

					MULWF		MULTIPLO,1			;MULTIPLICAR LA VARIABLE "MULTIPLO" CON EL REGISTRO W
					MOVF		PRODL,0				;-----MOVER EL RESULTADO DEL REGISTRO PRODL AL REGISTRO W
					MOVWF		MULTIPLO				;GUARDAR EL RESULTADO EN LA VARIABLE "MULTIPLO"
					MOVF		PORTB,0				;-----LEER EL PUERTO B Y COPIARLO EN EL REGISTRO W
					MOVWF		PAST					;-----COPIAR EL CONTENIDO DEL REGISTRO W EN LA VARIABLE "PAST"					
														;SUMAR LA VARIABLE "MULTIPLO" CON LA VARIABLE "PAST"					
														;EL RESULTADO ESCRIBIRLO EN EL PUERTO B
					
					RETURN
					
					END
```

*tengo la idea de que es parecido a la secuencia Fibonacci, me falta sumar dos variables/registros pero aun no puedo, lo demás ya lo tengo, si tienen alguna idea se los agradecería, 

saludos.* ...


----------



## palurdo (Sep 21, 2013)

Pues a mí me parece más bien un contador johnson







 lo cual es tan simple de hacer que casi me da vergüenza explicarlo...

Inicias la variable que vayas a usar a 0, si quieres puedes usar el puerto de salida que quieras como contador, como por ejemplo RB.

Haces un bucle que tenga estas instrucciones:


```
BUCLE
     MOVLW 0x01
     XORWF STATUS,f    ;Se invierte el bit de Carry.
     RRF PORTB,f             ;Se Rota el puerto B a la derecha a través del Carry. 
     CALL Retardo            ;Rutina para esperar un tiempo.
     GOTO BUCLE  ;Salta al siguiente ciclo del contador.
```


----------



## morta (Sep 22, 2013)

fibonacci seria:
00001
00010
00011
00101
01000
01101
y asi......


----------



## Scooter (Sep 22, 2013)

Creo que lo mejor sería una tabla de datos


----------



## palurdo (Sep 22, 2013)

Bueno, si de verdad se fuera a generar la secuencia de fibonacci en el puerto B para ir encendiendo Leds, pues sería usar este programa (para 16F628 pero facilmente modificable para el 18F452):

Fórmula generadora X[0]=0,X[1]=1,X[2]=0;

X[0]=(X[1]+X[2])%256;
X[1]=X[2];
X[1]=X[0];



```
__CONFIG _WDT_OFF&_PWRTE_ON&_XT_OSC&_LVP_OFF&_CP_OFF 

	LIST p=16F628A
	INCLUDE <P16F628A.INC>

RET0	EQU 0x21
RET1	EQU 0x22

	ORG 0x00 
	BSF STATUS,RP0
	CLRF TRISB
	BCF STATUS,RP0
	CLRF PORTB
	MOVLW 0x01

BUCLE
	CALL FIBONACCI
	CALL RETARDO
	CALL RETARDO
	GOTO BUCLE

FIBONACCI

	XORWF PORTB,F
	XORWF PORTB,W
	XORWF PORTB,F
	ADDWF PORTB,F
	RETURN

RETARDO
	CLRF RET1
	CLRF RET0
	DECFSZ RET0,f
	GOTO $-1
	DECFSZ RET1,f
	GOTO $-4
	RETURN

end
```

Genera esta secuencia de 384 numeros, secuencia que luego se repite:


```
00000001 (1)
00000001 (1)
00000010 (2)
00000011 (3)
00000101 (5)
00001000 (8)
00001101 (13)
00010101 (21)
00100010 (34)
00110111 (55)
01011001 (89)
10010000 (144)
11101001 (233)
01111001 (121)
01100010 (98)
11011011 (219)
00111101 (61)
00011000 (24)
01010101 (85)
01101101 (109)
11000010 (194)
00101111 (47)
11110001 (241)
00100000 (32)
00010001 (17)
00110001 (49)
01000010 (66)
01110011 (115)
10110101 (181)
00101000 (40)
11011101 (221)
00000101 (5)
11100010 (226)
11100111 (231)
11001001 (201)
10110000 (176)
01111001 (121)
00101001 (41)
10100010 (162)
11001011 (203)
01101101 (109)
00111000 (56)
10100101 (165)
11011101 (221)
10000010 (130)
01011111 (95)
11100001 (225)
01000000 (64)
00100001 (33)
01100001 (97)
10000010 (130)
11100011 (227)
01100101 (101)
01001000 (72)
10101101 (173)
11110101 (245)
10100010 (162)
10010111 (151)
00111001 (57)
11010000 (208)
00001001 (9)
11011001 (217)
11100010 (226)
10111011 (187)
10011101 (157)
01011000 (88)
11110101 (245)
01001101 (77)
01000010 (66)
10001111 (143)
11010001 (209)
01100000 (96)
00110001 (49)
10010001 (145)
11000010 (194)
01010011 (83)
00010101 (21)
01101000 (104)
01111101 (125)
11100101 (229)
01100010 (98)
01000111 (71)
10101001 (169)
11110000 (240)
10011001 (153)
10001001 (137)
00100010 (34)
10101011 (171)
11001101 (205)
01111000 (120)
01000101 (69)
10111101 (189)
00000010 (2)
10111111 (191)
11000001 (193)
10000000 (128)
01000001 (65)
11000001 (193)
00000010 (2)
11000011 (195)
11000101 (197)
10001000 (136)
01001101 (77)
11010101 (213)
00100010 (34)
11110111 (247)
00011001 (25)
00010000 (16)
00101001 (41)
00111001 (57)
01100010 (98)
10011011 (155)
11111101 (253)
10011000 (152)
10010101 (149)
00101101 (45)
11000010 (194)
11101111 (239)
10110001 (177)
10100000 (160)
01010001 (81)
11110001 (241)
01000010 (66)
00110011 (51)
01110101 (117)
10101000 (168)
00011101 (29)
11000101 (197)
11100010 (226)
10100111 (167)
10001001 (137)
00110000 (48)
10111001 (185)
11101001 (233)
10100010 (162)
10001011 (139)
00101101 (45)
10111000 (184)
11100101 (229)
10011101 (157)
10000010 (130)
00011111 (31)
10100001 (161)
11000000 (192)
01100001 (97)
00100001 (33)
10000010 (130)
10100011 (163)
00100101 (37)
11001000 (200)
11101101 (237)
10110101 (181)
10100010 (162)
01010111 (87)
11111001 (249)
01010000 (80)
01001001 (73)
10011001 (153)
11100010 (226)
01111011 (123)
01011101 (93)
11011000 (216)
00110101 (53)
00001101 (13)
01000010 (66)
01001111 (79)
10010001 (145)
11100000 (224)
01110001 (113)
01010001 (81)
11000010 (194)
00010011 (19)
11010101 (213)
11101000 (232)
10111101 (189)
10100101 (165)
01100010 (98)
00000111 (7)
01101001 (105)
01110000 (112)
11011001 (217)
01001001 (73)
00100010 (34)
01101011 (107)
10001101 (141)
11111000 (248)
10000101 (133)
01111101 (125)
00000010 (2)
01111111 (127)
10000001 (129)
00000000 (0)
10000001 (129)
10000001 (129)
00000010 (2)
10000011 (131)
10000101 (133)
00001000 (8)
10001101 (141)
10010101 (149)
00100010 (34)
10110111 (183)
11011001 (217)
10010000 (144)
01101001 (105)
11111001 (249)
01100010 (98)
01011011 (91)
10111101 (189)
00011000 (24)
11010101 (213)
11101101 (237)
11000010 (194)
10101111 (175)
01110001 (113)
00100000 (32)
10010001 (145)
10110001 (177)
01000010 (66)
11110011 (243)
00110101 (53)
00101000 (40)
01011101 (93)
10000101 (133)
11100010 (226)
01100111 (103)
01001001 (73)
10110000 (176)
11111001 (249)
10101001 (169)
10100010 (162)
01001011 (75)
11101101 (237)
00111000 (56)
00100101 (37)
01011101 (93)
10000010 (130)
11011111 (223)
01100001 (97)
01000000 (64)
10100001 (161)
11100001 (225)
10000010 (130)
01100011 (99)
11100101 (229)
01001000 (72)
00101101 (45)
01110101 (117)
10100010 (162)
00010111 (23)
10111001 (185)
11010000 (208)
10001001 (137)
01011001 (89)
11100010 (226)
00111011 (59)
00011101 (29)
01011000 (88)
01110101 (117)
11001101 (205)
01000010 (66)
00001111 (15)
01010001 (81)
01100000 (96)
10110001 (177)
00010001 (17)
11000010 (194)
11010011 (211)
10010101 (149)
01101000 (104)
11111101 (253)
01100101 (101)
01100010 (98)
11000111 (199)
00101001 (41)
11110000 (240)
00011001 (25)
00001001 (9)
00100010 (34)
00101011 (43)
01001101 (77)
01111000 (120)
11000101 (197)
00111101 (61)
00000010 (2)
00111111 (63)
01000001 (65)
10000000 (128)
11000001 (193)
01000001 (65)
00000010 (2)
01000011 (67)
01000101 (69)
10001000 (136)
11001101 (205)
01010101 (85)
00100010 (34)
01110111 (119)
10011001 (153)
00010000 (16)
10101001 (169)
10111001 (185)
01100010 (98)
00011011 (27)
01111101 (125)
10011000 (152)
00010101 (21)
10101101 (173)
11000010 (194)
01101111 (111)
00110001 (49)
10100000 (160)
11010001 (209)
01110001 (113)
01000010 (66)
10110011 (179)
11110101 (245)
10101000 (168)
10011101 (157)
01000101 (69)
11100010 (226)
00100111 (39)
00001001 (9)
00110000 (48)
00111001 (57)
01101001 (105)
10100010 (162)
00001011 (11)
10101101 (173)
10111000 (184)
01100101 (101)
00011101 (29)
10000010 (130)
10011111 (159)
00100001 (33)
11000000 (192)
11100001 (225)
10100001 (161)
10000010 (130)
00100011 (35)
10100101 (165)
11001000 (200)
01101101 (109)
00110101 (53)
10100010 (162)
11010111 (215)
01111001 (121)
01010000 (80)
11001001 (201)
00011001 (25)
11100010 (226)
11111011 (251)
11011101 (221)
11011000 (216)
10110101 (181)
10001101 (141)
01000010 (66)
11001111 (207)
00010001 (17)
11100000 (224)
11110001 (241)
11010001 (209)
11000010 (194)
10010011 (147)
01010101 (85)
11101000 (232)
00111101 (61)
00100101 (37)
01100010 (98)
10000111 (135)
11101001 (233)
01110000 (112)
01011001 (89)
11001001 (201)
00100010 (34)
11101011 (235)
00001101 (13)
11111000 (248)
00000101 (5)
11111101 (253)
00000010 (2)
11111111 (255)
00000001 (1)
00000000 (0)
```


----------



## packs (Sep 23, 2013)

Gracias a los que han contestado, mas o menos con sus respuestas tengo una idea, lo que quiero que haga es que los leds empiezan de cero (0) luego sea uno(1) ....

00000000-> 0
10000000-> 1
11000000-> 3
11100000-> 7
11110000-> 15
11111000-> 31
11111100-> 63
.
.
.
.
 así como lo deje en la tabla al empezar, lo que quería mas o menos es una "formula" y hacer un bucle para que solo con meter un 1 en W (WREG), usar una variable (MULTIPLO) para multiplicar por 2 y que se quede en esa misma variable, y por ultimo usar una segunda variable (PAST) para sumar el resultado de la multiplicación y el valor anterior y por ultimo colocarlo en el puerto, la multiplicación ya quedo y colocar el valor de la multiplicación, pero no logro hacer la suma, debo aclarar que el PIC que estoy usando es el PIC18F452

les mostraría una foto del diagrama pero no me deja subir foto

me dice que a los 5 mensajes


----------

