algo parecido a un random

[andyros]

Hola que tal , os cuento , estoy haciendo un programa para elegir los numeros de la loteria primitiva, ( cuenta del 1 al 49 , y escoge 6 numeros mediante pulsador ).  

He logrado que funcione como yo queria   , pero ahora se me habia ocurrido que el propio pic escogiese al azar los 6 numeros , vamos,  una apuesta automatica , y aqui me surge el problema , no tengo ni idea de como hacerlo ,  



Trabajo en ensamblador y estoy utilizando un 16f84a

SALUDOS

[Elena2000]

Hola!

Ah, qué bien, un compi que programa en ensamblador.
A ver si te puedo echar una manita.

Configura el pin RA0 del pic, por ejemplo, como entrada conectada al pulsador.  A ver, yo haría esto:

;*** configurar el PIC, registros, puertos, bla bla bla, y entre ellos defines dos registros, por ejemplo
PULSADOR   EQU 0x40 ; este registro para guardar la cuenta de números aleatorios
RES       EQU     0x20; por ejemplo, para guardar el resultado

; Origen del PIC... saltar la dirección de memoria de interrupciones, etc
INICIO:      
;Tu programa...
CLRF   PULSADOR
; bla bla
; Rutina para generar num. aleatorios entre 1 y 49 mientras se pulsa el pulsador
GENERAR:
btfss   PORTA,0         ; RA0 para ver si sigue pusado?
GOTO   PARA         ;Vale, no es está pulsado, podemos mostrar el número aleatorio generado
INCF   PULSADOR,F         ; Incrementamos el valor aleatorio
MOVF   PULSADOR,W         ; Miramos si es 49
SUBLW   50
BTFSS   STATUS,Z      ; Si Z esta a 1 es que la resta fue 0
GOTO   GENERAR      ; Seguimos generando el numero aleatorio
MOVLW   1   
MOVWF   PULSADOR
GOTO    GENERAR      

PARA:
MOVF   PULSADOR,W      ; Movemos el valor de PULSADOR a W
MOVWF   RES   ;Movemos el valor de W a RES para mostrar el resultado
CALL   RESULTADO   ; aqui llamas a tu rutina para mostrar el número en un display, por ejemplo

Ya nos contarás. Suerte!!

[MGLSOFT]

Tambien podrias estar haciendo alguna cuenta rara con el valor de la cuenta del timer0, el cual se incrementa sin esperarte, tal vez sea mas aleatorio que esta forma anterior..

[CDT_Gonzalo]

Escrito originalmente por MGLSOFTTambien podrias estar haciendo alguna cuenta rara con el valor de la cuenta del timer0, el cual se incrementa sin esperarte, tal vez sea mas aleatorio que esta forma anterior..

el problema es que siempre va a haber la misma distancia de numeros, porque si lo que el quiere es generar los 6 numeros juntos, cuando se empiezen a ejecutar las rutinas, lo va a hacer siempre igual, y van a tener una lógica, y deja de ser aleatorio

saludos!

[andyros]

Hola de nuevo , gracias por vuestro interes.  

Tienes toda la razon CDT_Gonzalo, me estaba refiriendo a eso exactamente, si coloco unas rutinas de tiempo , cuando salga el primer numero los otros 5 siempre seran los mismos, y por eso ando un poco perdido.

Hola Elena2000 , creo que lo que has descrito es el programa principal que ya he realizado , este con cada pulsacion escoge un numero al azar,  " ojo que este numero ya no puede salir otra vez en el contaje " y por eso debe ser excluido del contaje  y asi sucesivamente con los 6 numeros , os lo voy a dejar aqui para que le echeis un vistazo .

Lo que quiero ahora es tener la opcion de elegir yo, los numeros  ( pulsando 6 veces ) , o que el pic los genere automaticamente los 6 numeros ( con una sola pulsacion ), ok .

