AnsweredAssumed Answered

Debugging code from RAM

Question asked by mohan.sivakumar on Dec 2, 2014
Latest reply on Dec 2, 2014 by Clive One
Hi,
I am developing an application for STM32F427 that runs from RAM using Keil. The bootloader application moves the code to ram and starts the execution, so execution is not an issue. But I am not able to load/debug the code using Keil. When I try to load it, it throws the error message "No algorithm found for address <start address>-<end address>. I read this manual http://www.keil.com/support/man/docs/ulinkpro/ulinkpro_su_newalgorithms.htm and now the error message is gone but, the operation freezes and timesout during erase. Has anyone tried it before? Here is the code I wrote for the programming algorithm.

/***********************************************************************/
/*  This file is part of the ARM Toolchain package                     */
/*  Copyright (c) 2010 Keil - An ARM Company. All rights reserved.     */
/***********************************************************************/
/*                                                                     */
/*  FlashDev.C:  Flash Programming Functions adapted                   */
/*               for New Device 256kB Flash                            */
/*                                                                     */
/***********************************************************************/
 
#include "..\FlashOS.H"        // FlashOS Structures
 
/*
   Mandatory Flash Programming Functions (Called by FlashOS):
                int Init        (unsigned long adr,   // Initialize Flash
                                 unsigned long clk,
                                 unsigned long fnc);
                int UnInit      (unsigned long fnc);  // De-initialize Flash
                int EraseSector (unsigned long adr);  // Erase Sector Function
                int ProgramPage (unsigned long adr,   // Program Page Function
                                 unsigned long sz,
                                 unsigned char *buf);
 
   Optional  Flash Programming Functions (Called by FlashOS):
                int BlankCheck  (unsigned long adr,   // Blank Check
                                 unsigned long sz,
                                 unsigned char pat);
                int EraseChip   (void);               // Erase complete Device
      unsigned long Verify      (unsigned long adr,   // Verify Function
                                 unsigned long sz,
                                 unsigned char *buf);
 
       - BlanckCheck  is necessary if Flash space is not mapped into CPU memory space
       - Verify       is necessary if Flash space is not mapped into CPU memory space
       - if EraseChip is not provided than EraseSector for all sectors is called
*/
 
 
/*
 *  Initialize Flash Programming Functions
 *    Parameter:      adr:  Device Base Address
 *                    clk:  Clock Frequency (Hz)
 *                    fnc:  Function Code (1 - Erase, 2 - Program, 3 - Verify)
 *    Return Value:   0 - OK,  1 - Failed
 */
 
 
typedef volatile unsigned char    vu8;
typedef          unsigned char     u8;
typedef volatile unsigned short   vu16;
typedef          unsigned short    u16;
typedef volatile unsigned long    vu32;
typedef          unsigned long     u32;
 
#define M8(adr)  (*((vu8  *) (adr)))
#define M16(adr) (*((vu16 *) (adr)))
#define M32(adr) (*((vu32 *) (adr)))
 
 
 
 
int Init (unsigned long adr, unsigned long clk, unsigned long fnc) {
 
  /* Add your Code */
  return (0);                                  // Finished without Errors
}
 
 
/*
 *  De-Initialize Flash Programming Functions
 *    Parameter:      fnc:  Function Code (1 - Erase, 2 - Program, 3 - Verify)
 *    Return Value:   0 - OK,  1 - Failed
 */
 
int UnInit (unsigned long fnc) {
 
  /* Add your Code */
  return (0);                                  // Finished without Errors
}
 
 
/*
 *  Erase complete Flash Memory
 *    Return Value:   0 - OK,  1 - Failed
 */
 
int EraseChip (void) {
 
    int i;
    unsigned int *ptr = (unsigned int *)0x20000000;
    for (i = 0;i<0x30000/4;i++)
    {
        *ptr = 0;
        ptr++;
    }
    return (0);                                 // Finished without Errors
}
 
 
/*
 *  Erase Sector in Flash Memory
 *    Parameter:      adr:  Sector Address
 *    Return Value:   0 - OK,  1 - Failed
 */
 
int EraseSector (unsigned long adr) {
    unsigned int i;
    unsigned int cur_sector = adr/1024;
    unsigned int * sector_addr = (unsigned int *)(cur_sector*1024);
    for(i = 0;i<256;i++)
    {
        *sector_addr = 0;
        sector_addr++;
    }
    return (0);                                   // Finished without Errors
}
 
 
/*
 *  Program Page in Flash Memory
 *    Parameter:      adr:  Page Start Address
 *                    sz:   Page Size
 *                    buf:  Page Data
 *    Return Value:   0 - OK,  1 - Failed
 */
 
int ProgramPage (unsigned long adr, unsigned long sz, unsigned char *buf) {
 
   sz = (sz + 3) & ~3;                                   // Adjust size for Words
   
  while (sz) {
 
    M32(adr) = *((u32 *)buf);                           // Program Double Word
    if(M32(adr) != *((u32 *)buf))
    {
        return 1;
    }
    adr += 4;                                           // Go to next Word
    buf += 4;
    sz  -= 4;
  }
 
  return (0);                                // Finished without Errors
}

Outcomes