jueves, 16 de febrero de 2017

PRACTICA # 11 DATA FLASH

OBJETIVO:
       Haremos uso de la memoria flash interna del MCU R5F563NB de la tarjeta de evaluación YRDKRX63N. Escribiremos 8 bytes dentro de la data flash y posteriormente los leeremos para visualizarlos en el debug en forma de array. Se mostrará que los datos son guardados con éxito a partir de la dirección de memoria 0x100000.
  • Se crearán rutinas de inicialización, verificación, borrado, escritura y lectura de la flash.

DESARROLLO:
  • Del RX63N Group User's Manual: Hardware pagina 1794 vemos la dirección y tamaño de la memoria de datos flash y sus bloques:

PASOS:
  • Creación de un proyecto:
1.- Abrir el software e2studio
2.- New/ C Project / Renesas RXC ToolChain


3.- Seleccionar el target R5F563NB, debug hardware Segger jLink, después next


4.- Seleccionar C/C++ Source file y por ultimo Finish.


5.- La estructura de archivos para el control de la data flash es la siguiente:


6.- Agregar en la sección de memoria (linker/Section) en las propiedades del proyecto RPFRAM y PFRAM

7.- Agregar en la sección de memoria (linker/user) en las propiedades del proyecto
-rom=PFRAM=RPFRAM


8.- La función main queda de la siguiente manera:

#define SIZEDATA 8
uint32_t address, g_ret;
uint8_t buf[SIZEDATA], i, read_buff[SIZEDATA];
void SR_DATA_FLASH(void);

void main(void)
{
            set_ipl( 0 );       // enable interrupts
            SR_Oscilador();     // configura oscilador a 96 Mhz
            SR_INIT_PORTS();    // inicializa puertos i/o
            SR_DATA_FLASH();    // inicializa data flash, escribe y lee de ejemplo

            while(1)
            {
                        __nop();
            }
}

9.- La función para la escritura y lectura utilizando la API flash queda como:

void SR_DATA_FLASH(void)
{
            R_FlashCodeCopy();
            /* After Data Flash Area is enabled, you can access Data Flash Memory */
            R_FlashDataAreaAccess(0xFFFF, 0xFFFF);
            /* Get beginning address of DF block */
            address = g_flash_BlockAddresses[BLOCK_DB0];
            /***************************/
            /* Check if block is blank */
            /***************************/
            g_ret = R_FlashDataAreaBlankCheck(address, BLANK_CHECK_ENTIRE_BLOCK);

            /************************/
            /* Erase our Flash area */
            /************************/
            /* NOTE: You can watch the flash memory erasing/writing with the E1/E20
             within HEW if you enable "Debug the program using the CPU
             re-write mode"  in the "System" tab of the
             "Configuration Properties" window when connecting */
            g_ret = R_FlashErase(BLOCK_DB0);

            /* Check for errors */
            if (g_ret != FLASH_SUCCESS)
            {
                        while (1)
                        {
                                    /* Error in demo. */
                        }
            }

            /* Check Blank Checking using both methods of input: address and
             block number */
            /* First try with address */
            g_ret = R_FlashDataAreaBlankCheck(address, BLANK_CHECK_ENTIRE_BLOCK);

            /* Should be FLASH_BLANK since it was just erased */
            if (g_ret != FLASH_BLANK)
            {
                        while (1)
                        {
                                    /* Error in demo. */
                        }
            }

            /* Now use block number */
            g_ret = R_FlashDataAreaBlankCheck(BLOCK_DB0, BLANK_CHECK_ENTIRE_BLOCK);

            /* Should be FLASH_BLANK since it was just erased */
            if (g_ret != FLASH_BLANK)
            {
                        while (1)
                        {
                                    /* Error in demo. */
                        }
            }

            buf[0] = 0x34;
            buf[1] = 0x12;
            buf[2] = 0x76;
            buf[3] = 0x64;
            buf[4] = 0x96;
            buf[5] = 0x16;
            buf[6] = 0x74;
            buf[7] = 0x54;

            /*****************************/
            /* Write our buffer to Flash */
            /*****************************/
            g_ret = R_FlashWrite(address, (uint32_t) buf, sizeof(uint8_t) * SIZEDATA);

            /* Check for errors */
            if (g_ret != FLASH_SUCCESS)
            {
                        while (1)
                        {
                                    /* Error in demo. */
                        }
            }

            /* Clear ret */
            g_ret = 0;

            /* Read back written area */
            for (i = 0; i < sizeof(uint8_t) * SIZEDATA; i++)
            {
                        read_buff[i] = *(uint8_t *) (address + i);
            }

            /* Verify */
            for (i = 0; i < sizeof(uint8_t) * SIZEDATA; i++)
            {
                        if (read_buff[i] != buf[i])
                        {
                                    while (1)
                                    {
                                               /* Error in demo. */
                                    }
                        }
                        LED4 = ON_;  // Success
            }

            /******************************************************************/
            /* More Blank Check tests, use debugger to see returned values    */
            /******************************************************************/
            /* Check Blank Checking using both methods of input: address and
             block number */
            /* First try with address */
            g_ret = R_FlashDataAreaBlankCheck(address, BLANK_CHECK_ENTIRE_BLOCK);

             /* Should return FLASH_NOT_BLANK (not blank) */
            if (g_ret != FLASH_NOT_BLANK)
            {
                        while (1)
                        {
                                    /* Error in demo. */
                        }
            }

             /* Now use block number */
             g_ret = R_FlashDataAreaBlankCheck(BLOCK_DB0, BLANK_CHECK_ENTIRE_BLOCK);

             /* Should return FLASH_NOT_BLANK (not blank) */
            if (g_ret != FLASH_NOT_BLANK)
            {
                        while (1)
                        {
                                    /* Error in demo. */
                        }
            }
}
  • Agregar código, compilar y debug:
1.- Bajar el código de:
--> Practica #11

2.- Compilar con el icono del martillo y debug con el icono del insecto:


RESULTADOS:


No hay comentarios.:

Publicar un comentario