El montaje es un clasico , con 2 displays de 7 segmentos en paralelo ativados por  por ra0, para las unidades y ra1, para las decenas,   mediante transistor, y pulsador ra2, y todo lo necesario para hacer funcionar el pic............
He creado un registro para que este mas tiempo visible el numero ( originalmente va muy rapido , apenas visible ) , y asi poder ver que realmente los numeros seleccionados no vuelven a salir en la cuenta , en el programa final este registro no estara, ok, el registro se llama " VISIBLE  "
A ver si se nos ocurre alguna solucion .

SALUDOS

[andyros]

Hola de nuevo, no puedo subir el programa me sale un error de que no hay espacio disponible, pero este solo ocupa 20 K, como lo puede subir ?

[Nocturno]

En informática se suele utilizar muchas veces como semilla aleatoria la hora del sistema. Deduzco que en tu circuito no tienes ningún reloj externo pero, ¿porqué no implementar un reloj permanente con el PIC con el único propósito de usarlo como semilla aleatoria?.
No sé si te resultará muy complejo pero a nivel hard lo único que tendrías que añadir es alimentación por baterías, ¿no?

[pocher]

Yo también soy de la opinión que con el TMR0 se podría hacer tranquilamente. Haces que el TMR0 cuente 49 números (255-49=206) y cuando se desborde que vuelva a empezar por el 206.

Al activar el pulsador haces una captura del valor del TMR0 y con arreglo a una tabla (206=0, 207=1, ..., 255=49) sacas el valor a displays o LCD.

Si algún número se repite, pués que el programa haga una comparación con los anteriores y que lo deseche.

Puedes subir el programa aquí: http://miarroba.com/foros/ver.php?foroid=256746

[andyros]

Hola Pocher , no me deja crear un nuevo tema , me sale el siguiente error   " Lo sentimos, No tienes nivel suficiente para Nuevo tema. error  "  

Vaya , no tengo suerte .

SALUDOS

[pocher]

Pégalo, usando la # (es uno de los botones que hay cuando contestas un mensaje).

Lo aceptas todo hasta que te aparezca: (code)(/code), entonces tu código debes pegarlo entre los 2 codes.

Un saludo

[andyros]

Tampoco tengo acceso a una nueva respuesta, que complicado ,no.
Si quereis se lo envio a alguien y que lo cuelgue , ok .

SALUDOS

[MGLSOFT]

Lo que te dice Pocher es que pongas un nuevo mensaje aqui mismo, tal como hiciste con el anterior y con el boton numeral de la barra de herramientas habilitas la opcion de pegar codigo de programa que copias y luego pegas en el mensaje, luego lo cierras apretando el boton numeral...

[CDT_Gonzalo]

pensando un poco, la solucion tal vez sería generar el valor basandote en 3 datos, el valor de TMR0, el valor de un reloj externo, y el valor de TMR1...la idea podría ser la siguiente...como TMR1 es un reloj de 16 bits, vas a tener dos fases..fase de coincidencia con TMR0 y fase de no coincidencia (suponiendo que elijas el mismo prescaler), y ademas de eso, utilizar un generador de pulsos externo, lo mas inestable posible, y que trabaje a una velocidad diferente a la del reloj del PIC, y en lo posible, que vaya variando lo mas posible el valor del componente que defina la generacion del pulso externo...es complicado, pero yo creo quen o imposible...la idea esta en que busques la mayor cantidad de datos que sean asincronicos al trabajo del PIC, por darte una idea, podrias trabajar con algun sensor de temperatura, o con una resistencia LDR, que vaya variando un valor digital, son ideas, hay mucha gente que sabe muchisimo de eso y seguramente podra darte alguna idea mas firme y útil, trato de plantearte una base dentor de lo poco que se para que puedas ir desarrollando

espero te sea util

Mucha suerte con tu proyecto!, si encontras alguna solucion copada estaria bueno la comentes aqui

Saludos!
Gonzalo

[andyros]

Codigo: 


;******************************************************************************
;                           
;               A             YYYY      YYYY           RRRRRRRRR
;              AAA             YYY      YYY            RR      RR
;             AAAAA             YYY    YYY             RR      RR
;            AAAAAAA             YYY  YYY              RR    RRR
;           AAAAAAAAA             YYYYYY               RRRRRRR
;          AAA     AAA             YYYY                RR    RRR
;         AAAAA   AAAAA            YYYY                RR     RR   
;        AAAAA     AAAAA           YYYY                RR      RR
;        ********************************************************

 


