10 Respuestas Última respuesta el Aug 27, 2015 7:30 AM por fernando@info.unlp.edu.ar

    Almacenamiento y programa (sketch) Arduino

    fernando@info.unlp.edu.ar

      Estimados,

       

      En

      http://www.intel.la/content/www/xl/es/do-it-yourself/galileo-board-block-diagram.html?_ga=1.21718072.244337204.1431977719

      y en varios documentos de Galileo se indica:

      "

      Storage Options

      • 8 Mbyte Legacy SPI Flash to store firmware (bootloader) and the latest sketch
        • Between 256 Kbytes and 512 Kbytes dedicated for sketch storage

      "

      ¿Alguien sabe por qué están documentados esos límites? Si no entiendo mal esa información, el mínimo disponible sería de 256KB y el máximo de 512KB. Sin embargo, no consigo compatibilizar estos límites con:

      a) Los 8 MB almacenan el bootloader, que nunca tiene (o "tendría") un sketch... ¿por qué almacenarlo allí? Si no entiendo mal, los 8 MB tienen el Linux mínimo y en toda la documentación que he leído no hay ninguna forma de hacer persistente un programa (sketch) a menos que se inicie desde una tarjeta SD, con lo que tampoco se usaría el espacio de/para firmware.

      b) El sketch tiene que ser almacenado en RAM para ser ejecutado... ¿o no? En ese caso, la limitación sería de la RAM disponible, que son 256 MB.

       

      Muchas gracias por adelantado,

       

      Fernando.

        • Re: Almacenamiento y programa (sketch) Arduino
          gerardo.soria22

          Hola Fernando, bienvenido al foro, agradecemos tu interés por la plataforma Intel Galileo.

           

          Respondiendo a tu pregunta, los sketches Arduino necesitan almacenarse en la memoria flash para que el botón de reset (no el de reboot) pueda cumplir su función, ya que Galileo a diferencia de los Arduinos basados en AVR ejecutan los sketches como procesos de Linux, entonces, el botón de reset tiene que terminar el proceso actual del sketch (que esta en RAM) y después volverlo a cargar desde la flash.  De hecho se guardan en el directorio /sketch en el sistema de archivos de Linux, sin embargo, no se logra la persistencia del sketch por que cada que arranca la Galileo, carga una imagen limpia de Linux donde /sketch esta vacío, aunque físicamente exista el ultimo archivo cargado, Linux no lo ve hasta que cargas un nuevo sketch.

           

          Por otro lado, el límite que mencionas de la RAM no es del todo cierto ya que un sketch no puede ocupar todo el espacio, esto se debe a que Linux divide la memoria para procesos en el espacio de kernel y procesos en el espacio de usuario, por lo que el límite de utilización de un sketch en RAM es bastante menor.

           

          Espero la respuesta te sea de utilidad, te recuerdo que si tienes mas preguntas, no dudes en consultarlas por este medio. Saludos

            • Re: Almacenamiento y programa (sketch) Arduino
              fernando@info.unlp.edu.ar

              Hola Gerardo,

               

              Gracias por las respuestas, voy a ir probando y en todo caso reporto en este lugar para que quede documentado.

               

              Respecto de los límites, se agrega ahora lo que reporta el IDE (copiado del área de mensajes del IDE Arduino 1.6.0+Intel):

              "

              Sketch uses 61.687 bytes (0%) of program storage space. Maximum is 10.000.000 bytes.

              "

              que no es ni 512K no 256MB... veremos qué puedo ver experimentalmente.

               

              Gracias otra vez,

               

              Fernando.

              • Re: Almacenamiento y programa (sketch) Arduino
                fernando@info.unlp.edu.ar

                Gerardo Soria wrote:

                 

                Respondiendo a tu pregunta, los sketches Arduino necesitan almacenarse en la memoria flash para que el botón de reset (no el de reboot) pueda cumplir su función, ya que Galileo a diferencia de los Arduinos basados en AVR ejecutan los sketches como procesos de Linux, entonces, el botón de reset tiene que terminar el proceso actual del sketch (que esta en RAM) y después volverlo a cargar desde la flash.  De hecho se guardan en el directorio /sketch en el sistema de archivos de Linux, sin embargo, no se logra la persistencia del sketch por que cada que arranca la Galileo, carga una imagen limpia de Linux donde /sketch esta vacío, aunque físicamente exista el ultimo archivo cargado, Linux no lo ve hasta que cargas un nuevo sketch.

                 

                 

                No termino de entender la relación entre la memoria flash y el sistema de archivos del Linux que ejecuta la placa, incluyendo esto que mencionas del almacenamiento en /sketch. Más específicamente: no (me) queda claro cómo se "montaría" la memoria flash como parte del sistema de archivos de Linux de manera tal que lo almacenado en /sketch se vuelva a cargar desde la flash tal como mencionas que se hace cuando se utiliza el botón de reset.

                 

                Más aún, algunos detalles de cantidades o tamaños por ahora me parecen inconsistentes o por lo menos no le encuentro explicación:

                a)

                root@clanton:/# cd /

                root@clanton:/# du -sm

                12      .

                con esto, du está reportando 12 MB de almacenamiento utilizado por el sistema de archivos, que es más de los 8MB de flash, y que efectivamente no tiene relación con

                 

                b) Un sketch del cual el IDE reporta

                Sketch uses 8.059.209 bytes (80%) of program storage space. Maximum is 10.000.000 bytes.

                en realidad este "storage" no es el del sistema de archivos, porque

                 

                root@clanton:/# cd /sketch/

                root@clanton:/sketch# ls -l

                -rwxr--r--    1 root     root         58804 May 23  2015 sketch.elf

                 

                aunque hay unos datos interesantes con respecto a esto:

                     1) lo que se almacena en el sistema de archivos no es el .ino (algo que podríamos sospechar) sino el .elf creado a partir del .ino, claro.

                     2) la parte de código del sketch es bastante sencilla, sin embargo el .ino tiene la declaración

                          unsigned long int times[2000000];   // 2.000.000 de unsigned long int

                         que podemos asumir sin mucho problema que es la que se lleva la gran mayoría de los 8.059.209 bytes reportados por el IDE

                     3) No soy un experto, pero supongo que el .elf es el que contiene las indicaciones para crear el área de datos para el array sin necesidad de tener una correspondencia uno a uno de los bytes del archivo .elf respecto de lo que efectivamente estará en memoria. En este punto tenemos 3 tipos de elementos que se almacenan: el .ino (usado por el IDE), el .elf  (creado por el IDE a partir del .ino y enviado a la placa en la carga o "subida") y lo que efectivamente es el proceso en RAM que ejecuta Linux (creado a partir del .elf anterior). Como es de esperar, ninguna de las tres cosas tiene la misma longitud (formatos/contenidos/usos diferentes).

                 

                c) De lo que reporta el IDE como límite de 10.000.000 bytes de "program storage space", queda un gran espacio "disponible" respecto de los 256 MB (muy grande, de hecho). No creo que se limite a Galileo en cuanto a usar solamente 10MB del total para el único sketch que se ejeucuta desde el IDE de Arduino (no hay otra posibilidad desde/en Arduino). Ni bien se me ocurra algún experimento al respecto, comento los resultados, que seguramente tendrá relación con

                 

                Gerardo Soria wrote:

                ...

                Por otro lado, el límite que mencionas de la RAM no es del todo cierto ya que un sketch no puede ocupar todo el espacio, esto se debe a que Linux divide la memoria para procesos en el espacio de kernel y procesos en el espacio de usuario, por lo que el límite de utilización de un sketch en RAM es bastante menor.

                 

                 

                Donde por ahora es complicado para mí ver/saber/entender qué es "del todo cierto y qué no, sobre todo con tantos valores de límites todos diferentes (256K-512KB, 10.000.000, "sketch en RAM es bastante menor", etc.).

                 

                Creo que es todo por ahora,

                 

                Fernando.

                • Re: Almacenamiento y programa (sketch) Arduino
                  fernando@info.unlp.edu.ar

                  Hola Gerardo,

                  Gerardo Soria escribió:

                   

                  Respondiendo a tu pregunta, los sketches Arduino necesitan almacenarse en la memoria flash para que el botón de reset (no el de reboot) pueda cumplir su función, ya que Galileo a diferencia de los Arduinos basados en AVR ejecutan los sketches como procesos de Linux, entonces, el botón de reset tiene que terminar el proceso actual del sketch (que esta en RAM) y después volverlo a cargar desde la flash.

                  Todo indica que la flash no interviene más que en el proceso de inicio de Galileo y luego es todo manejado por el sistema Linux ejecutándose sobre/utilizando un

                  ramfs, con lo que la flash no es utilizada de ninguna manera durante la ejecución de Galileo una vez completado el proceso inicio. Toda la información que pude encontrar apunta a eso, básicamente por:

                  • La única forma de hacer que un sketch sea persistente es iniciando desde una memoria SD:

                            the galileo forget the sketch after power off-o... | Intel Communities

                            Maybe a silly question... | Intel Communities

                            Si se usara la flash no habría inconvenientes para que el sketch sea "automáticamente" o "metodológicamente" persistente (perdón por las comillas, pero si explico mucho, seguramente confundiré).

                            Hay varias secciones en las que se explica que los procedimientos de acceso a la flash no son sencillos, ni parecen orientados a ser hechos "regularmente", solamente para casos excepcionales. El propio proceso de actualización del firmware de Galileo implica usar un programa externo para hacerlo, no desde la placa misma ni desde el IDE con el que se programa (crea y envía el sketch a la placa). En ningún caso hay información para acceso a la flash desde un sketch o desde Linux ejecutándose en la placa.

                   

                  Gerardo Soria escribió:

                   

                  De hecho se guardan en el directorio /sketch en el sistema de archivos de Linux, sin embargo, no se logra la persistencia del sketch por que cada que arranca la Galileo, carga una imagen limpia de Linux donde /sketch esta vacío, aunque físicamente exista el ultimo archivo cargado, Linux no lo ve hasta que cargas un nuevo sketch.

                   

                  Efectivamente, el sketch de Arduino (o el .elf que se crea a partir del sketch) se almacena en el directorio /sketch, pero ese directorio no tiene nada una vez que se hace reboot ni está relacionado de ningnuna manera con la memoria flash (o ninguna forma documentada que yo haya encontrado, al menos).

                   

                  Sobre los límites/cantidad de bytes de un sketch, todavía no he probado nada específico, pero efectivamente no tiene mucho que ver con 256-512 KB. De hecho, no hay nada en ninguna parte al respecto, solamente algunos enlaces como el que está en el primer post. Además, vi que en

                  Intel® Galileo Boards and Kits

                  User Guide - Date: March 2014

                  http://www.intel.com/support/galileo/sb/CS-035225.htm

                  lo de los límites para un sketch no aparece, ni está relacionado con la flash de ninguna manera, y sí aparece mencionada/documentada la memoria flash de 8 MB, claro.

                   

                  Saludos,

                   

                  Fernando.

                  1 de 1 personas indicaron que les resultó útil
                    • Re: Almacenamiento y programa (sketch) Arduino
                      gerardo.soria22

                      Hola Fernando, me alegro que sigas investigando sobre tu duda, seguramente le será de utilidad a mas personas, yo por mi parte estuve explorando por los foros de la comunidad en Inglés y me encontré con una discusión en donde mencionan varias cosas interesantes, por ejemplo: que todas las utilerías relacionadas con los sketches (en su mayoria scripts de shell) se encuentran instaladas en /opt/cln/galileo. La segunda cosa interesante es que uno de esos scripts, específicamente sketch-setup.sh, es el que limita el almacenamiento del sketch a 256 KB. Revisando personalmente el contenido del script me encontré con lo siguiente:

                       

                      #!/bin/sh                                                                                                                      
                      #Krzysztof.M.Sywula@intel.com                                                                                                  
                                                                                                                                                     
                      SKETCH=/sketch                                                                                                                 
                      SKETCH_SIZE=256 #KB                                                                                                            
                      ERASE_SIZE=32 #KB                                                                                                              
                      IMAGE=/opt/cln/galileo/jffs2.bin                                                                                               
                      DEVICE=/dev/mtdblock0                                                                                                          
                                                                                                                                                     
                      start()                                                                                                                        
                      {                                                                                                                              
                              dd if=$IMAGE of=$DEVICE                                                                                                
                              mount -t jffs2 $DEVICE $SKETCH                                                                                         
                      }                                                                                                                              
                                                                                                                                                     
                      stop()                                                                                                                         
                      {                                                                                                                              
                              umount $SKETCH                                                                                                         
                              dd if=$DEVICE of=$IMAGE                                                                                                
                      }     
                       
                      setup()                                                                                                                        
                      {                                                                                                                              
                              ulimit -c unlimited                                                                                                    
                              modprobe mtdram total_size=$SKETCH_SIZE erase_size=$ERASE_SIZE                                                         
                              modprobe mtdchar                                                                                                       
                              modprobe mtdblock                                                                                                      
                              mkdir -p $SKETCH                                                                                                       
                                                                                                                                                     
                              # IF IMAGE DOES NOT EXIST - CREATE ONE                                                                                 
                              test -f $IMAGE || mkfs.jffs2 --pad=$(($SKETCH_SIZE * 1024)) -r /tmp --eraseblock=$ERASE_SIZE -o $IMAGE                 
                      }                                                                                                                              
                                                                                                                                                     
                      usage()                                                                                                                        
                      {                                                                                                                              
                              echo "Use: $1 [start/stop]"                                                                                            
                              exit 1                                                                                                                 
                      }  
                       
                      main()                                                                                                                         
                      {                                                                                                                              
                              echo $1                                                                                                                
                              if [ "x$1" = "xstart" ]; then                                                                                          
                              #       setup                                                                                                          
                              #       start                                                                                                          
                                      mkdir -p /sketch                                                                                               
                              elif [ "x$1" = "xstop" ]; then                                                                                         
                              #       stop 
                              else                                                                                                                   
                                      usage $0 
                              fi
                      }
                          
                      main "$@"
                      
                      
                      

                       

                      En donde efectivamente, nos encontramos en la línea 5 lo que parece ser el límite de 256 KB para el almacenamiento del sketch, así que en teoría modificando este parámetro puedes obtener mas espacio si así lo requieres, ya es cuestión de realizar las pruebas correspondientes para ver que es lo que ocurre, también podría ser interesante encontrar el valor máximo que soporta éste parámetro sin entrar en conflicto con el IDE Arduino o con la estabilidad del sistema.

                       

                      Aquí te dejo el link de la discusión original (en inglés) por si quieres darle un vistazo. Saludos.

                      Start sketch from Linux | Intel Communities

                        • Re: Almacenamiento y programa (sketch) Arduino
                          fernando@info.unlp.edu.ar

                          Muchas gracias, Gerardo, tengo para mirar estas cosas ahora y veo si saco algo más sólido.

                           

                          Fernando.

                          • Re: Almacenamiento y programa (sketch) Arduino
                            fernando@info.unlp.edu.ar

                            Estimado,

                             

                            Solamente para "cerrar" un poco esto, ahora que miré algunas cosas más:

                            1) El script sketch-setup parece que quedó de alguna versión anterior de yocto, porque al menos lo que necesitaría para ejecutar algunas de las operaciones más importantes, es decir

                            IMAGE=/opt/cln/galileo/jffs2.bin

                            DEVICE=/dev/mtdblock0

                            no existe en "ninguna" opción de arranque (con o sin memoria SD). En todos los casos de arranque (con o sin memoria SD), el contenido de /opt/cln/galileo/ no incluye jffs2.bin, ni /dev contiene mtdclock0 con lo cual los comandos que dependen de ellos fallarían (o no se ejecutaron, como en el caso del  mkfs.jffs2, que hubiera generado uno de ellos).

                             

                            2) Aunque ese script (skectch-setup) está mencionado en la discusión en inglés, esa discusión no aclara en este sentido, es decir en cuanto a qué hace o cómo impone límites o cómo arranca un sketch (o si lo hace, no lo vi, solamente menciona que el script existe y que impone límites). De hecho, se mencionan cosas que luego se corrijen, algo usual en un foro, claro, pero no respecto a este script en particular.

                             

                            3) Todo parece indicar que el arranque y reinicio de un sketch "dependerían finalmente" de los únicos dos ejecutables binarios (es decir no shelll scripts) en /opt/cln/galileo, que son

                            clloader

                            galileo_sketch_reset

                            y quizás esos sí impongan límites pero no lo puedo corroborar ahora mismo.

                             

                            Respecto de la pregunta original, en breve envío un post más, también como para "cerrar" al menos de mi lado el intercambio y reportar lo que puedo "más o menos" corroborar al día de hoy.

                             

                            Fernando.

                      • Re: Almacenamiento y programa (sketch) Arduino
                        fernando@info.unlp.edu.ar

                        fernando@info.unlp.edu.ar wrote:

                         

                        Estimados,

                         

                        En

                        http://www.intel.la/content/www/xl/es/do-it-yourself/galileo-board-block-diagram.html?_ga=1.21718072.244337204.1431977719

                        y en varios documentos de Galileo se indica:

                        "

                        Storage Options

                        • 8 Mbyte Legacy SPI Flash to store firmware (bootloader) and the latest sketch
                          • Between 256 Kbytes and 512 Kbytes dedicated for sketch storage

                        "

                        ¿Alguien sabe por qué están documentados esos límites? Si no entiendo mal esa información, el mínimo disponible sería de 256KB y el máximo de 512KB. Sin embargo, no consigo compatibilizar estos límites con:

                        a) Los 8 MB almacenan el bootloader, que nunca tiene (o "tendría") un sketch... ¿por qué almacenarlo allí? Si no entiendo mal, los 8 MB tienen el Linux mínimo y en toda la documentación que he leído no hay ninguna forma de hacer persistente un programa (sketch) a menos que se inicie desde una tarjeta SD, con lo que tampoco se usaría el espacio de/para firmware.

                        b) El sketch tiene que ser almacenado en RAM para ser ejecutado... ¿o no? En ese caso, la limitación sería de la RAM disponible, que son 256 MB.

                         

                        Muchas gracias por adelantado,

                         

                        Fernando.

                         

                        Respondo a mi propio post solamente para comentar lo que efectivamente pude mirar y concluyo a partir de lo poco que he hecho y leído al respecto:

                        1. La Legacy SPI flash no parece tener ninguna relación con almacenamiento de sketch(es), sino que se utiliza solamente para almacenar firmware (bootloader). Siempre que se menciona la persistencia de un sketch se indica el requerimiento de una memoria SD para almacenarlo, así que en principio la única forma de almacenar persistentemente un sketch es en memoria SD, lo que necesariamente (al menos en principio) descarta la posibilidad de almacenamiento en la Legacy SPI flash.
                        2. Por lo anterior, nada de esa memoria Legacy SPI flash, que es limitada, impondría límites a ningún sketch que se ejecute.
                        3. Como bien indica Gerardo, afirmar que el límite de requerimiento para un sketch es 256MB no es del todo correcto porque claramente no está toda la RAM disponible solamente para un sketch, pero el límite al menos por ahora no parece ser diferente que el de cualquier otro proceso que almacene en el sistema de archivos y se ejecute en Galileo. Claramente, el almacenamiento (y por lo tanto su posible límite) dependerá de la disponibilidad o no de memoria SD.
                        4. El almacenamiento del sketch será la RAM si no se tiene memoria SD o la memoria SD si se ha arrancado el sistema con esa memoria en la placa. En todos los casos, la ubicación será la misma: /sketch/sketch.elf. Claramente, sin SD el sketch no será persistente, por lo que habrá que cargarlo desde el IDE para que se ejecute después de haber desconectado la alimentación a la placa.

                         

                        Saludos,

                         

                        Fernando.