Sesión 10.

Por ahora no hemos conseguido solventar el error

Por lo visto el error se debe a esto: El EP9302 es un integrado que

incluye el ARM9 y algunos componentes adicionales. Pues bien, en el

Sistema Operativo, hay algunos componentes del EP9302 no están mapeados en memoria. Para poder mapearlos en memoria a nivel de drivernos han comentado que hay que seguir este tipo de estructura:

DIO_DIR7 0xDIRECCION 

//Definir los buffer 

 volatile char *ptr_1; 

//comprobar disponibilidad 

if(check_mem_region(DIO_DIR7, 1)) {               printk("DUMB: espacio de memoria en uso: DIO_DIR07\n");                    return -EBUSY;       } 

//Tomar memoriarequest_mem_region(DIO_DIR7, 1, "dumb_driver_07");  

     ptr_1 = __ioremap(DIO_DIR7, 1, 0); 

printk("dumb: ptr_1 remap = %p\n", ptr_1);

 //Dar valor 

 ptr_1[0] = 0xAA; 

 // Salir 

 release_mem_region(DIO_DIR7, 1);

Sin embargo, hemos desarrollado esa estructura para el driver y nos sigue dando exactamente el mismo error.

Aún seguimos en el laboratorio, pero sin ayuda, no creo que consigamos avanzar.

He aqui una foto del problema (en el log):

Sesión 9

Ha sido una de las sesiones menos productivas. Hemos descubierto que el driver del ADC no nos funciona, después de conectarle un voltaje a la entrada. A lo que dejamos hecho en la practica anterior faltaba asignarle el driver a su archivo:
"mknod   /dev/adc  c  70  0"
Al parecer cuando intentamos acceder a un registro desde el driver --> segmentation fault.
Hemos visto el log, y pone algo del estilo de "kernel paging error".
Como Álvaro no estaba para ayudarnos, nos hemos dedicado ha hacer el driver del Timer y a pensar como estructurar el driver/aplicación de interrupciones.

Esperamos arreglar esto pronto.

Sesión 8.

Bueno, la verdad es que ha sido una mañana en la que hemos aprendido bastante.
Hemos estado al principio repasando un poco todo lo de controladores y estudiando uno que nos habían proporcionado hecho (aun que era solo para los LEDs rojo y verde de la placa). Cuando hemos conseguido entenderlo todo nos hemos puesto manos a la obra para hacer nuestro propio controlador (el del ADC).
La verdad es que al final ha sido más facil de lo que pensábamos aun que hemos tenido que llamar a nuestro tutor para un par de cosas:
a) El primer problema era qué funciones del ADC meter en el controlador, y qué meter en la aplicación de usuario.
Álvaro nos ha comentado que esto está un poco en mano del programador y lo hemos hecho como nos ha parecido (aun que el nos ha dado el visto bueno).
b) El otro problema era que los los controladores solo se comunican con la aplicación mediante "char" y el registro de datos del ADC era de 12 bits, con lo cual hemos tenido que dividir el valor leido en 2 valores, y mandarselo a la aplicación en un buffer (buf[0] , buf[1]).
La aplicación a su ver tenía que reconvertirlo a un numero de 12 bits y calcular la tensión a la que equivale.

Finalmente hemos conseguido crear el controlador. Lo hemos compilado y cargado en la placa, así como el ejecutable de la aplicación.
El problema es que no nos dio tiempo a comprobar que funcionaba todo conectando un voltaje al pin del ADC, pero el programa se ejecutaba correctamente hasta el punto en el que tenía que leer el registro de datos del ADC (comprobado con printf y printk), lo cual es esperanzador.

Según nos han contado,una vez haces un driver los demás siguen el mismo esquema y todo te es más fácil, así que esperamos avanzar rápido (ya que las interrupciones estaban practicamente programadas para "micro desnudo" y solo tenemos que adaptarlas con un driver al sistema operativo ).

Clase de controladores y "Sesión 7".

