u8 OnTimer0(callback func, u8 timediv, u16 delay)
{
u8 _t0con = 0;
if (intUsed[INT_TMR0] == INT_NOT_USED)
{
intUsed[INT_TMR0] = INT_USED;
intCount[INT_TMR0] = 0;
intCountLimit[INT_TMR0] = delay;
intFunction[INT_TMR0] = func;
switch(timediv)
{
case INT_MICROSEC:
// 1 us = 1.000 ns = 12 cy
preloadH[INT_TMR0] = high8(0xFFFF - 12);
preloadL[INT_TMR0] = low8(0xFFFF - 12);
_t0con = T0_OFF & T0_16BIT & T0_SOURCE_INT & T0_PS_OFF;
break;
case INT_MILLISEC:
// 1 ms = 1.000.000 ns = 12.000 cy
// 12.000 / 8 = 1.500
preloadH[INT_TMR0] = high8(0xFFFF - 1500);
preloadL[INT_TMR0] = low8(0xFFFF - 1500);
_t0con = T0_OFF & T0_16BIT & T0_SOURCE_INT & T0_PS_ON & T0_PS_1_8;
break;
case INT_SEC:
// 1 sec = 1.000.000.000 ns = 12.000.000 cy
// 12.000.000 / 256 = 46875
preloadH[INT_TMR0] = high8(0xFFFF - 46875);
preloadL[INT_TMR0] = low8(0xFFFF - 46875);
_t0con = T0_OFF & T0_16BIT & T0_SOURCE_INT & T0_PS_ON & T0_PS_1_256;
break;
}
INTCON2bits.TMR0IP = INT_LOW_PRIORITY;
INTCONbits.TMR0IE = INT_ENABLE;
INTCONbits.TMR0IF = 0;
TMR0H = preloadH[INT_TMR0];
TMR0L = preloadL[INT_TMR0];
T0CON = _t0con;
return INT_TMR0;
}
#ifdef DEBUG
else
{
debug("Error : interrupt TIMER0 is already used !");
return false;
}
#endif
}
u8 OnTimer0(callback func, u8 timediv, u16 delay)
{
u8 _t0con = 0;
u16 _cycles_;
if (intUsed[INT_TMR0] == INT_NOT_USED)
{
intUsed[INT_TMR0] = INT_USED;
intCount[INT_TMR0] = 0;
intCountLimit[INT_TMR0] = delay;
intFunction[INT_TMR0] = func;
switch(timediv)
{
case INT_MICROSEC:
// 1 us = 1.000 ns = 12 cy
_cycles_ = System_getPeripheralFrequency() / 1000 / 1000;
preloadH[INT_TMR0] = high8(0xFFFF - _cycles_);
preloadL[INT_TMR0] = low8(0xFFFF - _cycles_);
_t0con = T0_OFF | T0_16BIT | T0_SOURCE_INT | T0_PS_OFF;
break;
case INT_MILLISEC:
// 1 ms = 1.000.000 ns = 12.000 cy
_cycles_ = System_getPeripheralFrequency() / 1000 ;
preloadH[INT_TMR0] = high8(0xFFFF - _cycles_);
preloadL[INT_TMR0] = low8(0xFFFF - _cycles_);
_t0con = T0_OFF | T0_16BIT | T0_SOURCE_INT | T0_PS_OFF;
break;
case INT_SEC:
// 1 sec = 1.000.000.000 ns = 12.000.000 cy
// 12.000.000 / 256 = 46875
_cycles_ = System_getPeripheralFrequency() >> 8;
preloadH[INT_TMR0] = high8(0xFFFF - _cycles_);
preloadL[INT_TMR0] = low8(0xFFFF - _cycles_);
_t0con = T0_OFF | T0_16BIT | T0_SOURCE_INT | T0_PS_ON | T0_PS_1_256;
break;
}
T0CON = _t0con;
INTCON2bits.TMR0IP = INT_LOW_PRIORITY;
TMR0H = preloadH[INT_TMR0];
TMR0L = preloadL[INT_TMR0];
INTCONbits.TMR0IF = 0;
INTCONbits.TMR0IE = INT_ENABLE;
return INT_TMR0;
}
void EEPROM_write16(u8 address, u16 mydata)
{
//u8 hibyte;
//u8 lobyte;
//lobyte = (u8)mydata;
//hibyte = (u8)(mydata >> 8);
EEPROM_write8(address, high8(mydata));
EEPROM_write8(address+1, low8(mydata));
}
void PMP_write(u16 value)
{
if (_pmp_width == PMP_MODE_16BIT)
{
PMP_wait(); // wait for PMP to be available
PMDIN1L = low8(value);
PMP_wait(); // wait for PMP to be available
PMDIN1H = high8(value);
}
else
{
PMP_wait(); // wait for PMP to be available
PMDIN1L = low8(value);
}
}
static u8 sd_readblock( u32 addr, u8 *data ) {
u8 tmp, i, resp[ R2 ];
u24 count;
u16 crc;
addr <<= 9;
//sd_waitidle();
if( sd_send_command( CMD17_READ_SINGLE_BLOCK, &addr, resp ) != SD_ERR_OK ) return( SD_ERR_GENERIC );
if( resp[ 0 ] ) return( SD_ERR_READ );
sd_assert();
// Wait (with timeout) for data token
i = 0;
do {
tmp = spi_txrx( CMD_IDLE );
} while( ++i != SD_READ_TIMEOUT && tmp == 0xFF );
// Bail on error
if( !( tmp & MSK_TOK_DATAERROR ) ) {
spi_txrx( CMD_IDLE );
sd_deassert();
return( SD_ERR_READ );
}
// Read data
count = 512;
while( count-- ) {
*data++ = spi_txrx( CMD_IDLE );
}
// Read CRC
high8( crc ) = spi_txrx( CMD_IDLE );
low8( crc ) = spi_txrx( CMD_IDLE );
tmp = spi_txrx( CMD_IDLE );
sd_deassert();
return( SD_ERR_OK );
}
void PMP_sendAddress(u16 addr)
{
PMP_wait(); // wait for PMP to be available
PMADDRH = high8(addr);
PMADDRL = low8(addr);
}
void PMP_init()
{
/// 1. Disable the PMP interrupt
//IntDisable(PMPINT);
/// 2. Stop and reset the PMP module
PMCONHbits.PMPEN = 0;//Bit(15);
PMCONH = 0;
PMCONL = 0;
PMMODEH = 0;
PMMODEL = 0;
PMEH = 0;
PMEL = 0;
/// 3. Configure Mode
// Enable Interrupt Request mode: IRQM<1:0> bits (PMMODE<14:13>).
PMMODEHbits.IRQM = PMP_MODE_IRQ_OFF;
// Select auto address increment: INCM<1:0> bits (PMMODE<12:11>).
if (_pmp_mode==PMP_MODE_ESLAVE || _pmp_mode==PMP_MODE_SLAVE)
{
if (_pmp_inc==1)
PMMODEHbits.INCM = PMP_MODE_INC_BUFFER;
else
PMMODEHbits.INCM = PMP_MODE_INC_OFF;
}
else // master mode 1 or 2
{
if (_pmp_inc==1)
PMMODEHbits.INCM = PMP_MODE_INC_ADDR;
if (_pmp_inc==-1)
PMMODEHbits.INCM = PMP_MODE_DEC_ADDR;
if (_pmp_inc==0)
PMMODEHbits.INCM = PMP_MODE_INC_OFF;
}
// Select 8- or 16-bit Data mode: MODE16 bit (PMMODE<10>).
PMMODEHbits.MODE16 = _pmp_width;
// Select Master mode : MODE<1:0> bits (PMMODE<9:8>).
// In Master mode 1, read and write strobe are combined into a
// single control line, PMRD/PMWR;
// a second control line, PMENB, determines when a read or write
// action is to be taken.
// In Master mode 2, read and write strobes (PMRD and PMWR)
// are supplied on separate pins.
PMMODEH |= _pmp_mode;
// Select 4 wait cycles before the PMRD/PMWR strobe
PMMODELbits.WAITB = _pmp_waitB;
// Wait cycles for a Read/Write strobe
PMMODELbits.WAITM = _pmp_waitM;
// Wait cycles for data hold
PMMODELbits.WAITE = _pmp_waitE;
/// 4. Configure Control
//SIDL: Stop in Idle Mode bi
//1 = Discontinue module operation when device enters Idle mode
//0 = Continue module operation in Idle mode
PMCONHbits.PSIDL = 0; // PMP idle when MCU idle
// Select multiplexed addressing: ADRMUX<1:0> bits (PMCON<12:11>).
PMCONHbits.ADRMUX = _pmp_mux; // Address and data appear on separate pins
//PMPTTL: PMP Module TTL Input Buffer Select bit
//1 = PMP module uses TTL input buffers
//0 = PMP module uses Schmitt Trigger input buffer
PADCFG1bits.PMPTTL = 0;
/*
/// Master Mode 1 (PMCSx, PMRD/PMWR, PMENB, PMBE, PMA<x:0> and PMD<7:0>)
if ( _pmp_mode == PMP_MODE_MASTER1 )
{
// Enable PMBE strobe: PTWREN bit (PMCON<9>)
if ( _pmp_control & PMENB )
PMCONHbits.PTWREN = 1; // PMP write strobe enable
else
PMCONHbits.PTWREN = 0; // PMP write strobe disable
// Enable PMRD/PMWR strobe: PTRDEN bit (PMCON<8>)
if (_pmp_control & PMRD_PMWR)
PMCONHbits.PTRDEN = 1; // PMP read strobe enable
else
PMCONHbits.PTRDEN = 0; // PMP read strobe disable
// To differentiate data bytes, the byte enable control strobe,
// PMBE, is used to signal when the Most Significant Byte(MSB)
// of data is being presented on the data lines
// Enable bit : PTBEEN bit (PMCONH<2>)
if ( _pmp_control & PMBE )
PMCONHbits.PTBEEN = 1; // PMP Enable strobe enable
else
PMCONHbits.PTBEEN = 0; // PMP Enable strobe disable
}
/// Master Mode 2 (PMCSx, PMRD, PMWR, PMBE, PMA<x:0> and PMD<7:0>)
else if ( _pmp_mode == PMP_MODE_MASTER2 )
{
*/
// Enable PMWR strobe: PTWREN bit (PMCON<9>)
if ( _pmp_control & PMWR )
PMCONHbits.PTWREN = 1; // PMP write strobe enable
else
PMCONHbits.PTWREN = 0; // PMP write strobe disable
// Enable PMRD strobe: PTRDEN bit (PMCON<8>)
if (_pmp_control & PMRD)
PMCONHbits.PTRDEN = 1; // PMP read strobe enable
else
PMCONHbits.PTRDEN = 0; // PMP read strobe disable
if ( _pmp_control & PMBE )
PMCONHbits.PTBEEN = 1; // PMP Enable strobe enable
else
PMCONHbits.PTBEEN = 0; // PMP Enable strobe disable
// }
// Enable PMCS1 Chip Selects: CSF<1:0> bits (PMCON<7:6>)
if ((_pmp_control & PMCS1) || (_pmp_control & PMCS2))
PMCONLbits.CSF = PMP_CS_ON;
else
PMCONLbits.CSF = PMP_CS_OFF;
// Address Latch Polarity bit
PMCONLbits.ALP = _pmp_polarity;
// Select PMCS2, PMCS1 active-low pin polarity: CS2P bit (PMCON<4>) = 0 and CS1P bit (PMCON<3>) = 0.
PMCONLbits.CS1P = _pmp_polarity;
// Byte Enable priority bit
PMCONLbits.BEP = _pmp_polarity;
// Select PMWR active-low pin polarity: WRSP bit (PMCON<1>) = 0.
PMCONLbits.WRSP = _pmp_polarity;
// Select PMRD active-low pin polarity: RDSP bit (PMCON<0>) = 0.
PMCONLbits.RDSP = _pmp_polarity;
/// 5. Enable/Disable PMA<15:0> Address pins
PMEH = high8(_pmp_address);
PMEL = low8(_pmp_address);
if ( _pmp_control & PMCS1 )
{
PMEHbits.PTEN14 = 1; //address 14 or PMCS1
//PMEH |= PMCS1;
}
if ( _pmp_control & PMCS2 )
{
PMEHbits.PTEN15 = 1; //address 15 or PMCS2
//PMEH |= PMCS2;
}
/** 6. If interrupts are used: **/
/*
// 6.1. Clear the interrupt flag bit, PMPIF (IFS1<2>) = 0.
IntClearFlag(INT_PARALLEL_MASTER_PORT);
// 6.2. Configure the PMP interrupt priority bits
IntSetVectorPriority(INT_PARALLEL_MASTER_PORT_VECTOR, 7, 3);
// 6.3. Enable the PMP interrupt by setting the interrupt enable bit, PMPIE = 1.
IntEnable(INT_PARALLEL_MASTER_PORT);
*/
/** 7. Enable the PMP master port **/
PMCONHbits.PMPEN = 1;//Bit(15);
// wait for >30 ms
Delayms(50);
}
u8 OnTimer3(callback func, u8 timediv, u16 delay)
{
u8 _t3con = 0;
if (intUsed[INT_TMR3] == INT_NOT_USED)
{
intUsed[INT_TMR3] = INT_USED;
intCount[INT_TMR3] = 0;
intCountLimit[INT_TMR3] = delay;
intFunction[INT_TMR3] = func;
switch(timediv)
{
// nb : T3_SOURCE_INT => Fosc/4
// 1 cy = 1/(Fosc/4)=4/Fosc=4/48MHz=83ns
case INT_MICROSEC:
// 1us = 1.000 ns = 12 cy
preloadH[INT_TMR3] = high8(0xFFFF - 12);
preloadL[INT_TMR3] = low8(0xFFFF - 12);
#if defined(PIC18F2550) || defined(PIC18F4550)
_t3con = T3_OFF | T3_16BIT | T3_PS_1_1 | T3_SOURCE_INT;
#endif
#if defined(PIC18F26J50) || defined(PIC18F46J50)
_t3con = T3_OFF | T3_16BIT | T3_PS_1_1 | T3_SOURCE_INT | T3_SOURCE_T1OSC;
#endif
break;
case INT_MILLISEC:
// 1 ms = 1.000.000 ns = 12.000 cy at Fosc/4
// 12.000 / 8 = 1.500
preloadH[INT_TMR3] = high8(0xFFFF - 1500);
preloadL[INT_TMR3] = low8(0xFFFF - 1500);
#if defined(PIC18F2550) || defined(PIC18F4550)
_t3con = T3_OFF | T3_16BIT | T3_PS_1_8 | T3_SOURCE_INT;
#endif
#if defined(PIC18F26J50) || defined(PIC18F46J50)
//_t3con = T3_OFF | T3_16BIT | T3_PS_1_8 | T3_SOURCE_INT | T3_SOURCE_T1OFF;
_t3con = 0b00110010;
#endif
break;
case INT_SEC:
// 1 sec = 1.000.000.000 ns = 12.000.000 cy
// 12.000.000 / 8 = 1.500.000
// 1.500.000 / 25 = 60000
preloadH[INT_TMR3] = high8(0xFFFF - 60000);
preloadL[INT_TMR3] = low8(0xFFFF - 60000);
intCountLimit[INT_TMR3] = delay * 25;
#if defined(PIC18F2550) || defined(PIC18F4550)
_t3con = T3_OFF | T3_16BIT | T3_PS_1_8 | T3_SOURCE_INT;
#endif
#if defined(PIC18F26J50) || defined(PIC18F46J50)
_t3con = T3_OFF | T3_16BIT | T3_PS_1_8 | T3_SOURCE_INT | T3_SOURCE_T1OSC;
#endif
break;
}
IPR2bits.TMR3IP = INT_LOW_PRIORITY;
PIE2bits.TMR3IE = INT_ENABLE;
PIR2bits.TMR3IF = 0;
TMR3H = preloadH[INT_TMR3];
TMR3L = preloadL[INT_TMR3];
T3CON = _t3con;
return INT_TMR3;
}
#ifdef DEBUG
else
{
debug("Error : interrupt TIMER3 is already used !");
return INT_TMR3;
}
#endif
}
u8 OnTimer1(callback func, u8 timediv, u16 delay)
{
u8 _t1con = 0;
if (intUsed[INT_TMR1] == INT_NOT_USED)
{
intUsed[INT_TMR1] = INT_USED;
intCount[INT_TMR1] = 0;
intCountLimit[INT_TMR1] = delay;
intFunction[INT_TMR1] = func;
switch(timediv)
{
case INT_MICROSEC:
// 1us = 1.000 ns = 12 cy
preloadH[INT_TMR1] = high8(0xFFFF - 12);
preloadL[INT_TMR1] = low8(0xFFFF - 12);
#if defined(PIC18F2550) || defined(PIC18F4550)
_t1con = T1_OFF | T1_16BIT | T1_PS_1_1 | T1_RUN_FROM_ANOTHER | T1_OSC_OFF | T1_SYNC_EXT_OFF | T1_SOURCE_INT;
#endif
#if defined(PIC18F26J50) || defined(PIC18F46J50)
_t1con = T1_OFF | T1_16BIT | T1_PS_1_1 | T1_OSC_OFF | T1_SYNC_EXT_OFF | T1_SOURCE_INT;
#endif
break;
case INT_MILLISEC:
// 1ms = 1.000.000ns = 12.000 cy
// 12.000 / 8 = 1.500
preloadH[INT_TMR1] = high8(0xFFFF - 1500);
preloadL[INT_TMR1] = low8(0xFFFF - 1500);
#if defined(PIC18F2550) || defined(PIC18F4550)
_t1con = T1_OFF | T1_16BIT | T1_PS_1_8 | T1_RUN_FROM_ANOTHER | T1_OSC_OFF | T1_SYNC_EXT_OFF | T1_SOURCE_INT;
#endif
#if defined(PIC18F26J50) || defined(PIC18F46J50)
_t1con = T1_OFF | T1_16BIT | T1_PS_1_8 | T1_OSC_OFF | T1_SYNC_EXT_OFF | T1_SOURCE_INT;
#endif
break;
case INT_SEC:
// 1 sec = 1.000.000.000 ns = 12.000.000 cy
// 12.000.000 / 8 = 1.500.000
// 1.500.000 / 25 = 60000
preloadH[INT_TMR1] = high8(0xFFFF - 60000);
preloadL[INT_TMR1] = low8(0xFFFF - 60000);
intCountLimit[INT_TMR1] = delay * 25;
#if defined(PIC18F2550) || defined(PIC18F4550)
_t1con = T1_OFF | T1_16BIT | T1_PS_1_8 | T1_RUN_FROM_ANOTHER | T1_OSC_OFF | T1_SYNC_EXT_OFF | T1_SOURCE_INT;
#endif
#if defined(PIC18F26J50) || defined(PIC18F46J50)
_t1con = T1_OFF | T1_16BIT | T1_PS_1_8 | T1_OSC_OFF | T1_SYNC_EXT_OFF | T1_SOURCE_INT;
#endif
break;
}
IPR1bits.TMR1IP = INT_LOW_PRIORITY;
PIE1bits.TMR1IE = INT_ENABLE;
PIR1bits.TMR1IF = 0;
TMR1H = preloadH[INT_TMR1];
TMR1L = preloadL[INT_TMR1];
T1CON = _t1con;
return INT_TMR1;
}
#ifdef DEBUG
else
{
debug("Error : interrupt TIMER1 is already used !");
return INT_TMR1;
}
#endif
}
