Autor Tema: Correr programas en la memoria Ram de un Pic  (Leído 13118 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #30 en: 12 de Enero de 2019, 15:35:05 »
Eso es por la parte de las luces, porque también quiero incluir un control de servomotor para hacer una o dos secuencias de movimientos.

Desconectado misterweb

  • PIC16
  • ***
  • Mensajes: 128
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #31 en: 13 de Enero de 2019, 09:39:11 »
Hola buenas Picuino:

Voy intentando entender tu proyecto:

Citar
La idea es usar una comunicación con un PC por puerto serie (con un conversor USB a UART externo).

Presupongo que es por el puerto serie por donde quieres meter los datos para que las luces vayan variando.

Citar
Las secuencias pueden ser sencillas, pero hay que describirlas de alguna manera. Eso que dices es un lenguaje de programación.

Pueden ser simplemente datos o bytes registrados en la memoria RAM, luego el programa que tienes dentro del Pic se encargue de interpretarlos y ejecutarlos .

Citar
TASK   1
WAIT  500
LED    1, 250
WAIT  500
LED    1, 0
END

El valor 250 puedo ser como una especie de ciclo de PWM?

Segun lo que te dije antes atraves del puerto serie  almacenas en las posiciones :

posicion     contenido
RAM
100             - valor 10  significa que llame a subrutina fijar los valores del retardo
101             - valor 0 
102             -  valor 50
103             -  valor 10    estos tres ultimos valores hacen que al final sea el retardo de 500
104             - valor 30   esto hace que corra la subrutina que tienes arriba de encender el LED1
105             -valor 31  hace que corra la subrutina de LED2
106              -valor 'q'   quit  fin de programa.


Asi es como funcionaria mi programa, las subrutinas ya estarian escritas y funcionando en la flash, no se si esto te podria valer a ti.
El programa se puede complicar todo lo que quieras...

Para probar los efectos de luz lo unico que tendrias que es variar el archivo de carga RAM volver a cargarlo y correrlo puedes tardar a lo mejor 10 segundos en hacerlo.

Saludos.
 
     
« Última modificación: 13 de Enero de 2019, 10:02:46 por misterweb »

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #32 en: 13 de Enero de 2019, 10:22:56 »
Presupongo que es por el puerto serie por donde quieres meter los datos para que las luces vayan variando.
Por el puerto serie meto el programa en formato de texto. Luego las luces varían dependiendo del programa, sin necesidad de conexión con el PC.
El puerto serie es en realidad un conversor USB-UART


El valor 250 puedo ser como una especie de ciclo de PWM?

Si, el pwm va desde 0 (apagado) hasta 250 (brillo máximo)


Segun lo que te dije antes atraves del puerto serie  almacenas en las posiciones :

posicion     contenido
RAM
100             - valor 10  significa que llame a subrutina fijar los valores del retardo
101             - valor 0 
102             -  valor 50
103             -  valor 10    estos tres ultimos valores hacen que al final sea el retardo de 500
104             - valor 30   esto hace que corra la subrutina que tienes arriba de encender el LED1
105             -valor 31  hace que corra la subrutina de LED2
106              -valor 'q'   quit  fin de programa.

La ram sería igual en los dos proyectos (el tuyo y el mío), pero en el mío el microcontrolador recibe los datos en formato texto y los convierte en lenguaje intermedio almacenado en la RAM. Posteriormente, una rutina se encarga de ejecutar los códigos de la RAM.

En mi caso el intérprete está en el micro y en tu caso el intérprete está en el PC.
En los dos casos, los intérpretes utilizan un lenguaje intermedio que se almacena en RAM.
En los dos casos una máquina virtual se encarga de interpretar ese lenguaje intermedio llamando a las subrutinas.



Pero en el mío

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #33 en: 13 de Enero de 2019, 10:46:54 »
La traducción correcta para mi código sería algo así:

(He cambiado algo las órdenes porque aún estoy definiendo el lenguaje)

Progama en formato texto:
Código: [Seleccionar]
TASK   1     
WAIT  500
LED    1, 250
WAIT  500
LED    1, 0
REPEAT
END

Programa en lenguaje intermedio o bytecode:
Código: [Seleccionar]
0x01     // orden WAIT 
0xF4
0x01     // numero 500 en formato de 16bits little-endian (podría también utilizarse big-endian)

0x11     // orden cambiar luminosidad del led 1 (0x12 sería cambiar la luminosidad del led 2)
0xFA     // Valor 250 en formato de 8 bits sin signo

0x01     // orden WAIT 
0xF4
0x01     // numero 500 en formato de 16bits little-endian (podría también utilizarse big-endian)

0x11     // orden cambiar luminosidad del led 1 (0x12 sería cambiar la luminosidad del led 2)
0xFA     // Valor 250 en formato de 8 bits sin signo

0x02     // REPEAT. Se comienza otra vez desde el principio

0x00     // END. Fin de la tarea.

Con esto estaría almacenada la rutina en RAM.


A continuación un programa sería una tarea especial que sirve para lanzar a un conjunto de tareas todas juntas. Se almacena en memoria así:

Código: [Seleccionar]
TASK 3
RUN  1   // Ejecuta la tarea 1
RUN  2   // Ejecuta la tarea 2
END


Código: [Seleccionar]
0x02     // orden init TASK
0x01     // Tarea número 1 (la primera tarea almacenada en la tablas de tareas

0x02     // orden init TASK
0x02     // Tarea número 2 (la segunda tarea almacenada en la tablas de tareas

0x00     //  END. Fin de la tarea. El programa termina y no se repite más.


Por último, la posición en RAM de cada una de las tareas se almacenan en una tabla.
Con la orden RUN 1 se ejecuta la tarea almacenada en la tabla en la primera posición.
Con la orden RUN 2 se ejecuta la tarea almacenada en la tabla en la Segunda posición.
Ahora las dos tareas se ejecutan a la vez, pero han comenzado en tiempos distintos y no están sincronizadas.

Si lo paro todo y mato las tareas (STOP) puedo iniciar las dos a la vez de forma sincronizada llamando a la tarea 3. RUN 3

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #34 en: 13 de Enero de 2019, 10:52:51 »
Para sincronizar todas las tareas hago lo siguiente:

1. El sistema tiene un contador de milisegundos que se va actualizando por interrupciones.
Por ejemplo podría estar en 15300 milisegundos

2. Cada tarea tiene un contador de tiempo, que se copia del contador de milisegundos del sistema con la orden RUN.
En este caso se copiaría  15300

3. En cada orden WAIT, se incrementa el contador de tiempo de la tarea
Por ejemplo un WAIT 500, aumentaría el contador de la tarea hasta 15800 milisegundos

Hasta que el contador del sistema no llege al valor del contador de la tarea, el programa no sigue adelante.



Esto asegura que no se pierden milisegundos al ejecutar otras instrucciones y así la cuenta de milisegundos de todas las tareas siempre estarán sincronizadas.
Esto evita tener que añadir instrucciones de sincronización y asegura que los tiempos de los programas siempre son consistentes.

Un saludo.
« Última modificación: 13 de Enero de 2019, 10:55:27 por Picuino »

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #35 en: 13 de Enero de 2019, 15:05:23 »
https://wiki.tcl-lang.org/page/Small+Tcl


Do you want a particularly small version of Tcl to embed in a hardware-constrained device? You're not the first. There are a few possibilities listed in the Implementations section of this page.


Desconectado misterweb

  • PIC16
  • ***
  • Mensajes: 128
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #36 en: 14 de Enero de 2019, 16:54:23 »
Muy buena Picuino

Veo que tienes la idea de meter el compilador de texto dentro del microcontrolador, no se cuanto lo tendras avanzado, pero lo veo un buen trabajito ademas de ver la forma como implentar cualquiera de los lenguajes que propones como tcl,... etc..

Aparte de espacio que ocupara esto el PIC.

Citar
Estoy usando para las pruebas un PIC16F15325, pero tengo la intención de que quepa en un PIC16F15324

No se te quedaran un poco pequeños estos pics.

Yo este proyecto es igual a mi idea que tuve hace mucho tiempo, tengo varios 8085, todos los integrados anexos a esta serie, control teclado, expansor puerto, etc..

Con la idea de montarme un miniordenador parecido al Spectrump, bueno pues la idea a la hora de montar el compilador en aquella epoca se usaban las memoria UVprom, estas eran la memorias que venian con ventanita de cristal y que se borraban con una lampara de ultravioleta, se programaban con un programador de Vprom.

El compilador que  usaba el Basic de aquella epoca, bueno pues pensando como implementarselo lo que se me ocurrio en aquel momento fuera con una de esas memoria UVprom, aunque hoy existiendo las memorias EEprom esto es mucho mas sencillo.

Al caso, la forma de implentarselo que se me ocurrio en esa epoca, era grabar en la memoria sucesivamente el texto de la orden y seguido el codigo en hexadecima de esa orden, de la forma siguiente  .. como ejemplo


orden    codigo hex
LET            05h
PRINT        0Ah
GOTO        3Ch
QUIT          3Ah
---------
---------
ETC...

El que manejaba el Spectrump en aquella epoca, se acordara de que se metia la orden comando por teclado y se apretaba ENTER, si no era correcto te daba un mensaje error, y si lo era daba mensaje creo OK. y esperaba el siguiente comando asi sucesivamente.

El caso es que interiormente me supongo que lo que haria es comparar la cadena de texto con una de las almacenadas en la memoria UVprom y encontraba la coincidencia  pues le asociaba el valor en hexadecimal de la orden.

Bueno todo este rollo es para  mostrarte otro punto de vista, que podria ser el grabar una memoria EEprom externa o la misma memoria interna del microcontrolador las cadenas de texto con las ordenes  y seguido el codigo hexadecimal asociado, lo unico que te tienes construir una subruitina que compare la cadena en EEprom con la que  tu has metido por el puerto serie, y te de codigo HEX correspondiente.

El construir una subrutina que haga eso no me parece  nada complicado y en principio me parece menos complicado que intentar implementar un tcl dentro del Pic.

Tampoco estoy por quitarte la idea, cada uno debe tener sus ideas propias para su proyecto,  simplemente te doy un punto de vista diferente.

Un abrazo.       




« Última modificación: 14 de Enero de 2019, 17:42:17 por misterweb »

Desconectado misterweb

  • PIC16
  • ***
  • Mensajes: 128
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #37 en: 14 de Enero de 2019, 17:24:50 »
Buenas ..

Precisamente rebuscando entre componentes que habia comprado hace tiempo em encontre con 5 - PIC24HJ128GP506, no me arcordaba ni que los tenia,

Y ahora me recorde que los tenia precisamente para un proyecto como este que era correr programas en la memoria RAM externa.

http://ww1.microchip.com/downloads/en/DeviceDoc/70175H.pdf

Saludos

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #38 en: 14 de Enero de 2019, 18:02:22 »
Hola misterweb. Implementar el TCL en un pic es casi imposible. Es un lenguaje muy flexible y dinámico en tiempo de ejecución y necesita mucha memoria RAM.
El TCL estaría al nivel del Lua, ambos para microprocesadores de 32 bits ocupando unos 100kb de memoria Flash.
Lo bueno del TCL es su filosofía muy simple y flexible. Puede inspirar para hacer otros lenguajes. Además la versión Picol ocupa solo 800 líneas de código, por lo que es suficientemente sencillo como para estudiarlo.


Por otro lado el Forth para Arduino ocupa unos 8kb. Es demasiado grande, aunque no necesito el compilador solo intérprete. Pero no voy a intentar simplificarlo porque no me gusta mucho la notación RPN.

He probado a compilar el uBasic y ha ocupado unos 3900Words, casi toda la memoria, pero ya se va acercando a lo que quiero.

Si al final veo muchos problemas de memoria, haré lo que tu pensabas, colocar el compilador en el PC. Por ahora tengo todas las rutinas de PWM y de comunicación UART por interrupciones en 1430 words (35% de memoria ocupada).
La idea final creo que será implementar una especie de lenguaje máquina interpretado. Como tú dices es bastante sencillo implementar el compilador. Simplemente se busca la palabra en un diccionario y se traduce a un código en memoria.

Luego un intérprete se limita a llamar a las diferentes funciones según el código que se encuentre en la memoria (una orden switch case)

Por ahora estoy liado con las estructuras de datos. Tengo que ponerlo todo en RAM, con la opción de guardar programas en FLASH para recuperarlos más adelante.

Un saludo.

Desconectado misterweb

  • PIC16
  • ***
  • Mensajes: 128
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #39 en: 15 de Enero de 2019, 18:37:59 »
Muy buenas Picuino y demas gente:

Citar
Si al final veo muchos problemas de memoria, haré lo que tu pensabas, colocar el compilador en el PC.

En principio sino no son muchos comandos inclusive en la flash del microcontrolador, en C podria ser algo
parecido a esto.

Código: [Seleccionar]
char COMANDO [ ] = "WAIT";
if (strcmp(DATO_EN_RAM, COMANDO)  == 0) { graba_codigo_hex_de_wait_en_RAM();   }

char COMANDO [ ] = "LED1";
if (strcmp(DATO_EN_RAM, COMANDO)  == 0) { graba_codigo_hex_de_wait_en_RAM();  }

Si ya empiezan a ser muchos comandos se podria almacenar los textos en la eeprom o de pic o exterior y entonces
y crear una rutina que vaya buscando los datos en la eeprom comparandola con la variable DATO_EN_RAM
y cuando encuentre coincidencia grabe dato contiguo en la eeprom, que es el codigo hex del comando en la RAM.

Para ello a lo mejor habra que dar un tamaño de grabacion del texto del comando en la eeprom, esto es dar un
ancho por ejemplo de 8 caracteres estandar, si el comando tiene menos caracteres rellenarlos con espacios en blanco,
y lo mismo los datos del comando que vienen por el puerto serie y se almacenan en RAM.

De esta forma asegura la comparacion y la sincronizacion de los datos.

Citar
y de comunicación UART por interrupciones en 1430 words

 Gracias a la interrupcion del puerto serie por que si no los datos se acaban perdiendo por falta de sincronizacion
 entre PC y PIC.

Citar
Luego un intérprete se limita a llamar a las diferentes funciones según el código que se encuentre en la memoria
(una orden switch case)

A lo mejor si lo vas a grabar en la flash, entonces correrlo ya directamente en la flash.
Puede que en algunos casos si grabas flash de esta forma tengas que recolocar todo el programa flash del pic o parte.

Aunque seguramente antes de grabarlo en flash lo que querras probar en memoria.

En mi caso en ensamblador el este codigo seria algo parecido a esto:

Código: [Seleccionar]
;**********************************************************************
;  SUBRUTINA EJECUCION PROGRAMA RAM EN BLOQUE 100 - 1FF
;  LOS CODIOGOS DE COMANDOS YA ESTAN ALMACENADOS EN EN ESTE BLOQUE
;  JUNTO CONLOS DATOS ANEXOS.
;**********************************************************************

RUNPROG
movlw 0x01    ;  Inicializacion contador de program
movwf FSR0H  ; 
movlw 0x00
movwf FSR0L


movlw 0ffh
movwf COUNTER

LAZO
    movf POSTINC0,W ; Mueve el dato de memoria a work y incrementa a la posicion
addwf PCL,1     ; Sumaselo a PCL para saltar al comando adecuado

    bra COMANDO1 ; CARGA COMANDO 1 ENVIAR UN DATO POR EL PUERTO A
    bra COMANDO2    ; CARGA COMANDO 2 ENVIAR UN DATO POR EL PUERTO B
    bra COMANDO3    ; CARGA COMANDO 3  ENVIAR UN DATO POR EL PUERTO C
    bra COMANDO4    ; CARGA COMANDO 4 PARA CONFIGURAR LAS VARIABLES DEL RETARDO
    bra COMANDO5  ; CARGA COMANDO 5 HACER UN SALTO INCODICIONAL A UNA DIRECCION DE PROGRAMA. 
    bra COMANDO6    ; CARGA COMANDO 6 HACER UN SALTO CODICIONAL A UNA DIRECCION DE PROGRAMA.
    bra COMANDO7    ; CARGA COMANDO 7 PARA EJERCUTAR  LA FUNCION RETURN RETORNO LLAMADA CALL.
    bra COMANDO8    ; CARGA COMANDO 8 ENVIO DE UN DATO BLOQUE 300-3FF A UNA POSICION DETERMINADA 200-2FF.
    bra COMANDO9    ; CARGA COMANDO 9 CONFIGURACION ENVION DATOS COMANDO ANTERIOR -- COMANDO8.
    bra COMANDO10   ; CARGA COMANDO 10 PARA CONFIGURACION PUERTO A  TRISA 
    bra COMANDO11   ; CARGA COMANDO 11 PARA CONFIGURACION PUERTO B  TRISB
    bra COMANDO12   ; CARGA COMANDO 12 PARA CONFIGURACION PUERTO C  TRISC 
    bra COMANDO13   ; CARGA COMANDO 13 CONFIGURA PUERTO I2C VIRTUAL.
    bra COMANDO14   ; CARGA COMANDO 14 SACA DATO POR EL PUERTO I2C VIRTUAL.
    bra COMANDO15   ; CARGA COMANDO 15 FIJA CONDICION DE START.
    bra COMANDO16   ; CARGA COMANDO 16 INICIA CIRCUITO I2C
    ETC...
     

salida

    decfsz COUNTER
    goto LAZO
   
    return

COMANDO1    ; EJEMPLO
    ETC..
    ETC..

    bra salida

COMANDO2
  ETC..

COMANDO3
  ETC..

Citar
Por ahora estoy liado con las estructuras de datos. Tengo que ponerlo todo en RAM, con la opción de guardar
programas en FLASH para recuperarlos más adelante.

¿Puede ser po los tamaños de los textos de los comandos como comente anteriormente? cual es el problema.

Que bonito, en definito es lo mismo que hace un ordenador o el Spectrump, que es compilar y descompilar o lo que
es lo mismo ensamblar y desensamblar.

Bueno si lo grabas en una eeprom, lo mismo que cuando compilas buscas la cadena y cuando lo encuentras salvas el
codigo del comando, cuando descompiles puedes hacer lo inverso, que es buscar el codigo de del comando y extraer
de la misma eeprom la cadena correspondiente.

La verdad es que todo esto es un buen trabajito.....jejeje, pero a mi me parece muy interesante.

Ademas Picuino cuando alguien crea un compilador, nadie lo crea todo a la vez, pasito a pasito, pienso que
nada es trabajo perdido, puede que en algun momento tengas que modificar muchas cosas pero aunque parezca
que no todo lo anterior vale.

Para mi que hago todas estas cosas por puro hobby el placer esta justo en el momento que estoy creando el codigo.
acabado esto queda satisfacion pero pasado el tiempo casi el olvido.


Un saludo.

« Última modificación: 15 de Enero de 2019, 18:41:22 por misterweb »

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #40 en: 16 de Enero de 2019, 04:44:23 »
El problema que tengo consiste en que cada rutina necesita memoria ram para los punteros de ejecucion, el estado run o idle, el contador de tiempo de espera, etc.

Para que sea pequeño y reubicable utilizo punteros relativos de 1byte.

La idea es rescatar una rutina de la flash y colocarla en ram para ejecutarla.
También quiero poder guardar una rutina desde la ram hasta la flash.

Como dices, la parte de compilación es sencilla porque solo hay 5 comandos sencillos.

A mi también me gusta la idea de emular un pequeño micro como el spectrum, aunque mi proyecto sea mucho más sencillo.

Un saludo.

Desconectado JamesTaggart

  • PIC10
  • *
  • Mensajes: 17
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #41 en: 16 de Enero de 2019, 18:47:35 »
Si la idea es probar secuencias de comandos para controlar algún dispositivo como LCDs o módulos SPI, I2C usando puerto serial, creo que la mejor alternativa sería implementar algo similar a lo que hicieron los de Sparkfun en el BusPirate:




https://learn.sparkfun.com/tutorials/bus-pirate-v36a-hookup-guide

Código: [Seleccionar]
HiZ>m
1. HiZ
2. 1-WIRE
3. UART
4. I2C
5. SPI
6. 2WIRE
7. 3WIRE
8. LCD
9. DIO
x. exit(without change)

Código: [Seleccionar]
I2C>[0x3a 0x0f [0x3b r]
I2C START BIT
WRITE: 0x3A ACK
WRITE: 0x0F ACK
I2C START BIT
WRITE: 0x3B ACK
READ: 0x41
NACK
I2C STOP BIT
I2C>

Desconectado misterweb

  • PIC16
  • ***
  • Mensajes: 128
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #42 en: 16 de Enero de 2019, 19:07:15 »
Muy buenas Picuino:

Citar
El problema que tengo consiste en que cada rutina necesita memoria ram para los punteros de ejecucion, el estado run o idle, el contador de tiempo de espera, etc.

No entiendo muy bien esto que dices, la idea que tengo del programa que quieres hacer se me ocurre de la siguiente forma.

Seria crear un array en RAM muy grande, dependeria del numero de rutinas con las que se fueran a grabar provenientes del puertos serie.

array[255]

Pero si por ejemplo a tamaño del comando le damos 7 caracteres ascii que como te dije en anterior post si no se compleratara se deberia completar con caracteres vacios.

Bueno creamos una variable PUNTERO, esta variable va saltando de 7 en 7:

0 a 6    - inculida primera rutina
7 a 13  - incluida 2 rutina
16 a 20 - etc..

cuando vaya a leer la primera posicion de rutina en RAM, leera las posicions 0,1,2,3,4,5,6 y las puede meter en un array por ejemplo

comando[6]

El puntero saltara 0, 7,14,21, etc..

Bueno por otro lado tenemos el lado de la memoria flash o eeprom, buen cuando se lee la flash o se graba en flash existe el puntero ptro o TBLPTR, bueno este puntero se incrementa cada vez que se lee un dato o se escribe.

El caso es que es un unico puntero.  Se puede reservar un espacio para el texto de la instruccion igual de 7 caracteres y en este caso el 8 byte se puede meter el codigo hexadecimal de ese comando.

De tal forma en la tablas e guardaria.

0 a 6 texto instrucion    7  codigo hex
8 a 14 texto instrucion    15  codigo hex
16 a 22 texto instrucion    23  codigo hex

Habra que hacer una subrutina que grabe o lea texto de la flash o eeprom con una variable PUNTERO2 que vaya
pegando saltos  0, 8, 16, 24 , etc...

Bueno esta subrutina cuando marque PUNTERO2 una posicion por ejemplo la 0 tendra que menter los datos contenidos en las posicones 0,1,2,3,4,5,6   dentro del array

comando2[7]

Bueno tanto los transistos de busqueda de codigo de instruccion, grabar datos de RAM a flash, como pasar datos de Flash a RAM, los transistos se harian entre los arrays comando[7]   y comando2[7].

Los punteros en principio yo solo veo dos  PUNTERO Y PUNTERO2 una para memoria RAM y otro para la flash y ambos se modificarian igual de forma incremental uno de 7 en 7 y otro de 8 en 8.

Yo en principio no veria mucho mas , aunque puede que me este equivocando.

Saludos.

Desconectado misterweb

  • PIC16
  • ***
  • Mensajes: 128
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #43 en: 16 de Enero de 2019, 19:33:33 »
 Muy Buenas JamesTaggart

Interesante el Bus Pirate, sobre todo puede trabajar con tensiones de 3,3 y 5 V.

Bueno  para averiguar con que address esta trabajando un dispositivo I2C existe una programita de Arduino que es muy util y te lo averigua.

Pero lo mas interesante de todo seria que este circuito hiciera funciones de sniffer esto es que si estas analizando la comunicacion I2C entre dos dispositivos te grabara y te sacara las tramas entre los 2 dispositivos.

Yo esto lo he intentado con un microcontrolador a nivel de capturar las tramas y luego traducirlo a un protocolo, pero al final me ha vuelto loco y no he conseguido sacar nada coherente, en fin es un proyecto que tengo ahi y que intentare algun dia resolver.

Bueno el proyecto que yo quiero hacer es esto de probar dispositivo, pero tambien muchas cosas mas , crear un trama, atacar distintos dispositivos logicos, etc.. etc..

Saludos.


Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re:Correr programas en la memoria Ram de un Pic
« Respuesta #44 en: 17 de Enero de 2019, 04:40:29 »
En mi caso, los comandos tienen que ser interactivos y también correr solos, en forma de tareas (task).
En memoria puede haber varias tareas, no solo una, y todas pueden correr de forma independiente (multitarea) incluso mientras el micro responde a órdenes interactivas. También puede haber tareas en marcha y otras paradas.

Las tareas se almacenan en un array de memoria de 250 bytes:
  char memprog[250]

Las órdenes se almacenan con códigos, no en forma de texto. Una especie de código máquina o bytecode.
Cada tarea tienen una cabecera de datos con su estado (RUN, STOP, IDLE) su número identificador del 0 al 32, los milisegundos de espera y un puntero a la posición de RUN.
Cada tarea apunta a la siguiente, en forma de lista encadenada, la última tarea tiene un puntero NULL para indicar el final de la lista.

Cuando se ejecuta una tarea, se copia el tiempo del sistema (millis) en la variable de milisegundos de la tarea. Cuando llega una orden WAIT, los milisegundos de la tarea se incrementan y el estado pasa a IDLE. En ese estado lo único que hace la tarea es esperar hasta que el tiempo del sistema valgan lo mismo que los milisegundos almacenados en la tarea y entonces vuelve al estado RUN.


De forma que tengo varios retos de almacenamiento de datos y de ejecución en paralelo.

Un saludo.