;DIRECTIVAS DEL PROGRAMA             

               LIST        P=16F84A        ;PIC A UTILIZAR
               RADIX       HEX             ;SISTEMA HEXADECIMAL


;ETIQUETAS DEL PROGRAMA 


W              EQU         0x00      
F              EQU         0x01
TMR0_OPT       EQU         0x01
PC             EQU         0x02
Z              EQU         0X02
ESTADO         EQU         0x03
PUERTAA        EQU         0x05
PUERTAB        EQU         0x06
INTCON         EQU         0x0B
UNIDADES       EQU         0x0C            ; REGISTRO AUXILIAR.
DECENAS        EQU         0x0D            ; REGISTRO AUXILIAR.
VER            EQU         0x0E            ; REGISTRO AUXILIAR.
SEGUNDO_1      EQU         0x0F            ; REGISTRO AUXILIAR.
MAXIMO         EQU         0x10            ; REGISTRO AUXILIAR.
VECES_3        EQU         0x11            ; REGISTRO AUXILIAR.
PRIMERO_U      EQU         0x12            ; REGISTRO AUXILIAR.
PRIMERO_D      EQU         0x13            ; REGISTRO AUXILIAR.
SEGUNDO_U      EQU         0x14            ; REGISTRO AUXILIAR.     
SEGUNDO_D      EQU         0x15            ; REGISTRO AUXILIAR.
TERCERO_U      EQU         0x16            ; REGISTRO AUXILIAR. 
TERCERO_D      EQU         0x17            ; REGISTRO AUXILIAR.
CUARTO_U       EQU         0x18            ; REGISTRO AUXILIAR.    
CUARTO_D       EQU         0x19            ; REGISTRO AUXILIAR.
QUINTO_U       EQU         0x20            ; REGISTRO AUXILIAR.   
QUINTO_D       EQU         0x21            ; REGISTRO AUXILIAR.
SEXTO_U        EQU         0x22            ; REGISTRO AUXILIAR. 
SEXTO_D        EQU         0x23            ; REGISTRO AUXILIAR.
SALTAR         EQU         0x24            ; REGISTRO AUXILIAR.
VISIBLE        EQU         0x25            ; REGISTRO AUXILIAR.

;PROGRAMA PRINCIPAL



               ORG         0               ;ORIGEN DEL PROGRAMA, AQUI EMPIEZA.
               
               goto        INICIO          ;VA A INICIO PARA SOBREPASAR EL 
              
               ORG         5               ;VECTOR DE INTERRUPCION.

              
INICIO         bsf         ESTADO,5        ;NOS SITUAMOS EN EL BANCO 1.
               
               movlw       b"00000111"     ;CARGA EL VALOR MAXIMO EN EL
               movwf       TMR0_OPT        ;PREDIVISOR TMR0 ( 256 ). 

               movlw       b"00100"        ;Ra2 ENTRADA Y EL RESTO SALIDAS.
               movwf       PUERTAA

               clrf        PUERTAB         ;PUERTAB COMO SALIDA.
               bcf         ESTADO,5        ;NOS SITUAMOS EN EL BANCO 0.

               clrf        PUERTAA         ;LO BORRO TODO , PARA EMPEZAR.
               clrf        PUERTAB
               clrf        DECENAS
               clrf        UNIDADES
               clrf        SALTAR


               movlw       d"3"            ;CARGO EL REGISTRO CON UN 3
               movwf       VECES_3
               
               
                              
INCREMENTA     incf        UNIDADES,1      ;INCREMENTO EL REGISTRO EN UNA UNIDAD
               movfw       UNIDADES        ;Y LO CARGO EN W.
               
               
               sublw       d"10"           ;REALIZO UNA RESTA PARA VER SI 
                                           ;HA LLEGADO A 10.
               btfsc       ESTADO,2        ;TESTEO EL BITE DE ESTADO
                                           ;Y SALTO SI VALE 0.
               call        BORRO           ;VOY A BORRO.


    
