Tool/software:
How to Configuration Flash Memory on EK-TM4C1294XL,I want to divide my FLASH into Flash blocks to store Data address and access
Hi,
Each block is 16kB. Therefore, you can place your data at a 16kB boundary. Refer to the FlashProgram and FlashErase APIs to program and erase data in the flash.
Here is a simple example.
uint32_t pui32Data[2]; // // Erase a block of the flash. // FlashErase(0x800); // // Program some data into the newly erased block of the flash. // pui32Data[0] = 0x12345678; pui32Data[1] = 0x56789abc; FlashProgram(pui32Data, 0x800, sizeof(pui32Data));
Hi Charles Tsal
We have followed your example and referred to other articles you responded to
e2e.ti.com/.../sw-dk-tm4c129x-tm4c129-internal- memory-read-write
1.We have a problem here, which is how to observe my Flash location in the IDE of Code Composer Studio. We need to determine whether it is written correctly.
2.How to use Here is a simple example. Do you need to include a specific function library?
3.Is the Flash splitting method different between EK-TM4C1294XL and MSP430F2xx?
4.Does EK-TM4C1294XL need to define its own blocks or does the Flash in MSP430F2xx have Main Memory and Information Memory?
5.How to use EEPROM? Is it the same as Flash? I need to use Uart to write and read data.
HI Charles Tsai
1.I used the EEPROM sample program you provided and after running it, I used Memory Browser to observe the location of address 0x400 and found that the location of address 0x400 was not written to the EEPROM.
2.6KB EEPROM address 0x200 - 0x43C ??
HI Charles Tsai Thanks for your assistance
1.I have been able to run the example normally to write data to EEPROM and use Uart to read data from EEPROM.Refer example to e2echina.ti.com/.../ccs-ek-tm4c1294xl-eeprom But I want to write Data into 96 blocks using EEPROM, but the current program cannot write to 96 and can only write to 48 at most and read it back. I want to ask if there is a problem with my program or if I need to use another one. address
2.Is there any other TI tool that can help us view the location of the EEPROM and its data content?
3.I would like to ask if Variables can observe the address and value of my EEPROM.
//*****************************************************************************
//
// hello.c - Simple hello world example.
//
// Copyright (c) 2013-2020 Texas Instruments Incorporated. All rights reserved.
// Software License Agreement
//
// Texas Instruments (TI) is supplying this software for use solely and
// exclusively on TI's microcontroller products. The software is owned by
// TI and/or its suppliers, and is protected under applicable copyright
// laws. You may not combine this software with "viral" open-source
// software in order to form a larger program.
//
// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
// DAMAGES, FOR ANY REASON WHATSOEVER.
//
// This is part of revision 2.2.0.295 of the EK-TM4C1294XL Firmware Package.
//
//*****************************************************************************
#include <stdint.h>
#include <stdbool.h>
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/gpio.h"
#include "drivers/pinout.h"
#include "driverlib/pin_map.h"
#include "driverlib/rom.h"
#include "driverlib/rom_map.h"
#include "driverlib/sysctl.h"
#include "driverlib/uart.h"
#include "utils/uartstdio.h"
#include "driverlib/eeprom.h"
#define j 48 // only 48
//*****************************************************************************
//
//! \addtogroup example_list
//! <h1>Hello World (hello)</h1>
//!
//! A very simple ``hello world'' example. It simply displays ``Hello World!''
//! on the UART and is a starting point for more complicated applications.
//!
//! Open a terminal with 115,200 8-N-1 to see the output for this demo.
//
//*****************************************************************************
//*****************************************************************************
//
// System clock rate in Hz.
//
//*****************************************************************************
uint32_t g_ui32SysClock;
int i;
//*****************************************************************************
//
// The error routine that is called if the driver library encounters an error.
//
//*****************************************************************************
#ifdef DEBUG
void
__error__(char *pcFilename, uint32_t ui32Line)
{
}
#endif
//*****************************************************************************
//
// Configure the UART and its pins. This must be called before UARTprintf().
//
//*****************************************************************************
void
UARTSend(const uint8_t *pui8Buffer, uint32_t ui32Count)
{
//
// Loop while there are more characters to send.
//
while(ui32Count--)
{
//
// Write the next character to the UART.
//
MAP_UARTCharPutNonBlocking(UART0_BASE, *pui8Buffer++);
}
}
void
ConfigureUART(void)
{
//
// Enable the GPIO Peripheral used by the UART.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
//
// Enable UART0
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Configure GPIO Pins for UART mode.
//
MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Initialize the UART for console I/O.
//
UARTStdioConfig(0, 115200, g_ui32SysClock);
}
//*****************************************************************************
//
// Print "Hello World!" to the UART on the Intelligent UART Module.
//
//*****************************************************************************
int
main(void)
{
//
// Run from the PLL at 120 MHz.
// Note: SYSCTL_CFG_VCO_240 is a new setting provided in TivaWare 2.2.x and
// later to better reflect the actual VCO speed due to SYSCTL#22.
//
g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_240), 120000000);
//
// Configure the device pins.
//
PinoutSet(false, false);
//
// Enable the GPIO pins for the LED D1 (PN1).
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1);
//
// Initialize the UART.
//
ConfigureUART();
//
// Hello!
//
//
// We are finished. Hang around flashing D1.
//
while(1)
{
uint32_t e2block;
uint32_t ui32EEPROMInit;
uint32_t pui32Data[j];
uint32_t pui32Read[j];
//
// Enable the EEPROM module.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_EEPROM0);
//
// Wait for the EEPROM module to be ready.
//
while(!SysCtlPeripheralReady(SYSCTL_PERIPH_EEPROM0))
{
}
//
// Wait for the EEPROM Initialization to complete
//
ui32EEPROMInit = EEPROMInit();
//
// Check if the EEPROM Initialization returned an error
// and inform the application
//
if(ui32EEPROMInit != EEPROM_INIT_OK)
{
while(1)
{
}
}
//
// Program some data into the EEPROM at address 0x400.
//
SysCtlDelay(50000000);
for(i=0;i<j;i++) {
pui32Data[i] = (i + 1) * 0x11111111; //
};
EEPROMProgram(pui32Data,0x400, sizeof(pui32Data)); //0x17FC
EEPROMRead(pui32Read, 0x400, sizeof(pui32Read));
for (i=0;i<j;i++) {
UARTprintf("number: %d\n", i );
UARTprintf("Data read from EEPROM: %x\n", pui32Read[i]); //
SysCtlDelay(30000000);
};
//UARTprintf("Data read from EEPROM SIze: %d\n",EEPROMSizeGet());
}
}
HI Charles Tsai:
1.The definition program problem you mentioned has been tested and it can only work if it is J input to a 48 MCU.If the MCU exceeds 48, for example, 50, it will not operate. The waveforms of my program and oscilloscope are as shown below.
2.I would like to ask if the positions will be automatically sorted. I refer to Compiler/EK-TM4C1294XL: How to read two consecutive locations of EEPROM into a structure. This article found that EEPROM_ADDRESS needs to be defined starting from 0x0000 and the offset will be increased each time. I want to ask if it is necessary. Define 96 addresses from (0x000...0x095) or define one for every four addresses (0x000....0x17c)
Instead of using (0x400) directly for automatic sorting, I tried to use his method but it still failed.
Hi,
EEprom offset address 0x400 corresponds to block #16. EEprom address 0xC80 corresponds to block #50 and address 0x1800 corresponds to block #96.
I use the below code to do some writes to EEprom and single step the code and I'm getting correct data.
// // Program some data into the EEPROM at address 0x400. // pui32Data[0] = 0x12345678; pui32Data[1] = 0x56789abc; EEPROMProgram(pui32Data, 0x400, sizeof(pui32Data)); // // Read it back. // EEPROMRead(pui32Read, 0x400, sizeof(pui32Read));
pui32Data[0] = 0x11223344; pui32Data[1] = 0x55667788; EEPROMProgram(pui32Data, 0xc80, sizeof(pui32Data)); // // Read it back. // EEPROMRead(pui32Read, 0xc80, sizeof(pui32Read));
pui32Data[0] = 0xAABBCCDD; pui32Data[1] = 0xDEADBEEF; EEPROMProgram(pui32Data, 0x1800, sizeof(pui32Data)); // // Read it back. // EEPROMRead(pui32Read, 0x1800, sizeof(pui32Read));
Refer to the datasheet on the organization of EEprom. There are 96 blocks and each block is 16 words or 64 bytes. Each word is equal to 4 bytes.
8.2.4.1 Functional Description
The EEPROM module provides a well-defined register interface to support accesses to the EEPROM
with both a random access style of read and write as well as a rolling or sequential access scheme.
A protection mechanism allows locking EEPROM blocks to prevent writes under a set of
circumstances as well as reads under the same or different circumstances. The password model
allows the application to lock one or more EEPROM blocks to control access on 16-word boundaries.
Blocks
There are 96 blocks of 16 words each in the EEPROM. These are readable and writable as words.
Bytes and half-words can be read, and these accesses do not have to occur on a word boundary.
The entire word is read and any unneeded data is simply ignored. The EEPROM blocks are writable
only on a word basis. To write a byte, it is necessary to read the word value, modify the appropriate
byte, and write the word back.
Each block is addressable as an offset within the EEPROM, using a block select register. Each
word is offset addressable within the selected block.
HI Charles Tsai:
1.We have some data that is transmitted in 1byte. I would like to ask if eeprom can write data in 1byte instead of word.
2.in the example, only 16 hexadecimal numbers are used, which means that only 16 words are used. I would like to ask Can 16 hexadecimal 64 bytes be used?
For example, uint32_t change to uint8 or Could you please tell me which of the following 3 definitions are used?
1.
pui32Data[0] = 0xAA; // 1byte
pui32Data[1] = 0xBB; // 2byte
.
.
.
pui32Data[62] = 0xEE;// 63byte
pui32Data[63] = 0xFF;// 64byte
or
2.
pui32Data[0] = 0xAAAAA........AAA; //32bytes
pui32Data[1] = 0xBBBBB........BBB; //32bytes
or
3.
pui32Data[0] = 0xAAAAA..................AAA; //64bytes
