/*
* Change data - single page
*
*/
uint32_t change_data_fmem(const __FMEM_SETT * const pSett, const __FMEM_DATA * const pData) {
__AT25DF_DATA hw_data;
// Addr rang test
if (test_addr_range(pSett, pData->addr) == FALSE_T) {
return eMEM_ADDR_ERROR;
}
// Capacity test
if ((pData->len > get_space_to_end_fmem(pSett, pData->addr)) || (pData->len == 0)) {
return eMEM_DATA_ERROR;
}
// One page test
if (pData->len > get_write_datalen(pSett, pData->addr)) {
return eMEM_DATA_ERROR;
}
// Change data - switch 1 -> 0
hw_data.addr.addr32 = convert_ext_addr_in_hw_addr(pSett, pData->addr);
hw_data.pBuff = pData->pBuff;
hw_data.len = pData->len;
// Write data
clear_wdt();
return program_page_at25df(&hw_data);
}
void checkKeyboard() {
uchar delayKeyb = 100; // valore di default
uchar KeybValue = 0;
uchar loopCounter = 0;
bool LOOP = true;
while (LOOP) {
clear_wdt();
// -- Leggiamo i dati dalla porta
if (loopCounter++ > 3) delayKeyb = 1; // Next wait più basso
delay_ms(delayKeyb);
KeybValue = readPortB47();
displayValues();
switch (KeybValue) {
case KEY_FUNC_UP:
if (++gcnFunc > FUNC_LAST) gcnFunc = 0;
continue;
case KEY_FUNC_DN:
if (--gcnFunc > FUNC_LAST) gcnFunc = FUNC_LAST; // non controlla il negativo. Quindi lavoro sull'assoluto.
continue;
case KEY_PULSE_UP:
if (fCONTINUOUS_KEY == false)
gcnPulse++; // ruota a 256
continue;
case KEY_PULSE_DN:
if (fCONTINUOUS_KEY == false)
gcnPulse--; // ruota a 256
continue;
// ---------------------------------------------------------------------------------
// Vale solo per misurare +Pulse e -Pulse.
// Quando questo è ON allora il numero dell'impulso viene ignorato e
// si procede ad una lettura continua. Come se fosse PosWAVE o NegWAVE.
// ---------------------------------------------------------------------------------
case KEY_CONTINUOUS:
LNtoggle_bool(fCONTINUOUS_KEY); // toggle bit
continue;
case KEY_SET_TMR0:
fSET_TMRx = true;
LOOP = false;
break;
default:
LOOP = false;
break;
} // end switch()
} // end While()
displayValues();
return;
}
void main()
{
__disable_interrupt();
init_core();
init_device();
init_wdt();
__enable_interrupt();
microrl_init (pointerMicrorl, &serprintf);
microrl_set_execute_callback (pointerMicrorl, execute);
microrl_set_complete_callback (pointerMicrorl, complet);
microrl_set_sigint_callback (pointerMicrorl, sigint);
init_app_settings();
print_revision();
DEBUG_PRINTF("FlashMem: %s %s\n\r",
get_family_desc_at25df(),
get_density_desc_at25df());
enable_default_lis3dh();
init_tasks();
init_reco_drift();
init_can_j1939();
DEBUG_PRINTF("\r\n\r\n");
while (1) {
if (pointerRingBuff->size(pointerRingBuff) > 0) {
const uint8_t data = pointerRingBuff->get(pointerRingBuff);
if (!get_proto_type()) {
microrl_insert_char (pointerMicrorl, data);
} else {
sdp_insert_char(data);
}
}
poll_can_msg();
run_tasks();
clear_wdt();
}
}
/*
* Erase memory
*
*/
uint32_t erase_memory_fmem(const __FMEM_SETT * const pSett) {
__AT25DF_ADDRESS hw_addr;
__eAt25DF_BLOCK block;
uint32_t err;
uint32_t int_addr;
const bool_t aligment64k = (pSett->start_addr % AT25DF_SECTOR_SIZE_64)
? FALSE_T : TRUE_T;
const bool_t aligment32k = (pSett->start_addr % AT25DF_SECTOR_SIZE_32)
? FALSE_T : TRUE_T;
err = eMEM_NOT_AVAILABLE;
int_addr = 0;
while (test_addr_range(pSett, int_addr) == TRUE_T) {
// Convert virtual addr in hw-addr
hw_addr.addr32 = convert_ext_addr_in_hw_addr(pSett, int_addr);
// Choice block size
const uint32_t size_mud_mem = pSett->allocated_size - int_addr;
if ((size_mud_mem >= AT25DF_SECTOR_SIZE_64) && (aligment64k == TRUE_T)) {
block = eAT25DF_BLOCk_64;
int_addr += AT25DF_SECTOR_SIZE_64;
}
else if ((size_mud_mem >= AT25DF_SECTOR_SIZE_32) && (aligment32k == TRUE_T)) {
block = eAT25DF_BLOCK_32;
int_addr += AT25DF_SECTOR_SIZE_32;
}
else {
block = eAT25DF_BLOCK_4;
int_addr += AT25DF_SECTOR_SIZE_4;
}
// Erase
clear_wdt();
err = block_erase_at25df(hw_addr, block);
if (err != eMEM_OK) {
break;
}
}
return err;
}
void checkKeyboard() {
uchar delayKeyb = 100; // valore di default
uchar KeybValue = 0;
uchar loopCounter = 0;
bool LOOP = true;
while (LOOP) {
clear_wdt();
// -- Leggiamo i dati dalla porta
if (loopCounter++ > 3) delayKeyb = 1; // Next wait più basso
delay_ms(delayKeyb);
KeybValue = readPortB47();
displayValues();
switch (KeybValue) {
// Decide la funzione da utilizzare
case KEY_FUNC_UP:
if (++gcFuncIndex > LAST_FUNCTION) gcFuncIndex = 0;
continue;
case KEY_FUNC_DN:
if (--gcFuncIndex > LAST_FUNCTION) gcFuncIndex = LAST_FUNCTION; // non controlla il negativo. Quindi lavoro sull'assoluto.
continue;
case KEY_PULSE_UP:
if (fCONTINUOUS_KEY == false)
gcPulseNumber++; // ruota a 256
continue;
case KEY_PULSE_DN:
if (fCONTINUOUS_KEY == false)
gcPulseNumber--; // ruota a 256
continue;
// ---------------------------------------------------------------------------------
// Vale solo per misurare +Pulse e -Pulse.
// Quando questo è ON allora il numero dell'impulso viene ignorato e
// si procede ad una lettura continua. Come se fosse PosWAVE o NegWAVE.
// ---------------------------------------------------------------------------------
case KEY_FSCALE:
gcGateIndex++;
if (gcGateIndex >= MAX_nGATEs) gcGateIndex = 0;
pTMR = &stTMR[gcGateIndex]; // change pointer to TMR0 value for the selected scale
continue;
case KEY_CONTINUOUS:
LNtoggle_bool(fCONTINUOUS_KEY); // toggle bit
continue;
case KEY_SET_TMR0:
fSET_TMRx = true;
LOOP = false;
break;
default:
LOOP = false;
break;
} // end switch()
} // end While()
displayValues();
return;
}
void KeyBoard_SetTMR0() {
uchar KeybValue;
uchar delayKeyb;
uchar loopCounter = 0;
bool LOOP = true;
LCD_Clear();
LCD_printRom(0,0, romStr_SETTING_TRM0_STRING);
// delay_s(3);
delay_ms(250);
while (LOOP) {
clear_wdt();
delayKeyb = 100; // valore di default
if (loopCounter++ > 3) delayKeyb = 1; // Next wait più basso
delay_ms(delayKeyb);
// -- Leggiamo i dati dalla porta
KeybValue = readPortB47();
displayTMRValues();
switch (KeybValue) {
// value of time to select (1mSec, 10mSec, 100mSec, 1Sec)
case TMR0_mSecSCALE:
case TMR0_mSecSCALE_DN:
gcGateIndex++;
if (gcGateIndex >= MAX_nGATEs) gcGateIndex = 0;
pTMR = &stTMR[gcGateIndex]; // change pointer to TMR0 value for the selected scale
continue;
// increments the ExtraCounter
case TRM0_ExtraCounter:
pTMR->extraCounter++;
continue;
// increments the ExtraDelay
case TMR0_ExtraDelay:
pTMR->delay++;
continue;
// increments the TMR0 value by 256 units
case TMR0_UP_0x0100:
pTMR->tmr += 0x0100;
continue;
// increments the TMR0 value by 16 units
case TMR0_UP_0x0010:
pTMR->tmr += 0x0010;
continue;
// decrements the TMR0 value by 1 units
case TMR0_UP_0x0001:
pTMR->tmr++;
continue;
// increments the ExtraCounter
case TRM0_ExtraCounter_DN:
pTMR->extraCounter--;
continue;
// increments the ExtraDelay
case TMR0_ExtraDelay_DN:
pTMR->delay--;
continue;
// decrements the TMR0 value by 256 units
case TMR0_DN_0x0100:
pTMR->tmr -= 0x0100;
continue;
// decrements the TMR0 value by 16 units
case TMR0_DN_0x0010:
pTMR->tmr -= 0x0010;
continue;
// decrements the TMR0 value by 1 units
case TMR0_DN_0x0001:
pTMR->tmr--;
continue;
//case TMR0_TEST_GATE:
// openTMR0Gate();
// openTMR0Gate(pTimerX);
// openTMR1Gate();
// continue;
case TMR0_EXIT:
if (loopCounter == 0) { // Next wait più basso
LOOP = false;
break;
}
else
continue;
default:
break;
}
if (fSTART_KEY == true) {
fSTART_KEY = false;
LCD_Clear();
return;
// LOOP = false;
}
// Waiting for Keyboard irq
RBIF_intcon = 0; //IRQ-Flag RB7:RB4 pins changed state
sleep();
// ripristiniamo alcune variabili al loro default
loopCounter = 0; // reset counter
toggle_pin( MyLED ); // attento al ';' finale se metterlo nella MACRO o meno
}
return;
}
void main() {
volatile uchar nPulse = 0; // numero dell'impulso da controllare. if==0 allora vai CONTINUO.
volatile uchar loopCounter = 0;
volatile uchar delayKeyb = 250;
rom char *BLANK16 = " ";
// nPSA = Tmr0Value;
nPSA = 0;
mSecScale = 0;
TMRO_TabEntry = 0;
irqType = 0;
KeybValue = 0; // valore del HC148
uchar j;
// uchar Tmr0Value = eeprom_read(_EEPROM);
Init_Registers();
initPorts();
LCD_initialize();
LCD_Clear();
// intcon_RBIE = 1; // Change of state (COS) on RB4 to RB7
// stTMR0.tmr0Value = TMR0_vals[mSecScale];
// stTMR0.delayVal = TMR0_cntr[mSecScale];
// stTMR0.psaValue = TMR0_psa[mSecScale];
// stTMR0.scale = mSecSCALE[mSecScale];
stTMR0.tmr0Value = TMR0_vals[mSecScale];
stTMR0.delayVal = TMR0_delay[mSecScale];
stTMR0.psaValue = TMR0_psa[mSecScale];
stTMR0.scale = mSecSCALE[mSecScale];
stTMR0.extraCounter = TMR0_cntr[mSecScale];
delayNum = 0;
while (1) {
clear_wdt();
displayCfgValues();
loopCounter++;
if (loopCounter > 3) delayKeyb = 200; // Next wait più basso
if (loopCounter >10) delayKeyb = 10; // Next wait più basso
readKeyboard(delayKeyb);
// LCD_printf(0,0, "KEYB: %02X", KeybValue);
switch (KeybValue) {
// Value of PSA 0x00 to 0x07
case KEY_PSA_UP:
case KEY_PSA_DN:
stTMR0.psaValue++;
if (stTMR0.psaValue > 0x08) stTMR0.psaValue = 0x00;
continue;
// increments the TMR0 value by 4096 units
case TMR0_UP_0x1000:
stTMR0.extraCounter++;
continue;
// increments the TMR0 value by 256 units
case TMR0_UP_0x0100:
stTMR0.tmr0Value += 0x0100;
continue;
// increments the TMR0 value by 16 units
case TMR0_UP_0x0010:
stTMR0.tmr0Value += 0x0010;
continue;
// decrements the TMR0 value by 1 units
case TMR0_UP_0x0001:
stTMR0.tmr0Value++;
continue;
// value of time to select (1mSec, 10mSec, 100mSec, 1Sec)
case KEY_mSecSCALE:
case KEY_mSecSCALE_DN:
TMR0_psa[mSecScale] = stTMR0.psaValue ;
TMR0_cntr[mSecScale] = stTMR0.extraCounter;
TMR0_vals[mSecScale] = stTMR0.tmr0Value ;
mSecSCALE[mSecScale] = stTMR0.scale ;
mSecScale++;
if (mSecScale > 4) mSecScale = 0;
stTMR0.psaValue = TMR0_psa[mSecScale];
stTMR0.extraCounter = TMR0_cntr[mSecScale];
stTMR0.tmr0Value = TMR0_vals[mSecScale];
stTMR0.scale = mSecSCALE[mSecScale];
continue;
case TMR0_DN_0x1000:
stTMR0.extraCounter--;
continue;
// decrements the TMR0 value by 256 units
case TMR0_DN_0x0100:
stTMR0.tmr0Value -= 0x0100;
continue;
// decrements the TMR0 value by 16 units
case TMR0_DN_0x0010:
stTMR0.tmr0Value -= 0x0010;
continue;
// decrements the TMR0 value by 1 units
case TMR0_DN_0x0001:
stTMR0.tmr0Value--;
continue;
case KEY_START2:
case KEY_START:
openGate();
continue;
// decrements the TMR0 value by 4096 units
default:
break;
}
toggle_pin( MyLED ); // attento al ';' finale se metterlo nella MACRO o meno
TMR0_GATE_LINE = 0; //Turn OFF Gate line
intcon_RBIE = 1; //Enable PortB4-7 IRQ
sleep();
intcon_RBIE = 0; //Disable PortB4-7 IRQ
delayKeyb = 250; // valore di default
}
}
void main() {
// uint x = 0x5566;
// asm {
// movf _x, W ; write to low byte of variable x
// movwf _tmr0l, W
// movf _x+1, W ; write to high byte of variable x
// movwf _tmr0h
// movf _tmr0h, W
// movwf _x+1 ; write to high byte of variable x
// movf _tmr0l, W
// movwf _x ; write to low byte of variable x
// }
Init_Registers();
// ----------------------------------------------------------------------------------------------------------------
// - Definendo le variabili a stringa fissa e poi utilizzare la variabile si risparmian un sacco di byte di code.
// ----------------------------------------------------------------------------------------------------------------
rom char *BLANK16 = " ";
initPorts();
LCD_initialize();
LCD_Clear();
irqType = 0;
volatile uchar nPulse=0; // numero dell'impulso da controllare. if==0 allora vai CONTINUO.
volatile uchar loopCounter=0;
volatile uchar delayKeyb=250;
HC148Value = 0; // valore del HC148
// === LCD Display ===
// ----0----1----1----2
// ----5----0----5----0
// PSA:xxx sc:100mS
// TMR0Val:xxxxxxxx
intcon_RBIE = 1; // Change of state (COS) on RB4 to RB7
delayNum = 0;
while (1) {
clear_wdt();
displayCfgValues();
loopCounter++;
if (loopCounter > 3) delayKeyb = 200; // Next wait più basso
if (loopCounter >10) delayKeyb = 10; // Next wait più basso
readHC148(delayKeyb);
switch (HC148Value) {
case TMR0_UP:
TMR0_mSec[TMRO_TabEntry]++;
continue;
case TMR0_DN:
TMR0_mSec[TMRO_TabEntry]--;
continue;
// case TMR0_UP16:
// TMR0_mSec[TMRO_TabEntry] += 0x010;
// continue;
// case TMR0_DN16:
// TMR0_mSec[TMRO_TabEntry] -= 0x10;
// continue;
case KEY_Delay_UP:
delayNum++;
continue;
case KEY_Delay_DN:
delayNum--;
continue;
case KEY_PSA_UP:
nPSA++;
if (nPSA > PSA_256) nPSA = NO_PSA;
continue;
case KEY_mSecSCALE_UP:
mSecScale++;
if (mSecScale > 3) mSecScale = 0;
continue;
case KEY_START:
Gate1mSec();
continue;
default:
break;
}
(MyLED == ON) ? MyLED = OFF : MyLED = ON;
TMR0_GATE_LINE = 0; //Turn OFF Gate line
intcon_RBIE = 1; //Enable PortB4-7 IRQ
sleep();
intcon_RBIE = 0; //Disable PortB4-7 IRQ
delayKeyb = 250; // valore di default
}
}
/*
* Write data
*
*/
uint32_t write_data_fmem(const __FMEM_SETT * const pSett, const __FMEM_DATA * const pData) {
uint32_t count_addr;
uint32_t count_data;
uint32_t err;
__AT25DF_DATA hw_data;
// Addr rang test
if (test_addr_range(pSett, pData->addr) == FALSE_T) {
return eMEM_ADDR_ERROR;
}
// Capacity test
if ((pData->len > get_space_to_end_fmem(pSett, pData->addr)) || (pData->len == 0)) {
return eMEM_DATA_ERROR;
}
// Write cycle
count_addr = pData->addr;
count_data = 0;
while (count_data < pData->len) {
// Determine data block for write
hw_data.len = get_write_datalen(pSett, count_addr);
hw_data.len = ((pData->len - count_data) > hw_data.len)
? hw_data.len : (pData->len - count_data);
// Prapare param for write
hw_data.addr.addr32 = convert_ext_addr_in_hw_addr(pSett, count_addr);
hw_data.pBuff = (pData->pBuff + count_data);
// Test at new sectror write
if (test_new_sector_write(pSett, count_addr) == TRUE_T) {
// Erase sector
clear_wdt();
err = block_erase_at25df(hw_data.addr, eAT25DF_BLOCK_4);
switch (err)
{
//--------------------------------------------------------------
case eMEM_OK:
break;
//--------------------------------------------------------------
case eMEM_BUSY:
//--------------------------------------------------------------
case eMEM_NOT_AVAILABLE:
//--------------------------------------------------------------
case eMEM_ADDR_ERROR:
//--------------------------------------------------------------
case eMEM_DATA_ERROR:
//--------------------------------------------------------------
case eMEM_WRITE_EN_ERROR:
//--------------------------------------------------------------
case eMEM_INTERNAL_ERROR:
//--------------------------------------------------------------
default:
return err;
}
}
// Write data
clear_wdt();
err = program_page_at25df(&hw_data);
switch (err)
{
//------------------------------------------------------------------
case eMEM_OK:
break;
//------------------------------------------------------------------
case eMEM_BUSY:
//------------------------------------------------------------------
case eMEM_NOT_AVAILABLE:
//------------------------------------------------------------------
case eMEM_ADDR_ERROR:
//------------------------------------------------------------------
case eMEM_DATA_ERROR:
//------------------------------------------------------------------
case eMEM_WRITE_EN_ERROR:
//------------------------------------------------------------------
case eMEM_INTERNAL_ERROR:
//------------------------------------------------------------------
default:
return err;
}
// Shift counters
count_addr += hw_data.len;
count_data += hw_data.len;
}
return eMEM_OK;
}
