int main() {
UINT8 pinvalue;
DRVCTRL example;
drvinit(example);
pinvalue = gpio_read_pin(&example,PORTD, 1);
init_gpio(DRV_PORTB);
init_gpio(DRV_PORTD);
/* I would really like to be able to implement a
function where I could just pass a pointer to a
function that would be called when the timer
overflowed, like the one below.
*/
/* schedulePeriodicTask(timePeriod,&task); */
init_timer();
init_usart0();
init_eeprom();
while (1) {
;
}
}
void initALL()
{
int flag;
/*initialize the clocks and basic peripherals*/
RCC_SYSCLKConfig(RCC_SYSCLKSource_HSE); //set the SYSCLOCK
RCC_HCLKConfig(RCC_SYSCLK_Div1); //set the SYSCLOCK
initUSART(USART1); //Initialize USART1
//initUSART(USART3); //Initialize USART3
ADC_Initialize(); //Initialize ADCs
I2C_LowLevel_Init(I2C1, 100000, 0); //Initialize I2C1 bus @ 100Khz speed
I2C_LowLevel_Init(I2C2, 100000, 0); //Initialize I2C1 bus @ 100Khz speed
initLED(); //Initialize LEDs D3 D4
initGPIO(); //initialize PB2 and PB12 used as external GPIO
//InitTimer(); //Initialize Timer
/* Initialize and configure RF related functions */
initRFconfpin(); // Init the GPIO PB15 used as CONFIG PIN with the RADIOCRAFT module
//Configure the RF BOARD to standard value (configfile.c): NETID 2.2.2.2 Channel 2
if (readintvalue(FLAG_EEPROM)!=0xf0f0f0f0){ //flag eeprom = f0f0f0f0 only when already initialized
flag= ConfigureRF();
close_RFconfig();
if (flag==ERROR)
printf("Configuration Failed");
else
printf("Configuration RF ok");
}
else
close_RFconfig();
/* Initialize EEPROM VALUES*/
if (readintvalue(FLAG_EEPROM)!=0xf0f0f0f0){ //flag eeprom = f0f0f0f0 only when already initialized
init_eeprom(); //Initialize eeprom
Receivedpackage.bytes[0]='$';
Receivedpackage.bytes[1]='V';
Receivedpackage.bytes[2]='x';
Receivedpackage.bytes[3]='x';
}
/*Initialize Sensors*/
init_acceler(); //initialize accelerometer
/* Initialize interrupts sources*/
EnRtcInter(); //Initialize RTC Interrupt Source
EnUsartInter(); //Enable the USART Interrupts
//EnPVDInter(); //Enable the power PVD
//EnExtInter(); //Initialize External Interrupt Source
//EnTimInterr(); //Initialize Timer Interrupt Source
}
int main (void)
{
// Read clock settings and update SystemCoreClock variable
SystemCoreClockUpdate();
// Enable and setup SysTick Timer for 1 ms
us_elapsed = 0;
SysTick_Config(SystemCoreClock / 1000);
// Turn on GPIO and IOCON blocks
Chip_GPIO_Init(LPC_GPIO);
Chip_IOCON_Init(LPC_IOCON);
// Disable buffering on stdout
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
// Initialize peripherals
usb_init();
Serial.begin(115200);
Debug.begin(115200);
fprintf(stderr, "Coretex M3 running at %ld MHz\r\n", (long) (SystemCoreClock / 1e6));
// Load eeprom
fprintf(stderr, "Opening eeprom file...");
init_eeprom();
fprintf(stderr, "Done!\r\n");
// Bind in NeoPixel display driver
//machineThread.machine.pDisplay = &neoPixel;
// Initialize
machineThread.setup(PIN_CONFIG);
firestep::threadRunner.setup(LED_PIN);
// Run over and over again
firestep::threadRunner.run();
return 0;
}
/*****************************************************************************
*
* flash_test - System Flash ROM diagnostics
*
* A destructive Flash ROM Read/Write test. Note that the area of Flash
* which is tested changes based on whether the diagnostic is being invoked
* from the System code or from the Factory code (can't write over MON960).
*
* This test basically does a Longword Address test to the Flash area.
*
*/
void flash_test(MENU_ARG arg)
{
ADDR start_addr = (ADDR)FLASH_ADDR; /* Original */
int i;
unsigned long *f_ptr = (unsigned long *)FLASH_ADDR;
int bytes_written = 0;
unsigned long flash_data;
char answer[20];
/* 10/31/00 */
int status;
init_eeprom();
printf("***********************************\n");
printf("*** WARNING ***\n");
printf("*** This test is destructive to ***\n");
printf("*** all contents of the FLASH! ***\n");
printf("***********************************\n");
printf("\nDo you wish to continue? (y/n)\n");
sgets(answer);
printf("\n\n");
if ((answer[0] != 'y') && (answer[0] != 'Y'))
return;
printf ("FLASH begins at 0x%X\n", FLASH_ADDR);
printf ("Total FLASH size = 0x%X\n\n", eeprom_size);
printf ("Checking FLASH ...\n");
if (check_eeprom(NO_ADDR, 0) == OK)
printf("FLASH is erased\n\n");
else
printf("FLASH is programmed between 0x%X and 0x%X\n\n",
eeprom_prog_first, eeprom_prog_last);
printf ("\nClearing Block Lock Bits... \n");
if(clear_all_lock_bits(NO_ADDR)==OK)
printf("Done!\n\n");
else
printf("Error!\n\n");
printf ("Erasing FLASH...\n");
if (erase_eeprom(NO_ADDR, 0) != OK)
printf("Error on erase_eeprom()\n\n");
else
printf("Done Erasing FLASH!\n\n");
(ADDR)start_addr = (ADDR)FLASH_BLK4_BASE_ADDR;
printf ("Writing Longword Data to FLASH...\n");
/* write to all of available Flash ROM. Don't do this thousands of times
since the Flash has only 100,000 write cycles in its lifespan */
while (bytes_written < (eeprom_size - RESERVED_AREA_SIZE)) {
flash_data = (unsigned long)start_addr;
for (i=0; i<TEST_BUF_LONGS; i++) {
flash_buffer[i] = flash_data; /* put address in buffer */
flash_data += 4; /* increment address */
}
if (write_eeprom (start_addr, (void *)flash_buffer, TEST_BUF_CHARS) != OK) {
printf("Error on write_eeprom()\n");
goto finish;
}
start_addr = (unsigned long)start_addr + TEST_BUF_CHARS;
bytes_written += TEST_BUF_CHARS;
}
printf ("Write Complete, Verifying Data...\n");
bytes_written = 0;
f_ptr = (unsigned long *)FLASH_BLK4_BASE_ADDR;
while (bytes_written < (eeprom_size - RESERVED_AREA_SIZE)) {
if (*f_ptr != (unsigned long)f_ptr) {
printf ("Data verification error at 0x%X\n", (unsigned long)f_ptr);
printf ("Expected 0x%X Got 0x%X\n", (unsigned long)f_ptr, *f_ptr);
goto finish;
}
f_ptr++;
bytes_written += 4;
}
printf ("Done Verifying Longword Data!\n\n");
printf ("Checking FLASH...\n");
if (check_eeprom(NO_ADDR, 0) == OK)
printf("FLASH is erased\n\n");
else
printf("FLASH is programmed between 0x%X and 0x%X\n\n",
eeprom_prog_first, eeprom_prog_last);
printf ("Erasing FLASH...\n");
if (erase_eeprom(NO_ADDR, 0) != OK)
printf("Error on erase_eeprom()\n\n");
else
printf("Done Erasing FLASH!\n\n");
printf ("Checking FLASH...\n");
if (check_eeprom(NO_ADDR, 0) == OK)
printf("FLASH is erased\n\n");
else
printf("FLASH is programmed between 0x%X and 0x%X\n\n",
eeprom_prog_first, eeprom_prog_last);
/* reinitialize variables */
bytes_written = 0;
start_addr = (ADDR)FLASH_BLK4_BASE_ADDR;
f_ptr = (unsigned long *)FLASH_BLK4_BASE_ADDR;
printf ("Writing Inverted Longword Data to FLASH...\n");
/* write to all of available Flash ROM. Don't do this thousands of times
since the Flash has only 100,000 write cycles in its lifespan */
while (bytes_written < (eeprom_size - RESERVED_AREA_SIZE)) {
flash_data = (unsigned long)start_addr;
for (i=0; i<TEST_BUF_LONGS; i++) {
flash_buffer[i] = ~flash_data; /* put address BAR in buffer */
flash_data += 4; /* increment address */
}
if (write_eeprom (start_addr, (void *)flash_buffer, TEST_BUF_CHARS) != OK) {
printf("Error on write_eeprom()\n");
goto finish;
}
start_addr = (unsigned long)start_addr + TEST_BUF_CHARS;
bytes_written += TEST_BUF_CHARS;
}
printf ("Write Complete, Verifying Data...\n");
bytes_written = 0;
while (bytes_written < (eeprom_size - RESERVED_AREA_SIZE)) {
if (*f_ptr != (~(unsigned long)f_ptr)) {
printf ("Data verification error at 0x%X\n", (unsigned long)f_ptr);
printf ("Expected 0x%X Got 0x%X\n", (~(unsigned long)f_ptr), *f_ptr);
goto finish;
}
f_ptr++;
bytes_written += 4;
}
printf ("Done Verifying Inverted Longword Data!\n\n");
printf ("Checking FLASH...\n");
if (check_eeprom(NO_ADDR, 0) == OK)
printf("FLASH is erased\n\n");
else {
printf("FLASH is programmed between 0x%X and 0x%X\n\n",
eeprom_prog_first, eeprom_prog_last);
}
printf ("Erasing FLASH...\n");
if (erase_eeprom(NO_ADDR, 0) != OK)
printf("Error on erase_eeprom()\n\n");
else
printf("Done Erasing FLASH!\n\n");
printf ("Checking FLASH...\n");
if (check_eeprom(NO_ADDR, 0) == OK)
printf("FLASH is erased\n\n");
else
printf("FLASH is programmed between 0x%X and 0x%X\n\n",
eeprom_prog_first, eeprom_prog_last);
/* 11/02/00 */
printf ("Setting Lock Bits for Blocks 0-3... \n");
if( (status = set_all_lock_bits() ) == OK )
printf("Done!\n");
else
printf("Error! status =0x%x\n", status);
finish:
_flushICache();
printf ("\nHit <CR> to Continue...\n");
(void)hexIn();
return;
}
int loadROM(fileBrowser_file* rom){
int ret = 0;
savestates_job = 0; //clear all pending save states
// First, if there's already a loaded ROM
if(hasLoadedROM){
// Unload it, and deinit everything
cpu_deinit();
eepromWritten = FALSE;
mempakWritten = FALSE;
sramWritten = FALSE;
flashramWritten = FALSE;
romClosed_RSP();
romClosed_input();
romClosed_audio();
romClosed_gfx();
closeDLL_RSP();
closeDLL_input();
closeDLL_audio();
closeDLL_gfx();
ROMCache_deinit();
free_memory();
#ifndef HW_RVL
ARAM_manager_deinit();
#endif
}
format_mempacks();
reset_flashram();
init_eeprom();
hasLoadedROM = TRUE;
#ifndef HW_RVL
ARAM_manager_init();
#endif
#ifdef USE_TLB_CACHE
TLBCache_init();
#else
tlb_mem2_init();
#endif
//romFile_init(rom);
ret = rom_read(rom);
if(ret){ // Something failed while trying to read the ROM.
hasLoadedROM = FALSE;
return ret;
}
// Init everything for this ROM
init_memory();
gfx_set_fb(xfb[0], xfb[1]);
if (screenMode == SCREENMODE_16x9_PILLARBOX)
gfx_set_window( 78, 0, 483, 480);
else
gfx_set_window( 0, 0, 640, 480);
gfx_info_init();
audio_info_init();
// control_info_init();
rsp_info_init();
romOpen_gfx();
// gfx_set_fb(xfb[0], xfb[1]);
romOpen_audio();
romOpen_input();
cpu_init();
if(autoSave==AUTOSAVE_ENABLE) {
switch (nativeSaveDevice)
{
case NATIVESAVEDEVICE_SD:
case NATIVESAVEDEVICE_USB:
// Adjust saveFile pointers
saveFile_dir = (nativeSaveDevice==NATIVESAVEDEVICE_SD) ? &saveDir_libfat_Default:&saveDir_libfat_USB;
saveFile_readFile = fileBrowser_libfat_readFile;
saveFile_writeFile = fileBrowser_libfat_writeFile;
saveFile_init = fileBrowser_libfat_init;
saveFile_deinit = fileBrowser_libfat_deinit;
break;
case NATIVESAVEDEVICE_CARDA:
case NATIVESAVEDEVICE_CARDB:
// Adjust saveFile pointers
saveFile_dir = (nativeSaveDevice==NATIVESAVEDEVICE_CARDA) ? &saveDir_CARD_SlotA:&saveDir_CARD_SlotB;
saveFile_readFile = fileBrowser_CARD_readFile;
saveFile_writeFile = fileBrowser_CARD_writeFile;
saveFile_init = fileBrowser_CARD_init;
saveFile_deinit = fileBrowser_CARD_deinit;
break;
}
// Try loading everything
int result = 0;
saveFile_init(saveFile_dir);
result += loadEeprom(saveFile_dir);
result += loadSram(saveFile_dir);
result += loadMempak(saveFile_dir);
result += loadFlashram(saveFile_dir);
saveFile_deinit(saveFile_dir);
switch (nativeSaveDevice)
{
case NATIVESAVEDEVICE_SD:
// if (result) menu::MessageBox::getInstance().setMessage("Found & loaded save from SD card");
if (result) autoSaveLoaded = NATIVESAVEDEVICE_SD;
break;
case NATIVESAVEDEVICE_USB:
// if (result) menu::MessageBox::getInstance().setMessage("Found & loaded save from USB device");
if (result) autoSaveLoaded = NATIVESAVEDEVICE_USB;
break;
case NATIVESAVEDEVICE_CARDA:
// if (result) menu::MessageBox::getInstance().setMessage("Found & loaded save from memcard in slot A");
if (result) autoSaveLoaded = NATIVESAVEDEVICE_CARDA;
break;
case NATIVESAVEDEVICE_CARDB:
// if (result) menu::MessageBox::getInstance().setMessage("Found & loaded save from memcard in slot B");
if (result) autoSaveLoaded = NATIVESAVEDEVICE_CARDB;
break;
}
}
return 0;
}
int main(void)
{
//! set the power reduction register to minimize current consumption
init_power_reduction();
//! set CPU clock to 32MHz and enables the DFLL32MHz
clock_init();
//! initialize the LCD module
init_lcd();
//! display all the segments in LCD
lcd_show_all();
//! initialize the GPIO pins
init_ioport();
//! initializes the UART
init_UART();
//! load the calibration data from flash
ADC_CalibrationValues_Load(&ADCA);
//! get the ADC offset value
get_offset();
//! initialize the ADC
init_ADC();
//! load the calibration value from eeprom
init_eeprom();
//! initilize RTC to external clock and 1 sec interrupt
rtc_init();
//! initilize the timer
init_timer();
while(1)
{
//! rtc_flag is set
if (rtc_flag == 1)
{
//! perform the calculation of metering paramters
calculate();
//for debugging
if(cover_open_flag ==1)
PORTD.OUTTGL = PIN3_bm;
//TCC1.CTRLA = ( TCC1.CTRLA & ~TC1_CLKSEL_gm ) | TC_CLKSEL_DIV64_gc;
TCC1.INTCTRLA = (TCC1.INTCTRLA & ~(TC1_OVFINTLVL_gm | TC1_ERRINTLVL_gm))|TC1_OVFINTLVL0_bm;
//! if power on detected
if(power_status_flag == POWER_ON_DETECTED)
{
//! change the clock frequency to 32MHz
CLKSYS_Prescalers_Config( CLK_PSADIV_1_gc, CLK_PSBCDIV_1_1_gc );
//! switch off the battery
PORTD.PIN4CTRL = PORT_OPC_WIREDANDPULL_gc;
//PORTD.OUTSET = PIN4_bm;
//! initialize gpio pins
init_ioport();
//! change the sleep mode to ideal sleep
SLEEP.CTRL = (SLEEP.CTRL & ~SLEEP_SMODE_gm)| SLEEP_SMODE_IDLE_gc;
//! enable ADC & Timer
ADC_Enable(&ADCA);
TCC1.CTRLA = ( TCC1.CTRLA & ~TC1_CLKSEL_gm ) | TC_CLKSEL_DIV64_gc;
//! initialize lcd module
init_lcd();
//! update power status flag
power_status_flag = POWERED_UP;
}
//! update the LCD display
lcd_disp_key();
tamper_check();
if( active_power[0] > max_demand )
{
max_demand = active_power[0];
}
//! check for calibration flag and proceed and call the appropriate calibration funtion
if(calibration_flag != 0)
{
//! checking the calibration flag for calibrating the date & time
if (calibration_flag == 1)
{ calibrate_time_date(); }
//! checking the calibration flag for calibrating the voltage
else if (calibration_flag == 2)
{ calibrate_voltage(); }
//! checking the calibration flag for calculating the offset value
else if (calibration_flag == 3)
{ calibrate_no_load(); }
//! checking the calibration flag for calculating the phase angle variation
else if (calibration_flag == 4)
{ calibrate_phase(); }
//! checking the calibration flag for calculating watt varition
else if (calibration_flag == 5)
{ calibrate_watt(); }
else if (calibration_flag == 6)
//! checking the calibration flag for calibrating the current
{ calibrate_current(); }
}
rtc_flag = 0;
__watchdog_reset();
}
//! checking the power_status, if power off is detected
else if(power_status_flag == POWER_OFF_DETECTED)
{
//! switch on the battery
PORTD.PIN4CTRL = PORT_OPC_WIREDAND_gc;
//PORTD.OUTCLR = PIN4_bm;
//! change the sleep mode to power save mode
SLEEP.CTRL = (SLEEP.CTRL & ~SLEEP_SMODE_gm)| SLEEP_SMODE_PSAVE_gc;
//! switch off the LCD
lcd_command(LCD_COMMAND,0x02);
//! change reset the gpio pin
facilitatePowersaving();
//! disable the ADC
ADC_Disable(&ADCA);
//! disable the timer
TCC1.CTRLA = ( TCC1.CTRLA & ~TC1_CLKSEL_gm ) | TC_CLKSEL_OFF_gc;
//! clear all the varilable used in for energy calculation
meter_flush();
//! reduce the cpu clock frequency to minimize power consumption
CLKSYS_Prescalers_Config( CLK_PSADIV_64_gc, CLK_PSBCDIV_1_1_gc );
//! update power status flag
power_status_flag = POWER_OFF;
__watchdog_reset();
}
//! goes to sleep
SLEEP.CTRL |= SLEEP_SEN_bm;
asm("sleep");
}
}