Hemos tenido la clase de controladores con nuestro tutor esta mañana.
Básicamente hay dos opciones para programar un micro:
1-"Desnudo", es decir, tocando directamente los registros necesarios y programando sin nada mas "debajo".
2-Utilizando un sistema operativo y programando lo necesario: drivers (en nuestro caso de ADC, interrupciones, y GPIO (in/out)) y la aplicación en sí.
La placa tiene instalado un sistema Linux básico sobre el que pretendemos cargar los driver que creemos.
La verdad es que es meterse en un mundo más difícil, pero nos parece bastante interesante entender como funcionan y relacionar todas las capas de un sistema.
Es posible que nos quite tiempo para hacer una practica con más "extras" pero creemos que merece la pena. Ha sido una clase con muchos conceptos y aún no hemos asimilado todos: un nuevo Makefile, cargar y registrar controladores, funciones del controlador, mensajes del kernel, como implementar con aplicaciones de usuario, etc... Tendremos que dedicarle tiempo.
Os dejo un par de capturas para ilustrar en que "nivel" se encuentran los controladores (basicamente entre el kernel y la plataforma):

Después de la clase, hemos ido al laboratorio y conseguido cargar un controlador de prueba.
Además también hemos descubierto que aún no podemos probar el ADC ni las interrupciones(que ya tenemos hechos) ya que hay que acceder a registros a los que solo tiene acceso el kernel (es decir, tendremos que acceder mediante los drivers) y por eso en la sesión anterior nos daba un "segmentation fault" al intentar ejecutar el programa en la placa.

Esperemos que merezca la pena la elección, por ahora estamos un poco perdidos con esto de los driver, pero todo es ponerse.

Reunión y Sesión 6

Hoy hemos tenido por un lado una reunión con nuestro tutor y la otra pareja que hace esta práctica, y por otro lado hemos estado 3 horas en el laboratorio.

En la reunión nos hemos dividido un poco el trabajo "básico" para avanzar más rápido y tener más tiempo para mejoras.
A nosotros nos ha tocado desarrollar el ADC, interrupciones y LEDs.
También nos ha comentado el tutor que en vez de hacer la memoria, podríamos hacer los "tutoriales" de cada parte del micro (parecidos a los que existen para el ColdFire) y hemos aceptado.
Así mismo también hemos decidido "mejorar" el sistema  programando sobre un sistema operativo (es decir, con drivers) en vez de programar sobre el "micro desnudo".
Hemos quedado las dos parejas mañana con nuestro tutor para que nos de una clase de 1h de lo que tenemos que saber sobre drivers. ha sido decisión nuestra el hacerlo con drivers para aprender más (pues ya nos hemos estado pegando con el "micro desnudo" hasta ahora, y lo hemos entendido bastante bien).
Espero que esta decisión no sea un lastre a lo largo del resto del semestre.
Por último, también hemos definido unos hitos más concretos para cada pareja.

Después hemos estado en el laboratorio unas 3 horas. Hemos completado el archivo relacionado con el ADC (ADC.c) y hemos investigado un poco acerca de como implementar lo relacionado con los LEDs (mediante los pins del GPIO (entrada/salida)).
Sin embargo hemos tenido 2 problemas:
1.- A la hora de compilar el problema completo nos ha dado un error en un punto en el que antes no nos lo daba (al llamar al método "lectura_adc()" como rutina de atención a la interrupción).
2.-Habiendo omitido el error anteriormente nombrado (poniendo le linea que daba error como comentario) hemos cargado el ejecutable en el micro, y al intentar ejecutarlo nos ha dado "segmentation fail".

Vamos a intentar subsanar estos errores en los días sucesivos, y mañana comentaremos como ha ido la clase de drivers.

Edit: El segmentation fail era por intentar acceder con aplicaciones de usuario a registros a los que solo tiene acceso el kernel. Tendremos que acceder a ellos con drivers.

Nota (Sesión 4 y 5)

Al final hemos conseguido que compile con ayuda de alvaro.
Habia que cambiar algunas cosas de programación que no sabiamos.

Sesión 4 y 5

Esta semana hemos venido 2 dias la laboratorio y hemos estado entendiendo y configurando las interrupciones y los timer.
La verdad es que nos ha costado entender como funcionaba todo.
Nos hemos ayudado de parte de un código para interrupciones  que aparecía en un foro de ARM.
La mayoría del tiempo hemos estado intentando entender el cógido y pensando como escribir el nuestro.
También nos ha quitado bastante tiempo buscar y entender los registros de configuración.

A día de hoy hemos conseguido aclarar casi todas las dudas que teníamos y hemos dejado el programa bastante estructurado (aun que nos sigue dando algún error de compilación y por tanto no hemos probado aún que funcione).
La verdad es que esta semana le hemos dedicado mucho tiempo a la asignatura, pero espero que la fluidez que hemos cogido en configurar (y buscar en la documentación) registros y programar nos ayude a ir mas rápido en los días sucesivos.