void hal_sys_init(){
SYSTEMConfigPerformance(SYS_CLK);
INTSetVectorPriority(INT_VECTOR_UART(UART3),3);
INTSetVectorPriority(INT_VECTOR_UART(UART5), 3);
INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
INTDisableInterrupts();
}
/*******************************************************************************
* FUNCTION: vUART2FlushRxBuffer
*
* PARAMETERS:
* ~ void
*
* RETURN:
* ~ void
*
* DESCRIPTIONS:
* Flush all the data in the Rx buffer.
*
*******************************************************************************/
void vUART2FlushRxBuffer(void)
{
unsigned char ucReceivedData;
unsigned int iStatus = INTDisableInterrupts();
prv_xRx.uiDataCount = 0;
prv_xRx.uiReadPt = 0;
prv_xRx.uiWritePt = 0;
// Discard all data available in the UART receive buffer.
while (UARTReceivedDataIsAvailable(UART2)) {
// Read the received data.
ucReceivedData = UARTGetDataByte(UART2);
}
// Clear the overrun flag.
if (UARTGetLineStatus(UART2) & UART_OVERRUN_ERROR) {
U2STAbits.OERR = 0;
}
// Clear the semaphore.
xSemaphoreTake(xBluetoothRxSemaphore, 0);
INTRestoreInterrupts(iStatus);
}
/*******************************************************************************
* FUNCTION: uiUART2Read
*
* PARAMETERS:
* ~ *pucBuffer - Buffer to store the received data.
* ~ uiLength - Number of bytes to read.
*
* RETURN:
* ~ Number of bytes read.
*
* DESCRIPTIONS:
* Read the data from UART.
*
*******************************************************************************/
unsigned int uiUART2Read(unsigned char *pucBuffer, unsigned char uiLength)
{
unsigned int uiActualLength = 0;
while (uiLength-- > 0) {
// Make sure there is data available in the buffer.
if (uiUART2GetRxDataCount() > 0) {
// Copy the data to the buffer.
*pucBuffer++ = prv_xRx.pucBuffer[prv_xRx.uiReadPt];
// Increase the number of data read.
uiActualLength++;
// Increase the read pointer and decrease the data count.
prv_vIncPointer(&prv_xRx.uiReadPt, prv_xRx.uiBufferSize);
unsigned int iStatus = INTDisableInterrupts();
prv_xRx.uiDataCount--;
INTRestoreInterrupts(iStatus);
}
else {
break;
}
}
return uiActualLength;
}
void Servo::writeMicroseconds(int value)
{
// calculate and store the values for the given channel
byte channel = this->servoIndex;
if( (channel >= 0) && (channel < MAX_SERVOS) ) // ensure channel is valid
{
if( value < SERVO_MIN() ) // ensure pulse width is valid
value = SERVO_MIN();
else if( value > SERVO_MAX() )
value = SERVO_MAX();
value = value - TRIM_DURATION;
value = usToTicks(value); // convert to ticks after compensating for interrupt overhead
unsigned int status;
status = INTDisableInterrupts();
servos[channel].ticks = value;
INTRestoreInterrupts(status);
}
}
/*******************************************************************************
* FUNCTION: uiUART2Write
*
* PARAMETERS:
* ~ *pucBuffer - Buffer for the data to send.
* ~ uiLength - Number of bytes to send.
*
* RETURN:
* ~ Number of bytes sent.
*
* DESCRIPTIONS:
* Transmit data via UART.
*
*******************************************************************************/
unsigned int uiUART2Write(const unsigned char *pucBuffer, unsigned char uiLength)
{
unsigned char ucActualLength = 0;
while (uiLength-- > 0) {
// Make sure there is empty space in the buffer.
if (uiUART2GetTxSpace() > 0) {
// Copy the data to the buffer.
prv_xTx.pucBuffer[prv_xTx.uiWritePt] = *pucBuffer++;
// Increase the number of transmitted data.
ucActualLength++;
// Increase the write pointer and data count.
prv_vIncPointer(&prv_xTx.uiWritePt, prv_xTx.uiBufferSize);
unsigned int iStatus = INTDisableInterrupts();
prv_xTx.uiDataCount++;
INTRestoreInterrupts(iStatus);
}
else {
break;
}
}
// Enable the Tx interrupt if there is new data.
if (ucActualLength > 0) {
INTEnable(INT_U2TX, INT_ENABLED);
}
return ucActualLength;
}
/*******************************************************************************
* FUNCTION: uiUART2GetTxSpace
*
* PARAMETERS:
* ~ void
*
* RETURN:
* ~ Remaining space in TX buffer.
*
* DESCRIPTIONS:
* Read the remaining empty space in the TX buffer.
*
*******************************************************************************/
volatile unsigned int uiUART2GetTxSpace(void)
{
unsigned int iStatus = INTDisableInterrupts();
unsigned int uiTxSpace = prv_xTx.uiBufferSize - prv_xTx.uiDataCount;
INTRestoreInterrupts(iStatus);
return uiTxSpace;
}
/*******************************************************************************
* FUNCTION: uiUART2GetRxDataCount
*
* PARAMETERS:
* ~ void
*
* RETURN:
* ~ Number of bytes available.
*
* DESCRIPTIONS:
* Read the number of bytes available in the Rx buffer.
*
*******************************************************************************/
volatile unsigned int uiUART2GetRxDataCount(void)
{
unsigned int iStatus = INTDisableInterrupts();
unsigned int uiDataCount = prv_xRx.uiDataCount;
INTRestoreInterrupts(iStatus);
return uiDataCount;
}
/********************************************************************
* Function: JumpToApp()
*
* Precondition:
*
* Input: None.
*
* Output:
*
* Side Effects: No return from here.
*
* Overview: Jumps to application.
*
*
* Note: None.
********************************************************************/
void JumpToApp(void)
{
void (*fptr)(void);
INTDisableInterrupts();
fptr = (void (*)(void))USER_APP_RESET_ADDRESS;
fptr();
}
inline BOOL SPIFUBAR(void)
{
BOOL returnValue;
unsigned int intEnabled;
intEnabled=INTDisableInterrupts();
returnValue=FALSE;
INTRestoreInterrupts(intEnabled);
return returnValue;
}
void __ISR(_TIMER_1_VECTOR, ipl7) _Timer1Handler(void)
{
HWORD dtcMtr;
IFS0CLR = ( 1 << 4 );
INTDisableInterrupts();
if ( ! fMtrLeft ) {
// Left motor feedback has timed out.
INTEnableInterrupts();
dtcMtr = OC1R + 20;
if ( dtcMtrMax >= dtcMtr ) {
OC1RS= dtcMtr;
}
else {
OC1RS = dtcMtrMax;
}
}
else {
fMtrLeft = fFalse;
INTEnableInterrupts();
}
INTDisableInterrupts();
if ( ! fMtrRight ) {
// Right motor feedback has timed out.
INTEnableInterrupts();
dtcMtr = OC4R + 20;
if ( dtcMtrMax >= dtcMtr ) {
OC4RS = dtcMtr;
}
else {
OC4RS = dtcMtrMax;
}
}
else {
fMtrRight = fFalse;
INTEnableInterrupts();
}
}
BOOL SPIDataReady(void)
{
BOOL returnValue;
unsigned int intTemp;
intTemp = INTDisableInterrupts();
returnValue=SPI.status.RXDataReady;
SPI.status.RXDataReady=FALSE;
INTRestoreInterrupts(intTemp);
return returnValue;
}
/*********************************************************************
* Function: DWORD get_fattime(void)
*
* PreCondition:
*
* Input: None
*
* Output: Time
*
* Side Effects:
*
* Overview: when writing fatfs requires a time stamp
* in this exmaple we are going to use a counter
* If the starter kit has the 32kHz crystal
* installed then the RTCC could be used instead
*
* Note:
********************************************************************/
DWORD get_fattime(void)
{
DWORD tmr;
INTDisableInterrupts();
tmr = GetCurrentDateTimeAsDWORD();
INTEnableInterrupts();
return tmr;
}
void setup_spi() {
// TODO move it out of here
INTDisableInterrupts();
mCNOpen(CN_ON | CN_IDLE_CON, CN1_ENABLE, CN1_PULLUP_ENABLE);
mPORTCRead();
mCNSetIntPriority(6); // same as below
mCNClearIntFlag();
mCNIntEnable(1);
INTEnableInterrupts();
}
void MyCyclone_Write(unsigned int theAddress, unsigned int theData)
{
unsigned int intStatus;
intStatus = INTDisableInterrupts();
mPORTEClearBits(CS_FPGA);
MySPI_PutC(theAddress | 0x8000); // Bit 7 = R/W = 1
MySPI_PutC(theData);
mPORTESetBits(CS_FPGA);
INTRestoreInterrupts(intStatus);
}
void DelayMs(WORD delay) {
unsigned int int_status;
while (delay--) {
int_status = INTDisableInterrupts();
OpenCoreTimer(500000 / 2000);
INTRestoreInterrupts(int_status);
mCTClearIntFlag();
while (!mCTGetIntFlag());
}
mCTClearIntFlag();
}
/********************************************************************
* Function: NVMemOperation()
*
* Precondition:
*
* Input: NV operation
*
* Output: NV eror
*
* Side Effects: This function must generate MIPS32 code only and
hence the attribute (nomips16)
*
* Overview: Performs reuested operation.
*
*
* Note: None.
********************************************************************/
UINT __attribute__((nomips16)) NVMemOperation(UINT nvmop)
{
int int_status;
int susp;
// Disable DMA & Disable Interrupts
#ifdef _DMAC
int_status = INTDisableInterrupts();
susp = DmaSuspend();
#else
int_status = INTDisableInterrupts();
#endif // _DMAC
// Enable Flash Write/Erase Operations
NVMCON = NVMCON_WREN | nvmop;
// Data sheet prescribes 6us delay for LVD to become stable.
// To be on the safer side, we shall set 7us delay.
delay_us(7);
NVMKEY = 0xAA996655;
NVMKEY = 0x556699AA;
NVMCONSET = NVMCON_WR;
// Wait for WR bit to clear
while(NVMCON & NVMCON_WR);
// Disable Flash Write/Erase operations
NVMCONCLR = NVMCON_WREN;
// Enable DMA & Enable Interrupts
#ifdef _DMAC
DmaResume(susp);
INTRestoreInterrupts(int_status);
#else
INTRestoreInterrupts(int_status);
#endif // _DMAC
// Return Error Status
return(NVMemIsError());
}
BOOL SPIGet(uint8_t *tempSPIRX)
{
BOOL returnValue;
unsigned int index;
unsigned int intTemp;
intTemp = INTDisableInterrupts();
for(index=0;index<sizeof(SPI.RXData);index++)
{
tempSPIRX[index]=SPI.RXData[index];
}
INTRestoreInterrupts(intTemp);
return returnValue;
}
void Setup_initializeBoard(void)
{
INTDisableInterrupts();
Setup_ports();
setup_ADC();
INTEnableSystemMultiVectoredInt();
Setup_timers();
RcRx_setupInputCaptures();
MotorCtrl_setupOutputCompares();
Setup_configInterrupts();
}
unsigned int MyCyclone_Read(unsigned int theAddress)
{
unsigned int theData;
unsigned int intStatus;
intStatus = INTDisableInterrupts();
mPORTEClearBits(CS_FPGA);
MySPI_PutC(theAddress & 0x7FFF); // Bit 7 = R/W = 0
theData = MySPI_GetC();
mPORTESetBits(CS_FPGA);
INTRestoreInterrupts(intStatus);
return(theData);
}
//===============================================================
// Name : StateClose
// Purpose : Close all peripherals and put device in sleep mode
//===============================================================
void StateClose(void)
{
INTDisableInterrupts(); // Disable all interrupts of the system.
// Wdt.Disable();
LED_ALL_OFF();
I2c.Close(I2C4);
// DRIVE B
//==========================================================
if (USE_DRIVE_B == 1)
{
Pwm.Close(PWM_2);
Pwm.Close(PWM_3);
InputCapture.Close(IC2);
InputCapture.Close(IC4);
}
//==========================================================
// DRIVE A
//==========================================================
if (USE_DRIVE_A == 1)
{
Pwm.Close(PWM_4);
Pwm.Close(PWM_5);
InputCapture.Close(IC1);
InputCapture.Close(IC3);
}
//==========================================================
Spi.Close(SPI4);
// Can.Close(CAN1);
Uart.Close(UART6);
Timer.Close(TIMER_1);
Timer.Close(TIMER_2);
Timer.Close(TIMER_3);
Timer.Close(TIMER_5);
// OSCCONSET = 0x10; // Sleep mode
}
void DelayMs(WORD time)
{
while(time--)
{
unsigned int int_status;
int_status = INTDisableInterrupts();
OpenCoreTimer(GetSystemClock() / 2000); // core timer is at 1/2 system clock
INTRestoreInterrupts(int_status);
mCTClearIntFlag();
while(!mCTGetIntFlag());
}
mCTClearIntFlag();
}
void setupTimer3(int freq) {
INTDisableInterrupts(); //disable interrupts while settting up
T3CON = 0b000 << 4; // set prescaler to 1:1
T3CONCLR = 0x2; // set input to PBCLK (the default; all defaults fine)
PR3 = (SYS_FREQ / freq) - 1; // set the period in period register 3
TMR3 = 0; // reset the Timer3 count
T3CONSET = 1 << 15; // turn Timer3 on
IPC3bits.T3IP = 5; // set timer interrupt priority
IPC3bits.T3IS = 0; // set subpriority
IFS0bits.T3IF = 0; // clear interrupt flag
INTEnableSystemMultiVectoredInt(); // enable interrupts at CPU
INTEnableInterrupts();
}
int main(void) {
CFGCONbits.JTAGEN = 0; // turn off JTAG, get back those pins for IO use
SYSTEMConfigPerformance(SYS_FREQ);
INTDisableInterrupts();
PIC32MX250_setup_pins();
//Setup SPI1
SPI1CON = 0; // turn off the spi module and reset it
SPI1BUF; // clear the rx buffer by reading from it
SPI1BRG = 0x3; // baud rate to 5MHz [SPI1BRG = (40000000/(2*desired))-1]
SPI1STATbits.SPIROV = 0; // clear the overflow bit
SPI1CONbits.CKE = 1; // data changes when clock goes from active to inactive
// (high to low since CKP is 0)
SPI1CONbits.MSTEN = 1; // master operation
SPI1CONbits.ON = 1; // turn on spi
TRISBbits.TRISB7=0; //set pins as outputs--0=output
TRISAbits.TRISA4=0;
TRISAbits.TRISA3=0;
TRISAbits.TRISA2=1; //make RA2 an input to trigger ADC collecting
//Initialize pin values
LATAbits.LATA3=1; //make this pin be 3.3v
LATAbits.LATA4=1;
LATBbits.LATB7=0; //make this pin go low
unsigned int sample=0;
while(1){
if (PORTAbits.RA2){
//if pin 9 goes high, read from the adc
sample=adc_grab(1);
}
}
return 0;
}
//===============================================================
// Name : StateInit
// Purpose : Initialization of the system.
//===============================================================
void StateInit(void)
{
INTDisableInterrupts(); // Disable all interrupts of the system.
INIT_PORTS;
// INIT_WDT;
INIT_TIMER;
#ifdef USE_POTENTIOMETER
INIT_ADC;
#else
INIT_INPUT_CAPTURE;
#endif
INIT_UART;
INIT_SPI;
INIT_PWM;
INIT_I2C;
INIT_CAN;
INIT_SKADI;
START_INTERRUPTS;
// Send ID to backplane by CAN protocol
SEND_ID_TO_BACKPLANE;
Timer.DelayMs(10);
// Send the mode of operation to the steering wheel
SEND_MODE_TO_STEERING_WHEEL;
// Get last known position of the mast
ReadMastPosFromEeprom();
if (AbsFloat(mastAngle.currentValue) > 360) // Error
{
mastAngle.previousValue = 0;
mastAngle.currentValue = 0;
}
#ifdef USE_POTENTIOMETER
if (potValues.lastAverage > ADC_TOTAL_BITS)
{
potValues.lastAverage = ADC_TOTAL_BITS << 1;
}
if (potValues.zeroInBits > ADC_TOTAL_BITS)
{
potValues.zeroInBits = ADC_TOTAL_BITS << 1;
}
if (potValues.potStepValue > POT_TO_MOTOR_RATIO)
{
potValues.potStepValue = POT_TO_MOTOR_RATIO << 1;
}
if (potValues.lastBits > (ADC_BITS_PER_REVOLUTION - 1))
{
potValues.lastBits = 0;
}
PotAddFirstSample(&potValues);
// potValues.potSamples.lineBuffer.buffer[potValues.potSamples.maxBufSize] = potValues.lastAverage;
// potValues.potStepSamples.lineBuffer.buffer[potValues.potStepSamples.maxBufSize] = potValues.potStepValue;
#endif
// Init registers for the drive
InitDriver();
#ifdef USE_POTENTIOMETER
potValues.angle = &mastAngle;
potValues.speed = &mastSpeed;
#endif
}
/*** UpdateMotorControl
**
** Synopsis:
** PutChUart1(ch)
**
** Parameters:
** posX - x position of the right joystick
** posY - y position of the right joystick
**
** Return Values:
** none
**
** Errors:
** none
**
** Description:
** This routine will update the motor controller based on the
** current X and Y position of the right joystick of the controller.
*/
void UpdateMotorControl( HWORD posX, HWORD posY )
{
static HWORD tusMtrLeftDcSav = dtcMtrStopped; // stopped
static HWORD tusMtrRightDcSav = dtcMtrStopped; // stopped
static BYTE dirMtrLeftSav = dirMtrLeftFwd;
static BYTE dirMtrRightSav = dirMtrRightFwd;
HWORD tusMtrLeftFbNew;
HWORD tusMtrRightFbNew;
// Determine motor direction and speed based on joystick position.
if ( posYMax < posY ) {
if ( posXMax < posX ) {
// Go forward and left.
MtrCtrlFwdLeft();
}
else if ( posXMin > posX ) {
// Go backward and left.
MtrCtrlBwdLeft();
}
else {
// Go left.
MtrCtrlLeft();
}
}
else if ( posYMin > posY ) {
if ( posXMax < posX ) {
// Go forward and right.
MtrCtrlFwdRight();
}
else if ( posXMin > posX ) {
// Go backward and right.
MtrCtrlBwdRight();
}
else {
// Go right.
MtrCtrlRight();
}
}
else {
if ( posXMax < posX ) {
// Go forward.
MtrCtrlFwd();
}
else if ( posXMin > posX ) {
// Go backward.
MtrCtrlBwd();
}
else {
MtrCtrlStop();
// Stop.
}
}
// Update left motor speed if necessary.
if ( tusMtrLeftDcSav != dtcMtrLeft ) {
// 1. disable left motor feedback.
INTDisableInterrupts();
fMtrLeftFb = fFalse;
INTEnableInterrupts();
if ( dtcMtrStopped != dtcMtrLeft ) {
// 3. update left motor feedback
tusMtrLeftFb = tusMtrLeftFbNew;
// 4. re-enable left motor feedback.
INTDisableInterrupts();
fMtrLeft = fFalse;
fMtrLeftFb = fTrue;
INTEnableInterrupts();
// 5. enable feedback watchdog
T1CONSET = ( 1 << 15 );
}
else {
// 2. update left motor duty cycle.
OC1RS = dtcMtrLeft;
// Disable feedback watchdog.
T1CONCLR = ( 1 << 15 );
TMR1 = 0;
IFS0CLR = ( 1 << 4 );
}
tusMtrLeftDcSav = dtcMtrLeft;
}
// Update right motor speed if necessary.
if ( tusMtrRightDcSav != dtcMtrRight ) {
// 1. disable right motor feedback.
INTDisableInterrupts();
fMtrRightFb = fFalse;
INTEnableInterrupts();
if ( dtcMtrStopped != dtcMtrRight ) {
// 3. update right motor feedback.
tusMtrRightFb = tusMtrRightFbNew;
// 4. re-enable right motor feedback.
INTDisableInterrupts();
fMtrRight = fFalse;
fMtrRightFb = fTrue;
INTEnableInterrupts();
// 5. enable feedback watchdog
T1CONSET = ( 1 << 15 );
}
else {
// 2. update right motor duty cycle.
OC4RS = dtcMtrRight;
}
tusMtrRightDcSav = dtcMtrRight;
}
// Update left motor direction if necessary.
if ( dirMtrLeftSav != dirMtrLeft ) {
OC1CONCLR = ( 1 << 15 ); // Disable output compare module 1
// to release I/O pin control of enable
// signal.
trisMtrLeftEnClr = ( 1 << bnMtrLeftEn ); // Set enable pin as a digital output.
prtMtrLeftEnClr = ( 1 << bnMtrLeftEn ); // Drive enable pin low.
if ( dirMtrLeftFwd == dirMtrLeft ) {
prtMtrLeftDirSet = ( 1 << bnMtrLeftDir );
}
else {
prtMtrLeftDirClr = ( 1 << bnMtrLeftDir );
}
OC1CONSET = ( 1 << 15 ); // Re-enable output compare module 1.
dirMtrLeftSav = dirMtrLeft; // Save the current direction of the
// left motor.
}
// Update right motor direction if necessary.
if ( dirMtrRightSav != dirMtrRight ) {
OC4CONCLR = ( 1 << 15 ); // Disable output compare module 4
// to release I/O pin control of enable
// signal.
trisMtrRightEnClr = ( 1 << bnMtrRightEn ); // Set enable pin as a digital output.
prtMtrRightEnClr = ( 1 << bnMtrRightEn ); // Drive enable pin low.
if ( dirMtrRightFwd == dirMtrRight ) {
prtMtrRightDirClr = ( 1 << bnMtrRightDir );
}
else {
prtMtrRightDirSet = ( 1 << bnMtrRightDir );
}
OC4CONSET = ( 1 << 15 ); // Re-enable output compare module 4.
dirMtrRightSav = dirMtrRight; // Save the current direciton of the
// right motor.
}
}
void BSP_IntDisAll (void)
{
INTDisableInterrupts();
}
void ClearExternalIO(void) {
int i;
// GS I2C Start
i2c_disable();
i2c_slave_disable();
// GS I2C End
if (SerialConsole != 1) SerialClose(1);
if (SerialConsole != 2) SerialClose(2);
if (SerialConsole != 3) SerialClose(3);
if (SerialConsole != 4) SerialClose(4);
// stop the sound
SoundPlay = 0;
CloseTimer2();
#ifdef OLIMEX
CloseOC1();
#else
CloseOC2();
#endif
inttbl[NBRPINS + 2].intp = NULL; // disable the tick interrupt
for (i = 1; i < NBRPINS + 1; i++) {
inttbl[i].intp = NULL; // disable all interrupts
#ifdef OLIMEX
#ifdef OLIMEX_DUINOMITE_EMEGA
if (ExtCurrentConfig[i] != EXT_CONSOLE_RESERVED && i != 35 ) { // don't reset the serial console
#else
if (ExtCurrentConfig[i] != EXT_CONSOLE_RESERVED && i != 21 ) { // don't reset the serial console
#endif
#else
if (ExtCurrentConfig[i] != EXT_CONSOLE_RESERVED) { // don't reset the serial console
#endif
ExtCfg(i, EXT_NOT_CONFIG); // all set to unconfigured
ExtSet(i, 0); // all outputs (when set) default to low
}
}
InterruptReturn = NULL;
}
/****************************************************************************************************************************
Initialise the I/O pins
*****************************************************************************************************************************/
void initExtIO(void) {
int i;
for (i = 1; i < NBRPINS + 1; i++) {
ExtCfg(i, EXT_NOT_CONFIG); // all set to unconfigured
ExtSet(i, 0); // all outputs (when set) default to low
}
#ifndef OLIMEX
CNCONbits.ON = 1; // turn on Change Notification module
CNPUEbits.CNPUE1 = 1; // turn on the pullup for pin C13 also called CN1
#endif
ExtCurrentConfig[0] = EXT_DIG_IN; // and show that we can read from it
P_LED_TRIS = P_OUTPUT; // make the LED pin an output
ExtSet(0, 0); // and turn it off
#ifdef OLIMEX
#ifdef OLIMEX_DUINOMITE_EMEGA
ExtCurrentConfig[35] = EXT_ANA_IN;
#else
ExtCurrentConfig[21] = EXT_ANA_IN;
#endif
#endif
// setup the analog (ADC) function
AD1CON1 = 0x00E0; // automatic conversion after sampling
AD1CSSL = 0; // no scanning required
AD1CON2 = 0; // use MUXA, use AVdd & AVss as Vref+/-
AD1CON3 = 0x203; //0x1F3F; // Tsamp = 32 x Tad;
AD1CON1bits.ADON = 1; // turn on the ADC
}
/****************************************************************************************************************************
Configure an I/O pin
Returns true if all is OK
*****************************************************************************************************************************/
int ExtCfg(int pin, int cfg) {
int tris, ana, oc;
if (pin < 0 || pin > NBRPINS) return false; // initial sanity check
// make sure that interrupts are disabled in case we are changing from an interrupt input
#ifdef OLIMEX
// if (pin == 5) ConfigINT2(EXT_INT_PRI_2 | RISING_EDGE_INT | EXT_INT_DISABLE);
// if (pin == 6) ConfigINT3(EXT_INT_PRI_2 | RISING_EDGE_INT | EXT_INT_DISABLE);
#ifdef OLIMEX_DUINOMITE_EMEGA
#else
if (pin == 7) ConfigINT4(EXT_INT_PRI_2 | RISING_EDGE_INT | EXT_INT_DISABLE);
#endif
#else
if (pin == 11) ConfigINT1(EXT_INT_PRI_2 | RISING_EDGE_INT | EXT_INT_DISABLE);
if (pin == 12) ConfigINT2(EXT_INT_PRI_2 | RISING_EDGE_INT | EXT_INT_DISABLE);
if (pin == 13) ConfigINT3(EXT_INT_PRI_2 | RISING_EDGE_INT | EXT_INT_DISABLE);
if (pin == 14) ConfigINT4(EXT_INT_PRI_2 | RISING_EDGE_INT | EXT_INT_DISABLE);
#endif
inttbl[pin].intp = NULL; // also disable a software interrupt on this pin
switch (cfg) {
case EXT_NOT_CONFIG:
// #ifdef OLIMEX
// if (pin == 5) {P_E5_TRIS = 1; P_E5_OC = 1;}
// if (pin == 6) {P_E6_TRIS = 1; P_E6_OC = 1;}
// if (pin == 11) {P_E11_TRIS = 1; P_E11_OC = 1;}
// if (pin == 12) {P_E12_TRIS = 1; P_E12_OC = 1;}
// #endif
tris = 1; ana = 1; oc = 1;
break;
case EXT_ANA_IN:
// #ifdef OLIMEX
if (pin > 6 && pin < 19) return false;
// if (pin == 5) {P_E5_TRIS = 1; P_E5_OC = 1;}
// if (pin == 6) {P_E6_TRIS = 1; P_E6_OC = 1;}
// #else
// if (pin > 10) return false;
// #endif
tris = 1; ana = 0; oc = 1;
break;
case EXT_FREQ_IN: // same as counting, so fall through
case EXT_PER_IN: // same as counting, so fall through
case EXT_CNT_IN:
// #ifdef OLIMEX
// #else
// if (pin == 11) {
// INT1Count = INT1Value = 0;
// ConfigINT1(EXT_INT_PRI_2 | RISING_EDGE_INT | EXT_INT_ENABLE);
// tris = 1; ana = 1; oc = 1;
// break;
// }
// #endif
// #ifdef OLIMEX
// if (pin == 5) {
// P_E5_TRIS = 1;
// P_E5_OC = 1;
// #else
// if (pin == 12) {
// #endif
// INT2Count = INT2Value = 0;
// ConfigINT2(EXT_INT_PRI_2 | RISING_EDGE_INT | EXT_INT_ENABLE);
// tris = 1; ana = 1; oc = 1;
// break;
// }
// #ifdef OLIMEX
// if (pin == 6) {
// P_E6_TRIS = 1;
// P_E6_OC = 1;
// #else
// if (pin == 13) {
// #endif
// INT3Count = INT3Value = 0;
// ConfigINT3(EXT_INT_PRI_2 | RISING_EDGE_INT | EXT_INT_ENABLE);
// tris = 1; ana = 1; oc = 1;
// break;
// }
#ifdef OLIMEX_DUINOMITE_EMEGA
break;
#else
#ifdef OLIMEX
if (pin == 7) {
#else
if (pin == 14) {
#endif
INT4Count = INT4Value = 0;
ConfigINT4(EXT_INT_PRI_2 | RISING_EDGE_INT | EXT_INT_ENABLE);
tris = 1; ana = 1; oc = 1;
break;
}
return false; // not an interrupt enabled pin
#endif
case EXT_INT_LO: // same as digital input, so fall through
case EXT_INT_HI: // same as digital input, so fall through
case EXT_DIG_IN:
#ifdef OLIMEX
// if (pin == 5) {P_E5_TRIS = 1; P_E5_OC = 1;}
// if (pin == 6) {P_E6_TRIS = 1; P_E6_OC = 1;}
// if (pin == 11) {P_E11_TRIS = 1; P_E11_OC = 1;}
// if (pin == 12) {P_E12_TRIS = 1; P_E12_OC = 1;}
#endif
tris = 1; ana = 1; oc = 1;
break;
case EXT_DIG_OUT:
#ifdef OLIMEX
// if (pin == 11) {P_E11_TRIS = 1; P_E11_OC = 1;} //return false;
// if (pin == 5) {P_E5_TRIS = 1; P_E5_OC = 1;}
// if (pin == 6) {P_E6_TRIS = 1; P_E6_OC = 1;}
// if (pin == 12) {P_E12_TRIS = 1; P_E12_OC = 1;}
#endif
tris = 0; ana = 1; oc = 0;
break;
case EXT_OC_OUT:
#ifdef OLIMEX
// if (pin == 11) {P_E11_TRIS = 1; P_E11_OC = 1;} //return false;
// if (pin == 5) {P_E5_TRIS = 1; P_E5_OC = 1;}
// if (pin == 6) {P_E6_TRIS = 1; P_E6_OC = 1;}
// if (pin == 12) {P_E12_TRIS = 1; P_E12_OC = 1;}
#else
if (pin < 11) return false;
#endif
tris = 0; ana = 1; oc = 1;
break;
case EXT_COM_RESERVED:
case EXT_CONSOLE_RESERVED:
ExtCurrentConfig[pin] = cfg; // don't do anything except set the config type
#ifdef OLIMEX
// if (pin == 5) {P_E5_TRIS = 1; P_E5_OC = 1; P_E5_ANALOG = 1;}
// if (pin == 6) {P_E6_TRIS = 1; P_E6_OC = 1; P_E6_ANALOG = 1;}
// if (pin == 11) {P_E11_TRIS = 1; P_E11_OC = 1;}
// if (pin == 12) {P_E12_TRIS = 1; P_E12_OC = 1;}
#endif
return true;
default:
return false;
}
ExtCurrentConfig[pin] = cfg;
// set the TRIS and analog characteristics
switch (pin) {
case 1: P_E1_TRIS = tris; P_E1_OC = oc; P_E1_ANALOG = ana; break;
case 2: P_E2_TRIS = tris; P_E2_OC = oc; P_E2_ANALOG = ana; break;
case 3: P_E3_TRIS = tris; P_E3_OC = oc; P_E3_ANALOG = ana; break;
case 4: P_E4_TRIS = tris; P_E4_OC = oc; P_E4_ANALOG = ana; break;
case 5: P_E5_TRIS = tris; P_E5_OC = oc; P_E5_ANALOG = ana; break;
case 6: P_E6_TRIS = tris; P_E6_OC = oc; P_E6_ANALOG = ana; break;
#ifdef OLIMEX
#ifdef OLIMEX_DUINOMITE_EMEGA
case 7: P_E7_TRIS = tris; P_E7_OC = oc; P_E7_ANALOG = ana; break;
case 8: P_E8_TRIS = tris; P_E8_OC = oc; break;
case 9: P_E9_TRIS = tris; P_E9_OC = oc; break;
case 10: P_E10_TRIS = tris; P_E10_OC = oc; break;
#else
case 7: P_E7_TRIS = tris; P_E7_OC = oc; break;
case 8: if (!S.SDEnable) { P_E8_TRIS = tris; P_E8_OC = oc;} break;
case 9: if (!S.SDEnable) { P_E9_TRIS = tris; P_E9_OC = oc;} break;
case 10: if (!S.SDEnable) { P_E10_TRIS = tris; P_E10_OC = oc;} break;
#endif
#else
case 7: P_E7_TRIS = tris; P_E7_OC = oc; P_E7_ANALOG = ana; break;
case 8: P_E8_TRIS = tris; P_E8_OC = oc; P_E8_ANALOG = ana; break;
case 9: P_E9_TRIS = tris; P_E9_OC = oc; P_E9_ANALOG = ana; break;
case 10: P_E10_TRIS = tris; P_E10_OC = oc; P_E10_ANALOG = ana; break;
#endif
case 11: P_E11_TRIS = tris; P_E11_OC = oc; break;
case 12: P_E12_TRIS = tris; P_E12_OC = oc; break;
case 13: P_E13_TRIS = tris; P_E13_OC = oc; break;
case 14: P_E14_TRIS = tris; P_E14_OC = oc; break;
case 15: P_E15_TRIS = tris; P_E15_OC = oc; break;
case 16: P_E16_TRIS = tris; P_E16_OC = oc; break;
case 17: P_E17_TRIS = tris; P_E17_OC = oc; break;
case 18: P_E18_TRIS = tris; P_E18_OC = oc; break;
#ifdef OLIMEX
// SPP +
#ifdef OLIMEX_DUINOMITE_EMEGA // edit for DuinoMite eMega
case 19: P_E19_TRIS = tris; P_E19_OC = oc; break;
case 20: P_E20_TRIS = tris; P_E20_OC = oc; break;
case 21: P_E21_TRIS = tris; P_E21_OC = oc; break;
case 22: P_E22_TRIS = tris; P_E22_OC = oc; break;
case 23: P_E23_TRIS = tris; P_E23_OC = oc; break;
case 24: P_E24_TRIS = tris; P_E24_OC = oc; break;
case 25: P_E25_TRIS = tris; P_E25_OC = oc; break;
case 26: P_E26_TRIS = tris; P_E26_OC = oc; break;
case 27: P_E27_TRIS = tris; P_E27_OC = oc; break;
case 28: P_E28_TRIS = tris; P_E28_OC = oc; break;
case 29: P_E29_TRIS = tris; P_E29_OC = oc; break;
case 30: P_E30_TRIS = tris; P_E30_OC = oc; break;
case 31: P_E31_TRIS = tris; P_E31_OC = oc; P_E31_ANALOG = ana; break;
case 32: P_E32_TRIS = tris; P_E32_OC = oc; P_E31_ANALOG = ana; break;
case 33: P_E33_TRIS = tris; P_E33_OC = oc; break;
case 34: P_E34_TRIS = tris; P_E34_OC = oc; break;
case 35: P_E35_TRIS = tris; P_E35_OC = oc; P_E31_ANALOG = ana; break;
case 36: P_E36_TRIS = tris; P_E36_OC = oc; break;
case 37: P_E37_TRIS = tris; P_E37_OC = oc; break;
case 38: P_E38_TRIS = tris; P_E38_OC = oc; break;
case 39: P_E39_TRIS = tris; P_E39_OC = oc; break;
#else // original by Geoff Graham for DuinoMite Mega
case 19: //if (!S.VideoMode) {
P_E19_TRIS = tris; P_E19_OC = oc; P_E19_ANALOG = ana;//}
break;
case 20: if (!S.VideoMode || P_VGA_COMP) {P_E20_TRIS = tris; P_E20_OC = oc; P_E20_ANALOG = ana;} break;
case 21: P_E21_TRIS = tris; P_E21_OC = oc; P_E21_ANALOG = ana; break;
case 22: P_E22_TRIS = tris; P_E22_OC = oc; break;
case 23: P_E23_TRIS = tris; P_E23_OC = oc; break;
#endif
// SPP -
#else
case 19: P_E19_TRIS = tris; P_E19_OC = oc; break;
case 20: P_E20_TRIS = tris; P_E20_OC = oc; break;
#endif
#ifdef UBW32
case 21: P_E21_TRIS = tris; P_E21_OC = oc; break;
case 22: P_E22_TRIS = tris; P_E22_OC = oc; break;
case 23: P_E23_TRIS = tris; P_E23_OC = oc; break;
case 24: P_E24_TRIS = tris; P_E24_OC = oc; break;
case 25: P_E25_TRIS = tris; P_E25_OC = oc; break;
case 26: P_E26_TRIS = tris; P_E26_OC = oc; break;
case 27: P_E27_TRIS = tris; P_E27_OC = oc; break;
case 28: P_E28_TRIS = tris; P_E28_OC = oc; break;
case 29: P_E29_TRIS = tris; P_E29_OC = oc; break;
case 30: P_E30_TRIS = tris; P_E30_OC = oc; break;
case 31: P_E31_TRIS = tris; P_E31_OC = oc; break;
case 32: P_E32_TRIS = tris; P_E32_OC = oc; break;
case 33: P_E33_TRIS = tris; P_E33_OC = oc; break;
case 34: P_E34_TRIS = tris; P_E34_OC = oc; break;
case 35: P_E35_TRIS = tris; P_E35_OC = oc; break;
case 36: P_E36_TRIS = tris; P_E36_OC = oc; break;
case 37: P_E37_TRIS = tris; P_E37_OC = oc; break;
case 38: P_E38_TRIS = tris; P_E38_OC = oc; break;
case 39: P_E39_TRIS = tris; P_E39_OC = oc; break;
case 40: P_E40_TRIS = tris; P_E40_OC = oc; break;
case 41: P_E41_TRIS = tris; P_E41_OC = oc; break;
case 42: P_E42_TRIS = tris; P_E42_OC = oc; break;
case 43: P_E43_TRIS = tris; P_E43_OC = oc; break;
case 44: P_E44_TRIS = tris; P_E44_OC = oc; break;
case 45: P_E45_TRIS = tris; P_E45_OC = oc; break;
case 46: P_E46_TRIS = tris; P_E46_OC = oc; break;
case 47: P_E47_TRIS = tris; P_E47_OC = oc; break;
case 48: P_E48_TRIS = tris; P_E48_OC = oc; break;
case 49: P_E49_TRIS = tris; P_E49_OC = oc; break;
case 50: P_E50_TRIS = tris; P_E50_OC = oc; break;
#endif
}
if (cfg == EXT_NOT_CONFIG) ExtSet(pin, 0); // set the default output to low
return true;
}
/****************************************************************************************************************************
Set the output of a digital I/O pin
Returns true if all is OK
*****************************************************************************************************************************/
int ExtSet(int pin, int val){
val = (val != 0); // non zero is on
INTDisableInterrupts(); // setting an output bit is NOT atomic and a bit set operation
// in an interrupt could result in this set corrupting the output
switch (pin) {
#ifdef UBW32
case 0: P_LED_OUT = !val; break; // this is the LED - the UBW32 wired them upside down !!
#else
case 0: P_LED_OUT = val; break; // this is the LED
#endif
case 1: P_E1_OUT = val; break;
case 2: P_E2_OUT = val; break;
case 3: P_E3_OUT = val; break;
case 4: P_E4_OUT = val; break;
case 5: P_E5_OUT = val; break;
case 6: P_E6_OUT = val; break;
case 7: P_E7_OUT = val; break;
#ifdef OLIMEX
#ifdef OLIMEX_DUINOMITE_EMEGA
case 8: P_E8_OUT = val; break;
case 9: P_E9_OUT = val; break;
case 10: P_E10_OUT = val; break;
#else
case 8: if (!S.SDEnable) P_E8_OUT = val; break;
case 9: if (!S.SDEnable) P_E9_OUT = val; break;
case 10: if (!S.SDEnable) P_E10_OUT = val; break;
#endif
#else
case 8: P_E8_OUT = val; break;
case 9: P_E9_OUT = val; break;
case 10: P_E10_OUT = val; break;
#endif
case 11: P_E11_OUT = val; break;
case 12: P_E12_OUT = val; break;
case 13: P_E13_OUT = val; break;
case 14: P_E14_OUT = val; break;
case 15: P_E15_OUT = val; break;
case 16: P_E16_OUT = val; break;
case 17: P_E17_OUT = val; break;
case 18: P_E18_OUT = val; break;
#ifdef OLIMEX
#ifdef OLIMEX_DUINOMITE_EMEGA
case 19: P_E19_OUT = val; break;
case 20: P_E20_OUT = val; break;
#else
case 19: P_E19_OUT = val; break;
case 20: if (!S.VideoMode || P_VGA_COMP) P_E20_OUT = val; break;
case 22: P_E22_OUT = val ; break;
case 23: P_E23_OUT = val ; break;
#endif
#else
case 19: P_E19_OUT = val; break;
case 20: P_E20_OUT = val; break;
#endif
#if defined UBW32 || defined OLIMEX_DUINOMITE_EMEGA
case 21: P_E21_OUT = val; break;
case 22: P_E22_OUT = val; break;
case 23: P_E23_OUT = val; break;
case 24: P_E24_OUT = val; break;
case 25: P_E25_OUT = val; break;
case 26: P_E26_OUT = val; break;
case 27: P_E27_OUT = val; break;
case 28: P_E28_OUT = val; break;
case 29: P_E29_OUT = val; break;
case 30: P_E30_OUT = val; break;
case 31: P_E31_OUT = val; break;
case 32: P_E32_OUT = val; break;
case 33: P_E33_OUT = val; break;
case 34: P_E34_OUT = val; break;
case 35: P_E35_OUT = val; break;
case 36: P_E36_OUT = val; break;
case 37: P_E37_OUT = val; break;
case 38: P_E38_OUT = val; break;
case 39: P_E39_OUT = val; break;
#endif
#ifdef UBW32
case 40: P_E40_OUT = val; break;
case 41: P_E41_OUT = val; break;
case 42: P_E42_OUT = val; break;
case 43: P_E43_OUT = val; break;
case 44: P_E44_OUT = val; break;
case 45: P_E45_OUT = val; break;
case 46: P_E46_OUT = val; break;
case 47: P_E47_OUT = val; break;
case 48: P_E48_OUT = val; break;
case 49: P_E49_OUT = val; break;
case 50: P_E50_OUT = val; break;
#endif
default:
INTEnableInterrupts();
return false;
}
INTEnableInterrupts();
return true;
}
