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 }
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); } }
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)); }
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 }