;EN ESTA PARTE DEL PROGRAMA COMPARO UNO A UNO LOS NUMEROS MEMORIZADOS
;PARA QUE NO ENTREN EN LA SIGUIENTE CUENTA Y NO SALGA EL MISMO
;NUMERO 2 VECES.
;REALIZO UNA OPERACION XOR.

;bit x (w)  bit x ("f" Result. bit x (W o f según "d" 

;    0          0     ------------> 0
;    0          1     ------------> 1
;    1          0     ------------> 1
;    1          1     ------------> 0




               movfw       UNIDADES        ;EL NUMERO QUE HAY EN UNIDADES 
               xorwf       PRIMERO_U,0     ;REALIZO UNA XOR ( UNIDADES-PRIMERO_U )
               btfss       ESTADO,2        ;TESTEO EL BIT Y SALTO SI SON IGUALES
               goto        SIGUIENTE_2     ;SI NO ES IGUAL PASO AL 2º NUMERO
               

               movfw       DECENAS         ;SI EN EL PRIMER NUMERO NO COINCIDE LAS 
               xorwf       PRIMERO_D,0     ;UNIDADES NO HACE FALTA MIRAR LAS DECENAS, 
               btfss       ESTADO,2        ;SI COINCIDE MIRO LAS DECENAS.
               goto        SIGUIENTE_2     ;ASI SUCESIVAMENTE CON LOS 6 NUMEROS.
               goto        INCREMENTA      ;SI EL NUMERO COINCIDE NO LO VISUALIZO
                                           ;E INCREMENTO EL REGISTRO.

SIGUIENTE_2    movfw       UNIDADES
               xorwf       SEGUNDO_U,0
               btfss       ESTADO,2
               goto        SIGUIENTE_3
               

               movfw       DECENAS
               xorwf       SEGUNDO_D,0
               btfss       ESTADO,2
               goto        SIGUIENTE_3
               goto        INCREMENTA

SIGUIENTE_3    movfw       UNIDADES
               xorwf       TERCERO_U,0
               btfss       ESTADO,2
               goto        SIGUIENTE_4
               

               movfw       DECENAS
               xorwf       TERCERO_D,0
               btfss       ESTADO,2
               goto        SIGUIENTE_4
               goto        INCREMENTA
               

SIGUIENTE_4    movfw       UNIDADES
               xorwf       CUARTO_U,0
               btfss       ESTADO,2
               goto        SIGUIENTE_5
             

               movfw       DECENAS
               xorwf       CUARTO_D,0
               btfss       ESTADO,2
               goto        SIGUIENTE_5
               goto        INCREMENTA

SIGUIENTE_5    movfw       UNIDADES
               xorwf       QUINTO_U,0
               btfss       ESTADO,2
               goto        SIGUIENTE_6
               

               movfw       DECENAS
               xorwf       QUINTO_D,0
               btfss       ESTADO,2
               goto        SIGUIENTE_6
               goto        INCREMENTA

SIGUIENTE_6    movfw       UNIDADES
               xorwf       SEXTO_U,0
               btfss       ESTADO,2
               goto        DISPLAY_2        ;SI NO COINCIDE NINGUNO LO VISUALIZO.
                                            ;VA A DISPLAY_2

               movfw       DECENAS
               xorwf       SEXTO_D,0
               btfss       ESTADO,2
               goto        DISPLAY_2        ;SI NO COINCIDE NINGUNO LO VISUALIZO.
                                            ;VA A DISPLAY_2
               goto        INCREMENTA




                

               
DISPLAY_2      call        DISPLAY         ;VOY A DISPLAY.

               btfsc       PUERTAA,2       ;TESTEO SI SE HA PULSADO.   
               goto        INCREMENTA      ;VA A INCREMENTA.
             
               bsf         SEGUNDO_1,0     ;PONGO A 1 EL BIT, ESTE SIRVE 
               call        DISPLAY1        ;PARA REPETIR 3 VECES EL NUMERO
               goto        INCREMENTA      ;SELECCIONADO.
               
;******************  RUTINA DE DECENAS  ************************


BORRO          clrf        UNIDADES        ;BORRO LAS UNIDADES.
               incf        DECENAS,1       ;INCREMENTO LAS DECENAS.
               movfw       DECENAS         ;REALIZO UNA RESTA PARA VER SI HA
               sublw       d"5"            ;LLEGADO A 5.
               btfsc       ESTADO,2        ;TESTEO EL BITE DE ESTADO 
                                           ;Y SALTO SI VALE 0.
               goto        EMPEZAR         ;VA A EMPEZAR.

               RETURN                      ;RETORNA DE LA RUTINA. 
                          

EMPEZAR        clrf        UNIDADES        ;BORRO DECENAS Y UNIDADES PARA 
               clrf        DECENAS         ;EMPEZAR DE NUEVO.
               
               goto        INCREMENTA      ;VA A INCREMENTA.


;******************  RUTINA DE VISUALIZACION DE LOS NUMEROS  ****

DISPLAY1       movlw       0x7F            ;CARGO EL VALOR 7F EN EL REGISTRO
               movwf       MAXIMO          ;MAXIMO,ESTE ES, EL QUE HACE, QUE SE VEA  
               goto        DISPLAY_LEN     ;MIENTRAS PARPADEA.


;************* OJO CON ESTE REGISTRO  ********************************
;ESTE REGISTRO SOLO SIRVE PARA VER EL CONTAJE, Y VER COMO NO APARECEN LOS NUMEROS 
;SELECCIONADOS, EN LA VERSION FINAL NO APARECERA.



DISPLAY        movlw       96               ;ESTE HACE QUE VEAMOS UNO A UNO
               movwf       VISIBLE          ;EL CONTAJE.


;*********************************************************************
DISPLAY_LEN    movfw       UNIDADES        ;LLEVO A W EL REGISTRO UNIDADES.
               call        TABLA           ;LLAMA A LA RUTINA TABLA.
               movwf       PUERTAB         ;LLEVO LO QUE HAY EN W A LA PUERTAB.
               bsf         PUERTAA,0       ;PONGO UN 1 EN EL TRANSISTOR 
                                           ;DE UNIDADES.
               call        TIEMPO          ;LLAMO A LA RUTINA PARA 
                                           ;LA PERDIDA DE TIEMPO.
               bcf         PUERTAA,0       ;APAGO EL DISPLAY DE LAS UNIDADES.
    
               movfw       DECENAS         ;LO MISMO QUE LAS UNIDADES 
               call        DECENAS1        ;PERO ESTA VEZ PARA LAS DECENAS.
               movwf       PUERTAB
               bsf         PUERTAA,1
               call        TIEMPO
               bcf         PUERTAA,1

               btfsc       SEGUNDO_1,0     ;ESTE ES EL REGISTRO QUE UTILIZO
               goto        SALTO           ;PARA ACCEDER A LAS REPETICIONES.

               decfsz      VISIBLE,1       ;OJO CON ESTE REGISTRO ES PARA
               goto        DISPLAY_LEN     ;QUE PODAMOS VER EL CONTAJE.
               
              
 SALTO         btfss       SEGUNDO_1,0     ;VUELVO A MIRAR PARA ACCEDER.

               RETURN                      ;RETORNA DE LA RUTINA


;LLEGADO AQUI HE DE REPETIR EL NUMERO 3 VECES 

             
               decfsz      MAXIMO,1        ;RESTA EL REGISTRO HASTA LLEGAR A CERO. 
               goto        DISPLAY_LEN     ;SI NO LLEGO A CERO VA A DISPLAY_LEN.

               
               clrf        PUERTAB         ;UNA VEZ PASADO EL TIEMPO DE VISUALIZACION
               call        SEGUNDO0_5      ;APAGO MEDIO SEGUNDO LOS DISPLAYS.
       
               decfsz      VECES_3,1       ;REPETIRLO 3 VECES EL APAGADO Y ENCENDIDO.
    
               goto        DISPLAY1
               movlw       d"3"            ;VUELVO A CARGAR EL REGISTRO.
               movwf       VECES_3         ;PARA LA PROXIMA REPETICION
               bcf         SEGUNDO_1,0     ;Y APAGO EL BIT PARA QUE NO REPITA MAS.


;CON ESTE BIT REPITO LOS 6 NUMEROS MEMORIZADOS , LLEGADO AQUI SE ACABO LA SELECCION, 
;SE QUEDARA REPITIENDO EN UN BUCLE INFINITO DE MOMENTO......


               btfsc       SALTAR,5        ;UTILIZO ESTE BIT PARA VER LOS 6 NUMEROS
                                           ;LLEGADO AQUI HEMOS TERMINADO "DE MOMENTO".

               return                      ;RETORNA DE LA RUTINA.
               call        GRABAR          ;AQUI VA A GRABAR EL NUMERO.( AUN POR REALIZAR)

;*************************************************************************************
               btfsc       SALTAR,5        ;TESTEA DE NUEVO EL BIT.
               goto        ACABO_1         ;Y VA A ACABO_1 EN UN BUCLE INFINITO.
                                           

;AQUI MEMORIZO LOS NUMEROS PARA DESPUES COMPARARLOS.

               btfsc       SALTAR,0        ;MIRO SI EL BIT ES 1 SI NO SALTO.    
               goto        SEGUNDO_N       ;SI ERA UNO ES POR QUE EL PRIMER 
                                           ;NUMERO ESTA MEMORIZADO.
               movfw       UNIDADES        ;LLEVO LAS UNIDADES A W.
               movwf       PRIMERO_U       ;MEMORIZO LAS UNIDADES.
               movfw       DECENAS         ;LLEVO AS DECENAS A W.
               movwf       PRIMERO_D       ;MEMORIZO LAS DECENAS.
               bsf         SALTAR,0        ;PONGO A 1 EL BIT PARA SABER QUE 
                                           ;HE MEMORIAZADO EL PRIMER NUMERO.
               goto        INCREMENTA      ;VA A INCREMENTA

SEGUNDO_N      btfsc       SALTAR,1        ;TODO IGUAL HASTA MEMORIZAR LOS 6.
               goto        TERCERO_N       
               movfw       UNIDADES
               movwf       SEGUNDO_U
               movfw       DECENAS
               movwf       SEGUNDO_D
               bsf         SALTAR,1

               goto        INCREMENTA

TERCERO_N      btfsc       SALTAR,2
               goto        CUARTO_N
               movfw       UNIDADES
               movwf       TERCERO_U
               movfw       DECENAS
               movwf       TERCERO_D
               bsf         SALTAR,2

               goto        INCREMENTA

CUARTO_N       btfsc       SALTAR,3
               goto        QUINTO_N
               movfw       UNIDADES
               movwf       CUARTO_U
               movfw       DECENAS
               movwf       CUARTO_D
               bsf         SALTAR,3

               goto        INCREMENTA
               
QUINTO_N       btfsc       SALTAR,4
               goto        SEXTO_N
               movfw       UNIDADES
               movwf       QUINTO_U
               movfw       DECENAS
               movwf       QUINTO_D
               bsf         SALTAR,4

               goto        INCREMENTA

SEXTO_N        movfw       UNIDADES
               movwf       SEXTO_U
               movfw       DECENAS
               movwf       SEXTO_D
               bsf         SALTAR,5   
               
;****************** BUCLE INFINITO *******************
                                           
ACABO_1        movfw        PRIMERO_U      ;PONGO EL REGISTRO EN W.
               movwf        UNIDADES       ;Y LO LLEGO AL REGISTRO UNIDADES.
               movfw        PRIMERO_D      ;IGUAL CON LAS DECENAS.
               movwf        DECENAS
               bsf          SEGUNDO_1,0    ;PONGO A 1 EL BIT.
               call         DISPLAY1       ;Y HAGO LA LLAMADA PARA VISUALIZAR.

               movfw        SEGUNDO_U      ;Y ASI SUCESIVAMENTE CON LOS 6.
               movwf        UNIDADES
               movfw        SEGUNDO_D
               movwf        DECENAS
               bsf          SEGUNDO_1,0
               call         DISPLAY1 

               movfw        TERCERO_U
               movwf        UNIDADES
               movfw        TERCERO_D
               movwf        DECENAS
               bsf          SEGUNDO_1,0
               call         DISPLAY1 

               movfw        CUARTO_U
               movwf        UNIDADES
               movfw        CUARTO_D
               movwf        DECENAS
               bsf          SEGUNDO_1,0
               call         DISPLAY1  

               movfw        QUINTO_U
               movwf        UNIDADES
               movfw        QUINTO_D
               movwf        DECENAS
               bsf          SEGUNDO_1,0
               call         DISPLAY1  

               movfw        SEXTO_U
               movwf        UNIDADES
               movfw        SEXTO_D
               movwf        DECENAS
               bsf          SEGUNDO_1,0
               call         DISPLAY1 

               goto         ACABO_1       ;BUCLE INFINITO.                                 
               


;******************  RUTINA DE VISUALIZACION DE LAS UNIDADES  *****************



TABLA       addwf           PC,F           ;COGE EL VALOR HEX Y LO CONVIERTE.
                                           ;EN EL NUMERO PARA QUE SE VEA EN
                                           ;DISPLAY.

            
                      
            retlw           3F
            retlw           06
            retlw           5B
            retlw           4F
            retlw           66
            retlw           6D
            retlw           7D
            retlw           07
            retlw           7F
            retlw           67

 
;******************** RUTINA DE VISUALIZACION DE LAS DECENAS *******************


DECENAS1    addwf           PC,F           ;COGE EL VALOR HEX Y LO CONVIERTE.
                                           ;EN EL NUMERO PARA QUE SE VEA EN
                                           ;DISPLAY.

            
                      
            retlw           00
            retlw           06
            retlw           5B
            retlw           4F
            retlw           66


;******************* RUTINA DE GRABACION DE LA EEPROM *************************

            
GRABAR       return   
;******************** RUTINA PARA PERDER TIEMPO ********************************

TIEMPO1      bcf            INTCON,2       ;BORRA EL TESTIGO DE DESBORDAMIENTO
             movlw          0xF0           ;CARGO EL NUMERO 240 EN TMRO, CON LO 
                                           ;CUAL CONTARA 16 VECES, (256-240=16).

             movwf          TMR0_OPT       
TIEMPO2      btfss          INTCON,2       ;MIRA EL TESTIGO DE DESBORDAMIENTO
             goto           TIEMPO2        ;Y SALTARA CUANDO TERMINE DE CONTAR.
            
             decfsz         VER,F          ;RESTA EL REGISTRO VER Y LO DEPOSITA
             goto           TIEMPO1        ;EN EL MISMO, HASTA VALER 0.
         
             return


;******************* RUTINA DE 0"5 SEGUNDO *************************************
SEGUNDO0_5   movlw          0x7A           ;CARGO EL NUMERO 122 EN W.
             goto           MAS            ;VA A MAS.



;******************* RUTINA DE 0"1 SEGUNDO *************************************

REPETIR1     movlw          0x0A           ;CARGO EL NUMERO 10 EN W.
             goto           MAS            ;VA A MAS.


;******************* RUTINA DE 0"04 SEGUNDO ************************************

TIEMPO       movlw          0x01           ;CARGO EL NUMERO 1 EN W.
MAS          movwf          VER            ;SE DEPOSITA EN EL REGISTRO VER.
             call           TIEMPO1        ;VA A TIEMPO1.

             return                        ;RETORNA DE LA RUTINA


             END                        

[andyros]

Hola de nuevo , ya he conseguido poner el mensaje, ( gracias por las indicaciones, MGLSOFT )

Como podeis ver en el programa , se escoge los numeros pulsando 6 veces , y lo que quiero conseguir es que,  con solo una pulsacion el pic genere los 6 numeros aleatoriamente ( si es posible ) .

SALUDOS