/*********************************************************************
* Function: void InitSymbolTimer()
*
* PreCondition: none
*
* Input: none
*
* Output: none
*
* Side Effects: TMR0 for PIC18 is configured for calculating
* the correct symbol times. TMR2/3 for PIC24/dsPIC
* is configured for calculating the correct symbol
* times
*
* Overview: This function will configure the UART for use at
* in 8 bits, 1 stop, no flowcontrol mode
*
* Note: The timer interrupt is enabled causing the timer
* roll over calculations. Interrupts are required
* to be enabled in order to extend the timer to
* 4 bytes in PIC18. PIC24/dsPIC version do not
* enable or require interrupts
********************************************************************/
void InitSymbolTimer()
{
#if defined(__18CXX)
T0CON = 0b00000000 | CLOCK_DIVIDER_SETTING;
INTCON2bits.TMR0IP = 1;
INTCONbits.TMR0IF = 0;
INTCONbits.TMR0IE = 1;
T0CONbits.TMR0ON = 1;
timerExtension1 = 0;
timerExtension2 = 0;
#elif defined(__dsPIC30F__) || defined(__dsPIC33F__) || defined(__PIC24F__) || defined(__PIC24H__)
T2CON = 0b0000000000001000 | CLOCK_DIVIDER_SETTING;
T2CONbits.TON = 1;
#elif defined(__PIC32MX__)
CloseTimer2();
WriteTimer2(0x00);
WriteTimer3(0x00);
WritePeriod3(0xFFFF);
OpenTimer2((T2_ON|T2_32BIT_MODE_ON|CLOCK_DIVIDER_SETTING),0xFFFFFFFF);
#else
#error "Symbol timer implementation required for stack usage."
#endif
}
void main(void) {
uint16_t v;
uint8_t i;
int16_t pad;
uint32_t padsNow=0;
uint32_t padsLast=0;
int8_t lastKey;
uint8_t cnt=0;
uint16_t lastEncValue;
uint8_t encStep;
int16_t senseDelta;
uint8_t easteregg;
SetupBoard();
SetupCTMU();
encStep=1;
encValue=0;
lastEncValue=0;
octave=3;
encMin=0;
encMax=14;
senseDelta=99;
OpenTimer4(TIMER_INT_ON & T4_PS_1_1 & T4_POST_1_1); // Timer4 - Rotary Encoder polling
WriteTimer4(0xFF);
TMR4IF=0;
OpenTimer2(TIMER_INT_ON & T2_PS_1_4 & T2_POST_1_8); // Timer2 = Display Refresh
WriteTimer2(0xFF);
TMR2IF=0;
GIE=1;
PEIE=1;
ei();
disp[0]=0x00;
disp[1]=0x00;
disp[2]=0x00;
keys=0;
easteregg=0;
leds=0x7fff;
__delay_ms(25);
leds=0x0000;
CalibratePads();
leds=0x7fff;
__delay_ms(25);
leds=0x0000;
//
// encMin=1;
// encMax=24;
// encValue=1;
// for (;;) {
// pad=ReadPad(encValue);
// DispValue(pad);
// leds=0;
// if ((encValue>=1) && (encValue<=9)) {setbit(leds,encValue-1); setbit(leds,10);}
// if ((encValue>=10) && (encValue<=19)) {setbit(leds,encValue-10);setbit(leds,11);}
// if ((encValue>=20) && (encValue<=29)) {setbit(leds,encValue-20);setbit(leds,12);}
// __delay_ms(25);
// }
for (;;) {
// Check for tones H+A+D
if (padsLast==0b000000000000101000000100) EasterEgg(1);
if (padsLast==0b101000000100000000000000) EasterEgg(2);
padsNow=0;
for (i=0; i<PADS; i++) {
pad=ReadPad(i);
if (GetPadBaseValue(i)-pad>senseDelta) {
setbit(padsNow,i);
}
}
for (i=0; i<PADS; i++) {
if (testbit(padsNow,i) != testbit(padsLast,i)) {
if (testbit(padsNow,i)) {
SendNoteOn(octave*12+i);
} else {
SendNoteOff(octave*12+i);
}
}
}
padsLast=padsNow;
for (i=0; i<KEYS; i++) {
if (testbit(keys,i)) {
disp[0]=charmap[butSettings[i].txt[0]-32];
disp[1]=charmap[butSettings[i].txt[1]-32];
disp[2]=charmap[butSettings[i].txt[2]-32];
lastKey=i;
encMin=butSettings[i].min;
encMax=butSettings[i].max;
encValue=butSettings[i].value;
encStep=butSettings[i].stepSize;
lastEncValue=encValue;
break;
}
}
if ((encValue!=lastEncValue) && (lastKey!=-1)) {
lastEncValue=encValue;
if (butSettings[lastKey].cc==127) { // OCTAVE
DispValue(encValue*encStep);
octave=encValue;
butSettings[lastKey].value=encValue;
DispValue(encValue*encStep);
} else if (butSettings[lastKey].cc==126) { // SENSE DELTA
senseDelta=encValue;
butSettings[lastKey].value=senseDelta;
DispValue(senseDelta);
if (senseDelta&1) setbit(leds,0); else clrbit(leds,0);
} else {
SendCC(butSettings[lastKey].cc, encValue*encStep);
DispValue(encValue*encStep);
}
}
__delay_ms(10);
}
}
//*********************************************************************
//* PWM output only works on the pins with hardware support.
//* These are defined in the appropriate pins_*.c file.
//* For the rest of the pins, we default to digital output.
//*********************************************************************
void analogWrite(uint8_t pin, int val)
{
// We need to make sure the PWM output is enabled for those pins
// that support it, as we turn it off when digitally reading or
// writing with them. Also, make sure the pin is in output mode
// for consistenty with Wiring, which doesn't require a pinMode
// call for the analog output pins.
pinMode(pin, OUTPUT);
if (val == 0)
{
digitalWrite(pin, LOW);
}
else if (val == 255)
{
digitalWrite(pin, HIGH);
}
else
{
switch(digitalPinToTimer(pin))
{
#ifdef _OCMP1
case TIMER_OC1:
//* Open Timer2 with Period register value
OpenTimer2(T2_ON | T2_PS_1_256, PWM_TIMER_PERIOD);
OpenOC1( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, (PWM_TIMER_PERIOD*val)/256, (PWM_TIMER_PERIOD*val)/256 );
//Set duty cycle on fly
SetDCOC1PWM((PWM_TIMER_PERIOD*val)/256);
break;
#endif
#ifdef _OCMP2
case TIMER_OC2:
//* Open Timer2 with Period register value
OpenTimer2(T2_ON | T2_PS_1_256, PWM_TIMER_PERIOD);
OpenOC2( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, (PWM_TIMER_PERIOD*val)/256, (PWM_TIMER_PERIOD*val)/256 );
//Set duty cycle on fly
SetDCOC2PWM((PWM_TIMER_PERIOD*val)/256);
break;
#endif
#ifdef _OCMP3
case TIMER_OC3:
//* Open Timer2 with Period register value
OpenTimer2(T2_ON | T2_PS_1_256, PWM_TIMER_PERIOD);
OpenOC3( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, (PWM_TIMER_PERIOD*val)/256, (PWM_TIMER_PERIOD*val)/256 );
//Set duty cycle on fly
SetDCOC3PWM((PWM_TIMER_PERIOD*val)/256);
break;
#endif
#ifdef _OCMP4
case TIMER_OC4:
//* Open Timer2 with Period register value
OpenTimer2(T2_ON | T2_PS_1_256, PWM_TIMER_PERIOD);
OpenOC4( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, (PWM_TIMER_PERIOD*val)/256, (PWM_TIMER_PERIOD*val)/256 );
//Set duty cycle on fly
SetDCOC4PWM((PWM_TIMER_PERIOD*val)/256);
break;
#endif
#ifdef _OCMP5
case TIMER_OC5:
//* Open Timer2 with Period register value
OpenTimer2(T2_ON | T2_PS_1_256, PWM_TIMER_PERIOD);
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, (PWM_TIMER_PERIOD*val)/256, (PWM_TIMER_PERIOD*val)/256 );
//Set duty cycle on fly
SetDCOC5PWM((PWM_TIMER_PERIOD*val)/256);
break;
#endif
#if 0
//* this is the original code, I want to keep it around for refernce for a bit longer
#ifdef _OCMP1
case TIMER_OC1:
//* Open Timer2 with Period register value
OpenTimer2(T2_ON | T2_PS_1_256, PWM_TIMER_PERIOD);
OpenOC1( OC_ON | OC_TIMER_MODE32 | OC_TIMER2_SRC | OC_CONTINUE_PULSE | OC_LOW_HIGH, 256, (256 - val) );
// SetDCOC1PWM((PWM_TIMER_PERIOD * val) / 256);
break;
#endif
#ifdef _OCMP2
case TIMER_OC2:
//* Open Timer2 with Period register value
OpenTimer2(T2_ON | T2_PS_1_256, PWM_TIMER_PERIOD);
OpenOC2( OC_ON | OC_TIMER_MODE32 | OC_TIMER2_SRC | OC_CONTINUE_PULSE | OC_LOW_HIGH, 256, (256 - val) );
// SetDCOC2PWM((PWM_TIMER_PERIOD * val) / 256);
break;
#endif
#ifdef _OCMP3
case TIMER_OC3:
//* Open Timer2 with Period register value
OpenTimer2(T2_ON | T2_PS_1_256, PWM_TIMER_PERIOD);
OpenOC3( OC_ON | OC_TIMER_MODE32 | OC_TIMER2_SRC | OC_CONTINUE_PULSE | OC_LOW_HIGH, 256, (256 - val) );
// SetDCOC3PWM((PWM_TIMER_PERIOD * val) / 256);
break;
#endif
#ifdef _OCMP4
case TIMER_OC4:
//* Open Timer2 with Period register value
OpenTimer2(T2_ON | T2_PS_1_256, PWM_TIMER_PERIOD);
OpenOC4( OC_ON | OC_TIMER_MODE32 | OC_TIMER2_SRC | OC_CONTINUE_PULSE | OC_LOW_HIGH, 256, (256 - val) );
// SetDCOC4PWM((PWM_TIMER_PERIOD * val) / 256);
break;
#endif
#ifdef _OCMP5
case TIMER_OC5:
//* Open Timer2 with Period register value
OpenTimer2(T2_ON | T2_PS_1_256, PWM_TIMER_PERIOD);
OpenOC5( OC_ON | OC_TIMER_MODE32 | OC_TIMER2_SRC | OC_CONTINUE_PULSE | OC_LOW_HIGH, 256, (256 - val) );
// SetDCOC5PWM((PWM_TIMER_PERIOD * val) / 256);
break;
#endif
#endif
case NOT_ON_TIMER:
default:
if (val < 128)
{
digitalWrite(pin, LOW);
}
else
{
digitalWrite(pin, HIGH);
}
}
}
}
void ResetDevice(void)
{
DMACONbits.SUSPEND =1; //Suspend ALL DMA transfers
BMXCONbits.BMXARB = 0x02; //Faster Refresh Rate
BMXCONbits.BMXCHEDMA = 1;
LCD_DC_TRIS =0;
HSYNC_TRIS =0;
LCD_CS_TRIS =0;
VSYNC_TRIS =0;
LCD_RESET_TRIS =0;
BACKLIGHT_TRIS=0;
DATA_ENABLE_TRIS=0;
SRAM_TRIS =0;
ADDR15_TRIS=0;
ADDR16_TRIS=0;
ADDR17_TRIS =0;
ADDR18_TRIS =0;
LCD_RESET =1;
LCD_CS =1;
LCD_DC =1;
SRAM_CS =0;
ADDR17 =0;
ADDR18 =0;
PIXELCLOCK_TRIS =0;
#ifdef DISP_INV_LSHIFT
PIXELCLOCK =1;
#else
PIXELCLOCK =0;
#endif
#if defined(USE_TCON_MODULE)
GfxTconInit();
#endif
// setup the PMP
mPMPOpen(PMP_CONTROL, PMP_MODE, PMP_ADDRESS_LINES, PMP_INT_ON);
PMADDR = 0x0000;
// Open the desired DMA channel.
DmaChnOpen(1, 0, DMA_OPEN_DEFAULT);
// set the transfer event control: what event is to start the DMA transfer
DmaChnSetEventControl(1, DMA_EV_START_IRQ(_TIMER_2_IRQ));
// set the transfer parameters: source & destination address, source & destination size, number of bytes per event
#ifdef LCC_INTERNAL_MEMORY
BACKLIGHT =0; //Turn Backlight on
#ifdef USE_PALETTE
DmaChnSetTxfer(1, &GraphicsFrame[0], (void*)&PMDIN, HBackPorch, 2, 2);
#else
DmaChnSetTxfer(1, &GraphicsFrame[0], (void*)&PMDIN, HBackPorch, 1, 2);
#endif
#else
#if defined(GFX_USE_DISPLAY_PANEL_TFT_G240320LTSW_118W_E)
BACKLIGHT =0; //Turn Backlight on
DmaChnSetTxfer(1, (void*)&PMDIN ,&GraphicsFrame[0] , 1, HBackPorch, 2);
#else
BACKLIGHT =1;
DmaChnSetTxfer(1, (void*)&PMDIN ,&GraphicsFrame[0] , 1, HBackPorch, 16);
#endif
#endif
INTSetVectorPriority(INT_VECTOR_DMA(1), INT_PRIORITY_LEVEL_6); // set INT controller priority
DmaChnSetEvEnableFlags(1, DMA_EV_BLOCK_DONE); // enable the transfer done interrupt, when all buffer transferred
INTEnable(INT_SOURCE_DMA(1), INT_ENABLED); // enable the chn interrupt in the INT controller
DCH1CONbits.CHPRI = 0b11; //DMA channel has highest priority
// once we configured the DMA channel we can enable it
DmaChnEnable(1);
#ifdef LCC_INTERNAL_MEMORY
#ifdef USE_PALETTE
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_1, 70); //Start Timer
#else
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_1, 27); //Start Timer
#endif
#else //External Memory
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_1, 2); //Start Timer
#endif
DMACONbits.SUSPEND = 0;
#ifdef USE_DOUBLE_BUFFERING
// initialize double buffering feature
blInvalidateAll = 1;
blDisplayUpdatePending = 0;
NoOfInvalidatedRectangleAreas = 0;
_drawbuffer = GFX_BUFFER1;
SetActivePage(_drawbuffer);
SwitchOnDoubleBuffering();
#endif //USE_DOUBLE_BUFFERING
}
int main(void) {
timesec=0;
// set PIC32 to max computing power
SYSTEMConfig(SYS_FREQ, SYS_CFG_ALL);
INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
INTEnableSystemMultiVectoredInt();
initLEDs();
LED0 = 1;
LED1 = 1;
initSerialNU32v2();
setup_counters();
CloseADC10();
#define PARAM1 ADC_MODULE_ON | ADC_FORMAT_INTG | ADC_CLK_AUTO | ADC_AUTO_SAMPLING_ON
#define PARAM2 ADC_VREF_AVDD_AVSS | ADC_OFFSET_CAL_DISABLE | ADC_SCAN_ON | ADC_SAMPLES_PER_INT_16 | ADC_ALT_BUF_OFF | ADC_ALT_INPUT_OFF
#define PARAM3 ADC_CONV_CLK_INTERNAL_RC | ADC_SAMPLE_TIME_31
#define PARAM4 ENABLE_AN0_ANA | ENABLE_AN1_ANA | ENABLE_AN2_ANA | ENABLE_AN3_ANA | ENABLE_AN5_ANA | ENABLE_AN15_ANA
OpenADC10( PARAM1, PARAM2, PARAM3, PARAM4,0);
EnableADC10();
// Setup and turn off electromagnets
EMAG1 = 0; EMAG2 = 0;
TRISEbits.TRISE7 = 0; TRISCbits.TRISC1 = 0;
//Direction Output
DIR = 1;
TRISAbits.TRISA9 = 0;
//g-select Outputs
GSEL1 = 0; GSEL2 = 0;
TRISEbits.TRISE2 = 0; TRISCbits.TRISC13= 0;
//0g Inputs
TRISAbits.TRISA0 = 1;
TRISAbits.TRISA4 = 1;
// 20kHz PWM signal, duty from 0-1000, pin D3
OpenTimer2(T2_ON | T2_PS_1_4, 1000);
OpenOC4(OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
HBridgeDuty = 0;
SetDCOC4PWM(HBridgeDuty);
// 20Hz ISR
OpenTimer3(T3_ON | T3_PS_1_256, 15625);
mT3SetIntPriority(1);
mT3ClearIntFlag();
mT3IntEnable(1);
while(1) {
if(start){
EMAG2=0;
SetDCOC4PWM(100);
delaysec(delay1);
SetDCOC4PWM(1000);
delaysec(delay2);
SetDCOC4PWM(500);
delaysec(delay3);
EMAG2=1;
SetDCOC4PWM(0);
// EMAG1=0;
// SetDCOC4PWM(900);
// DIR = 0;
// delaysec(delay1);
// SetDCOC4PWM(0);
// delaysec(delay2);
// SetDCOC4PWM(700);
// delaysec(delay1);
// SetDCOC4PWM(1000);
// EMAG1=1;
start=0;
}
}
}
int main(void)
{
BOARD_Init();
SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
SERIAL_Init();
SPI_Init(SPI_SS1_CLKRATE, 0, 0);
TIMERS_Init();
printf("program begins...\n");
uint16_t i, j;
/* timer test: sucess
SET_OUTPUT_PIN(D, 10);
TIMERS_Init();
while (1) {
WRITE_HIGH(D, 10);
InitTimer(1, 100);
while (IsTimerActive(1));
WRITE_LOW(D, 10);
InitTimer(1, 100);
while (IsTimerActive(1)) ;
}
//*/
/* SPI read test 1: need to get 0x70 to ensure SPI reading is good
printf("IMU: SPI read test 1\n");
IMU_Init();
uint8_t id;
while (1) {
id = MPU6500_readOneByte( MPU6500_RA_WHO_AM_I );
printf( "id should be 0x70: 0x%x\n", id );
InitTimer(1, 1000);
while (IsTimerActive(1)) ;
}
//*/
/* SPI read test 2: need to get 0x70 to ensure SPI reading is good
printf("IMU: SPI read test 2\n");
IMU_Init();
uint8_t id;
while (1) {
MPU6500_readBytes(SPI_SS2_ID, MPU6500_RA_WHO_AM_I, 1, &id);
printf( "id should be 0x70: 0x%x\n", id );
InitTimer(1, 1000);
while (IsTimerActive(1)) ;
}
//*/
/* inv_mpu test: porting invense IMU library
printf("inv_mpu test: read test\n");
uint8_t buf[3] = {0};
uint8_t flag;
while (1) {
flag = mpu_read_reg(MPU6500_RA_WHO_AM_I, buf);
printf("flag: %d\n", flag);
printf( "id should be 0x70: 0x%x\n", buf[0]);
InitTimer(2, 1000);
while (IsTimerActive(2)) {
//printf("timer is still active\n");
}
}
//*/
/* porting inv_mpu test: init and read gyro
printf("inv_mpu test: read test\n");
uint16_t buf[3] = {0};
uint8_t flag = mpu_init(0);
mpu_reset_fifo();
mpu_set_sensors(INV_XYZ_GYRO|INV_XYZ_ACCEL);
mpu_configure_fifo(INV_XYZ_GYRO|INV_XYZ_ACCEL);
printf("flag: %d\n", flag);
uint16_t gyro[3], accel[3];
// flag = mpu_run_6500_self_test(gyro, accel, 0);
printf("flag=%d, gyro: % 5d, % 5d, % 5d", flag, gyro[0], gyro[1], gyro[2]);
printf(", accel: % 5d, % 5d, % 5d\n", accel[0], accel[1], accel[2]);
while (1) {
flag = mpu_get_gyro_reg(buf, 0);
printf("flag=%d, gyro: % 5d, % 5d, % 5d", flag, buf[0], buf[1], buf[2]);
mpu_get_accel_reg(buf, 0);
printf(", accel: % 5d, % 5d, % 5d\n", buf[0], buf[1], buf[2]);
InitTimer(2, 1000);
while (IsTimerActive(2));
}
//*/
/* test: reading multiple times from the same register: the internal pointer +1 when it read once
int vals;
uint16_t gyro[3], accel[3];
vals = mympu_open(200);
printf("MPU Init: %d\n", vals);
struct s_mympu mympu;
uint8_t flag;
while(1) {
mpu_get_accel_reg(accel, 0);
printf("all accel: % 5d, % 5d, % 5d\n", accel[0], accel[1], accel[2]);
uint8_t tmp = MPU6500_readOneByte(MPU6500_RA_ACCEL_XOUT_H);
accel[0] = tmp << 8;
tmp = MPU6500_readOneByte(MPU6500_RA_ACCEL_XOUT_L);
accel[0] |= tmp;
tmp = MPU6500_readOneByte(MPU6500_RA_ACCEL_YOUT_H);
accel[1] = tmp << 8;
tmp = MPU6500_readOneByte(MPU6500_RA_ACCEL_YOUT_L);
accel[1] |= tmp;
tmp = MPU6500_readOneByte(MPU6500_RA_ACCEL_ZOUT_H);
accel[2] = tmp << 8;
tmp = MPU6500_readOneByte(MPU6500_RA_ACCEL_ZOUT_L);
accel[2] |= tmp;
printf("byte accel: % 5d, % 5d, % 5d\n", accel[0], accel[1], accel[2]);
InitTimer(2, 100);
while (IsTimerActive(2));
}
//*/
/* test: reading multiple times from the same register: the internal pointer +1 when it read once
int vals;
uint8_t buf[20] = {0};
uint16_t gyro[3] = {0}, accel[3] = {0};
vals = mympu_open(200);
printf("MPU Init: %d\n", vals);
//IMU_Init();
uint8_t id = MPU6500_readOneByte( MPU6500_RA_WHO_AM_I );
printf( "id should be 0x70: 0x%x\n", id);
struct s_mympu mympu = {0};
int flag;
//MPU6500_writeOneByte( MPU6500_RA_USER_CTRL, 0x40 | 0x10 );
while(1) {
flag = mympu_update(&mympu);
//printf("yaw=[%d, %d], pitch=[%d,%d], roll=[%d,%d]\n", mympu.ypr[0], mympu.gyro[0], mympu.ypr[1], mympu.gyro[1], mympu.ypr[2], mympu.gyro[2]);
//printf("flag=%d, yaw=% 11f, pitch=% 11f, roll=% 11f\n", flag, mympu.ypr[0], mympu.ypr[1], mympu.ypr[2]);
printf("yaw=[%.3f, %.3f], pitch=[%.3f,%.3f], roll=[%.3f,%.3f]\n",
mympu.ypr[0], mympu.gyro[0], mympu.ypr[1], mympu.gyro[1], mympu.ypr[2], mympu.gyro[2]);
//flag = dmp_read_fifo(gyro, accel, buf, NULL,&vals,&vals);
//buf[0] = MPU6500_readOneByte(MPU6500_RA_FIFO_COUNTH);
//buf[1] = MPU6500_readOneByte(MPU6500_RA_FIFO_COUNTL);
//uint16_t count = (buf[0] << 8) | buf[1];
//printf("fifo count: %d\n", count);
//flag = mpu_read_fifo(gyro, accel, &vals, &vals, &vals);
//flag = mpu_read_fifo_stream(10, buf, &vals);
//read_fifo(buf, gyro, accel);
//printf("flag=%d, gyro: % 5d, % 5d, % 5d", flag, gyro[0], gyro[1], gyro[2]);
// printf(", accel: % 5d, % 5d, % 5", accel[0], accel[1], accel[2]);
//printf(", quat: %d, %d, %d, %d\n", buf[0], buf[1], buf[2], buf[3]);
InitTimer(2, 50);
while (IsTimerActive(2));
}
//*/
/* test: calibration by adding offset
int vals = mympu_open(200);
printf("MPU Init: %d\n", vals);
uint8_t id = MPU6500_readOneByte( MPU6500_RA_WHO_AM_I );
printf( "id should be 0x70: 0x%x\n", id);
struct s_mympu mympu = {0};
int flag;
printf("waiting for initial drift\n");
InitTimer(2, 20000); // wait for 20s to pass initial drift
while (IsTimerActive(2));
printf("get average offset\n");
float offsetX = 0, offsetY = 0, offsetZ = 0;
float offsetPrev[3] = {0};
float alpha = 0;
uint8_t k;
for (k=1; k <= 200; k++) {
flag = mympu_update(&mympu);
//printf("yaw=% 3.3f, pitch=% 3.3f, roll=% 3.3f\n",
//mympu.ypr[0], mympu.ypr[1], mympu.ypr[2]);
alpha = ((float) k - 1.) / k;
offsetX = alpha*offsetPrev[0] + (1. - alpha) * mympu.ypr[0];
offsetY = alpha*offsetPrev[1] + (1. - alpha) * mympu.ypr[1];
offsetZ = alpha*offsetPrev[2] + (1. - alpha) * mympu.ypr[2];
offsetPrev[0] = offsetX;
offsetPrev[1] = offsetY;
offsetPrev[2] = offsetZ;
InitTimer(2, 50);
while (IsTimerActive(2));
}
printf("average: x offset= %3.3f, y offset= %3.3f, z offset= %3.3f\n",
offsetX, offsetY, offsetZ);
//offsetX = abs(offsetX);
offsetY = abs(offsetY);
//offsetZ = abs(offsetZ);
while(1) {
flag = mympu_update(&mympu);
//printf("yaw=% 3.0f, pitch=% 3.0f, roll=% 3.0f\n",
//printf("%4.1f, %4.1f, %4.1f\n", mympu.ypr[0] - offsetX, mympu.ypr[1] - offsetY, mympu.ypr[2] - offsetZ);
printf("yaw=[%.3f, %.3f], pitch=[%.3f,%.3f], roll=[%.3f,%.3f]\n", mympu.ypr[0] - offsetX, mympu.gyro[0], mympu.ypr[1] - offsetY, mympu.gyro[1], mympu.ypr[2] - offsetZ, mympu.gyro[2]);
InitTimer(2, 50);
while (IsTimerActive(2));
}
//*/
//* test: two SPI devices, OLED and IMU
int vals = mympu_open(10);
OLED_Init();
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_1, 0x2710);
ConfigIntTimer2(T2_INT_ON | T2_INT_PRIOR_2);
printf("MPU Init: %d\n", vals);
uint8_t id = MPU6500_readOneByte( MPU6500_RA_WHO_AM_I );
printf( "id should be 0x70: 0x%x\n", id);
UG_SetForecolor(0x0F);
UG_SetBackcolor(0x00);
UG_FontSelect(FONT_6X8);
char str[50] = "";
while(1) {
//mympu_update(&mympu);
sprintf(str, "%.3f, %.3f, %.3f\n", mympu.ypr[0], mympu.ypr[1], mympu.ypr[2]);
printf("%s\n",str);
flag_writingScreen = 1;
UG_PutString(0, 0, str);
flag_writingScreen = 0;
InitTimer(1, 200);
while (IsTimerActive(1));
}
//*/
/*
flag = mpu_run_6500_self_test(gyro, accel, 0);
printf("\nflag=%d, gyro: % 5d, % 5d, % 5d", flag, gyro[0], gyro[1], gyro[2]);
printf(", accel: % 5d, % 5d, % 5d\n", accel[0], accel[1], accel[2]);
MPU6500_writeOneByte(MPU6500_RA_XA_OFFS_H, (accel[0] & 0x7F80) >> 8);
MPU6500_writeOneByte(MPU6500_RA_XA_OFFS_L_TC, accel[0] & 0x7F);
MPU6500_writeOneByte(MPU6500_RA_YA_OFFS_H, (accel[1] & 0x7F80) >> 8);
MPU6500_writeOneByte(MPU6500_RA_YA_OFFS_L_TC, accel[1] & 0x7F);
MPU6500_writeOneByte(MPU6500_RA_ZA_OFFS_H, (accel[2] & 0x7F80) >> 8);
MPU6500_writeOneByte(MPU6500_RA_ZA_OFFS_L_TC, accel[2] & 0x7F);
MPU6500_writeOneByte(MPU6500_RA_XG_OFFS_USRH, gyro[0] >> 8);
MPU6500_writeOneByte(MPU6500_RA_XG_OFFS_USRL, gyro[0] & 0xFF);
MPU6500_writeOneByte(MPU6500_RA_YG_OFFS_USRH, gyro[1] >> 8);
MPU6500_writeOneByte(MPU6500_RA_YG_OFFS_USRL, gyro[1] & 0xFF);
MPU6500_writeOneByte(MPU6500_RA_ZG_OFFS_USRH, gyro[2] >> 8);
MPU6500_writeOneByte(MPU6500_RA_ZG_OFFS_USRL, gyro[2] & 0xFF);
//*/
printf("program ended...\n");
return 0;
}
/*****************************************************************
* Function: setTime2PWM
* Input Variables: none
* Output Return: none
* Overview: Initializes the timer 2 for pusle width modulation
******************************************************************/
void setTimer2PWM()
{
OpenTimer2(TIMER_INT_OFF & T2_PS_1_1);
}
void main (void)
{
/*
Define Variables ---------------------------------------------------------------------
*/
// I2C/MSG Q variables
char c; // Is this used?
signed char length;
unsigned char msgtype;
unsigned char last_reg_recvd;
i2c_comm ic;
//unsigned char msgbuffer[MSGLEN+1];
unsigned char msgbuffer[12];
unsigned char i;
int I2C_buffer[];
int index = 0;
int ITR = 0;
int I2C_RX_MSG_COUNT = 0;
int I2C_RX_MSG_PRECOUNT = 0;
int I2C_TX_MSG_COUNT = 1;
// Timer variables
timer1_thread_struct t1thread_data; // info for timer1_lthread
timer0_thread_struct t0thread_data; // info for timer0_lthread
int timer_on = 1;
int timer2Count0 = 0, timer2Count1 = 0;
// UART variables
uart_comm uc;
//uart_thread_struct uthread_data; // info for uart_lthread
// ADC variables
int ADCVALUE = 0;
int adc_counter = 0;
int adc_chan_num = 0;
int adcValue = 0;
int count = 0;
// MIDI variable
char notePlayed;
/*
Initialization ------------------------------------------------------------------------
*/
// Clock initialization
OSCCON = 0x7C; // 16 MHz // Use for internal oscillator
OSCTUNEbits.PLLEN = 1; // 4x the clock speed in the previous line
// UART initialization
init_uart_recv(&uc); // initialize my uart recv handling code
// configure the hardware USART device
Open2USART( USART_TX_INT_OFF & USART_RX_INT_OFF & USART_ASYNCH_MODE & USART_EIGHT_BIT &
USART_CONT_RX & USART_BRGH_LOW, 31);
Open1USART( USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT &
USART_CONT_RX & USART_BRGH_LOW, 51);
//RCSTA1bits.CREN = 1;
//RCSTA1bits.SPEN = 1;
//TXSTA1bits.SYNC = 0;
//PIE1bits.RC1IE = 1;
IPR1bits.RC1IP = 0;
// I2C/MSG Q initialization
init_i2c(&ic); // initialize the i2c code
init_queues(); // initialize message queues before enabling any interrupts
i2c_configure_slave(0x9E); // configure the hardware i2c device as a slave
// Timer initialization
init_timer1_lthread(&t1thread_data); // init the timer1 lthread
OpenTimer0( TIMER_INT_ON & T0_16BIT & T0_SOURCE_INT & T0_PS_1_8);
OpenTimer2( TIMER_INT_ON & T2_PS_1_16 /*& T2_8BIT_RW & T2_SOURCE_INT & T2_OSC1EN_OFF & T2_SYNC_EXT_OFF*/); // Turn Off
// ADC initialization
// set up PORTA for input
PORTA = 0x0; // clear the port
LATA = 0x0; // clear the output latch
TRISA = 0xFF; // set RA3-RA0 to inputs
ANSELA = 0xFF;
initADC();
// Interrupt initialization
// Peripheral interrupts can have their priority set to high or low
// enable high-priority interrupts and low-priority interrupts
enable_interrupts();
// Decide on the priority of the enabled peripheral interrupts, 0 is low 1 is high
IPR1bits.TMR1IP = 0; // Timer1 interrupt
//IPR1bits.RCIP = 0; // USART RX interrupt
IPR1bits.SSP1IP = 1; // I2C interrupt
PIE1bits.SSP1IE = 1; // must specifically enable the I2C interrupts
IPR1bits.ADIP = 1; // ADC interrupt WE ADDED THIS
// set direction for PORTB to output
TRISB = 0x0;
TRISD = 0xFF;
LATB = 0x0;
ANSELC = 0x00;
/*
Hand off messages to subroutines -----------------------------------------------------------
*/
// This loop is responsible for "handing off" messages to the subroutines
// that should get them. Although the subroutines are not threads, but
// they can be equated with the tasks in your task diagram if you
// structure them properly.
while (1) {
// Call a routine that blocks until either on the incoming
// messages queues has a message (this may put the processor into
// an idle mode
block_on_To_msgqueues();
/*
High Priority MSGQ ----------------------------------------------------------------------
*/
// At this point, one or both of the queues has a message. It
// makes sense to check the high-priority messages first -- in fact,
// you may only want to check the low-priority messages when there
// is not a high priority message. That is a design decision and
// I haven't done it here.
length = ToMainHigh_recvmsg(MSGLEN,&msgtype,(void *) msgbuffer);
if (length < 0) {
// no message, check the error code to see if it is concern
if (length != MSGQUEUE_EMPTY) {
//printf("Error: Bad high priority receive, code = %x\r\n", length);
}
} else {
switch (msgtype) {
case MSGT_ADC: {
// Format I2C msg
msgbuffer[6] = (timer2Count0 & 0x00FF);
msgbuffer[5] = (timer2Count0 & 0xFF00) >> 8;
msgbuffer[4] = (timer2Count1 & 0x00FF);
msgbuffer[3] = (timer2Count1 & 0xFF00) >> 8;
msgbuffer[8] = 0x00;
msgbuffer[10] = adc_chan_num;
msgbuffer[11] = 0xaa; // ADC MSG opcode
// Send I2C msg
FromMainHigh_sendmsg(12, msgtype, msgbuffer); // Send ADC msg to FromMainHigh MQ, which I2C
// int hdlr later Reads
// Increment I2C message count from 1 to 100
if(I2C_TX_MSG_COUNT < 100) {
I2C_TX_MSG_COUNT = I2C_TX_MSG_COUNT + 1;
}
else {
I2C_TX_MSG_COUNT = 1;
}
// Increment the channel number
if(adc_chan_num <= 4) adc_chan_num++;
else adc_chan_num = 0;
// Set ADC channel based off of channel number
if(adc_chan_num == 0) SetChanADC(ADC_CH0);
else if(adc_chan_num == 1) SetChanADC(ADC_CH1);
else if(adc_chan_num == 2) SetChanADC(ADC_CH2);
else if(adc_chan_num == 3) SetChanADC(ADC_CH3);
else if(adc_chan_num == 4) SetChanADC(ADC_CH4);
else SetChanADC(ADC_CH5);
};
case MSGT_TIMER0: {
timer0_lthread(&t0thread_data,msgtype,length,msgbuffer);
break;
};
case MSGT_TIMER2: {
timer2Count0++;
if(timer2Count0 >= 0xFFFF) {
timer2Count1++;
timer2Count0 = 0;
}
break;
}
case MSGT_I2C_DATA: { //this data still needs to be put in a buffer
;
if(msgbuffer[0] == 0xaf) {
//FromMainLow_sendmsg(5, msgtype, msgbuffer);
// The code below checks message 'counts' to see if any I2C messages were dropped
//I2C_RX_MSG_COUNT = msgbuffer[4];
FromMainLow_sendmsg(9, msgtype, msgbuffer);
TXSTA2bits.TXEN = 1;
/*
// Send note data to the MIDI device
//while(Busy2USART());
putc2USART(msgbuffer[1]);
//while(Busy2USART());
Delay1KTCYx(8);
putc2USART(msgbuffer[2]);
//while(Busy2USART());
Delay1KTCYx(8);
putc2USART(msgbuffer[3]);
*/
if(I2C_RX_MSG_COUNT - I2C_RX_MSG_PRECOUNT == 1) {
if(I2C_RX_MSG_PRECOUNT < 99) {
I2C_RX_MSG_PRECOUNT++;
}
else {
I2C_RX_MSG_PRECOUNT = 0;
}
}
else {
I2C_RX_MSG_PRECOUNT = I2C_RX_MSG_COUNT;
}
}
};
`
case MSGT_I2C_DBG: {
//printf("I2C Interrupt received %x: ",msgtype);
for (i=0;i<length;i++) {
//printf(" %x",msgbuffer[i]);
}
//printf("\r\n");
// keep track of the first byte received for later use
last_reg_recvd = msgbuffer[0];
break;
};
case MSGT_I2C_RQST: {
//printf("I2C Slave Req\r\n");
// The last byte received is the "register" that is trying to be read
// The response is dependent on the register.
switch (last_reg_recvd) {
case 0xaa: {
break;
}
/*
case 0xa8: {
length = 1;
msgbuffer[0] = 0x3A;
break;
}
case 0xa9: {
length = 1;
msgbuffer[0] = 0xA3;
break;
}*/
};
//start_i2c_slave_reply(length,msgbuffer);
break;
};
default: {
//printf("Error: Unexpected msg in queue, type = %x\r\n", msgtype);
break;
};
};
}
/*
Low Priority MSGQ -----------------------------------------------------------------------
*/
length = ToMainLow_recvmsg(MSGLEN,&msgtype,(void *) msgbuffer);
if (length < 0) {
// no message, check the error code to see if it is concern
if (length != MSGQUEUE_EMPTY) {
}
} else {
switch (msgtype) {
case MSGT_TIMER1: {
timer1_lthread(&t1thread_data,msgtype,length,msgbuffer);
break;
};
case MSGT_OVERRUN:
case MSGT_UART_DATA:
{
LATB = 0xFF;
msgbuffer[11] = 0xBB;
FromMainHigh_sendmsg(12, msgtype, msgbuffer);
break;
};
default: {
break;
};
};
}
}
void InitApp(void)
{
// PORT A is all f****d because of JTAG. Input only on A0 and A1 it seems...
// Disable JTAG so we can use A4 and A5 for gpio (and maybe A0-A3 too?)
DDPCONbits.JTAGEN = 0;
// Set GPIO pin functionality:
// ===========================
// Note: how to set pins:
// TRIS*CLR -> clears a pin/bit in the * port
// TRIS*SET -> sets a pin/bit in the * port
// TRIS*INV -> inverts a pin/bit in the * port
// Note: UBW32 pin meaning:
// Set the LED's on the UBW32 as outputs:
// RE0 -> yellow
// RE1 -> red
// RE2 -> white
// RE3 -> green
//
// RE6 -> PRG button
// RE7 -> USER button
// Cleared pins (set to zero) are configured as outputs.
// This is the hard way to clear pins:
// TRISECLR = 0x0F;
// And this is the easy way:
_TRISE0 = 0;
_TRISE1 = 0;
_TRISE2 = 0;
_TRISE3 = 0;
// Set the PRG and USER buttons on the UBW32 as an inputs:
// This is the hard way:
// TRISESET = 0x00C0; // This sets pin RE7 and RE6: 1100 0000 = C0
// This is the easy way:
_TRISE6 = 1; // Set pins, set to one, are configured as inputs
_TRISE7 = 1;
// Set RE9 as an output to test the 44.1kHz interupt timing:
_TRISE9 = 0;
// Set pin RD8 as an output, could be written as TRISD = 0xFEFF;
// but that takes more clock cycles to perform:
// TRISDCLR = 0x0100;
// PWM Intialization:
// ==================
// configure RD0 as output for PWM
// PWM mode, Single output, Active High
// TRISDCLR = 0x00000001;
// OC1R = 0;
// OC1CON = 0x0000;
// OC1RS = 0;
// OC1CON = 0x0006;
// OC1CONSET = 0x8000;
// Set up some interupts:
// ======================
OpenCoreTimer( 0xFFFFFFFF ); // This is needed for the delay functions
// The next line: turn on timer2 | have it use an internal clock source | have it
// use a prescaler of 1:256, and use a period of 0xFFFF or 2^16 cycles
//
// This fires an interrupt at a frequency of (80MHZ/256/65535), or 4.77
// times a second.
// OpenTimer2( T2_ON | T2_SOURCE_INT | T2_PS_1_256, 0xFFFF);
// Set Timer2 to fire at 44.1kHz:
// (80MHz/1/44100) = 1814.059 = 1814 = 0x0716 with a prescaler of 1:1
OpenTimer2( T2_ON | T2_SOURCE_INT | T2_PS_1_1, 0x0716);
/*Configure Multivector Interrupt Mode. Using Single Vector Mode
is expensive from a timing perspective, so most applications
should probably not use a Single Vector Mode*/
INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
// The next line seems to provide the exact same functionality...
INTEnableSystemMultiVectoredInt();// Use multi-vectored interrupts:
// This statement configured the timer to produce an interrupt with a priority of 2
ConfigIntTimer2( T2_INT_ON | T2_INT_PRIOR_2);
}
static void lcd_setup(void)
{
//mPORTDSetPinsDigitalOut(BIT_3);
//mPORTDClearBits(BIT_3);
mPORTDSetPinsDigitalOut( BIT_2 );
//Set backlight to open drain
mPORTDOpenDrainOpen( BIT_2 );
//Enable contrast control
OpenTimer2(T2_ON, LCD_PWMPERIOD);
OpenOC4( OC_ON | OC_TIMER_MODE16 | OC_TIMER2_SRC | OC_CONTINUE_PULSE | OC_LOW_HIGH , LCD_PWMPERIOD, 0x0458 );
//Start the timer for contrast/brightness PWM
//OpenTimer3(T3_ON | T3_PS_1_1 | T3_SOURCE_INT, LCD_PWMPERIOD);
//PR3 = LCD_PWMPERIOD - 1;
//OC3R = 0;
//mT3SetIntPriority(4);
//mT3ClearIntFlag();
//mT3IntEnable(1);
//SetDCOC3PWM(LCD_PWMPERIOD >> 2);
//SetDCOC3PWM(1);
//Enable brightness control
OpenOC3( OC_ON | OC_TIMER_MODE16 | OC_TIMER2_SRC | OC_CONTINUE_PULSE | OC_LOW_HIGH , LCD_PWMPERIOD, 0x500 );
// Open ENABLE line as output
LCD_EN_CLR();
PORT_DIR_OUT(LCD_EN_P, LCD_EN);
LCD_EN_CLR();
// Open RW and RS lines as output
LCD_RS_CLR();
PORT_CLR(LCD_RW_P, LCD_RW);
PORT_DIR_OUT(LCD_RS_P, LCD_RS);
PORT_DIR_OUT(LCD_RW_P, LCD_RW);
LCD_RS_CLR();
PORT_CLR(LCD_RW_P, LCD_RW);
// Set data lines as output
PORT_CLR(LCD_DATA_P, LCD_DATA_MASK);
PORT_DIR_OUT(LCD_DATA_P, LCD_DATA_MASK);
PORT_CLR(LCD_DATA_P, LCD_DATA_MASK);
// Wait for proper power up
task_delay(LCD_LONG_DELAY);
task_delay(LCD_LONG_DELAY);
task_delay(LCD_LONG_DELAY);
task_delay(LCD_LONG_DELAY);
// Wait for the LCD to power up correctly
lcd_command(LCD_FUNCTION_SET_CMD | LCD_FUNCTION_SET_8_BITS);
task_delay(LCD_SHORT_DELAY);
lcd_command(LCD_FUNCTION_SET_CMD | LCD_FUNCTION_SET_8_BITS);
task_delay(LCD_VERY_SHORT_DELAY);
lcd_command(LCD_FUNCTION_SET_CMD | LCD_FUNCTION_SET_8_BITS);
task_delay(LCD_VERY_SHORT_DELAY);
// Set up the LCD function
lcd_command(LCD_FUNCTION_SET_CMD | LCD_FUNCTION_SET_8_BITS | LCD_FUNCTION_SET_2_LINES);
task_delay(LCD_VERY_SHORT_DELAY);
// Turn the display on
lcd_command(LCD_DISPLAY_CTRL_CMD | LCD_DISPLAY_CTRL_CURSOR_ON | LCD_DISPLAY_CTRL_BLINK_ON);
task_delay(LCD_VERY_SHORT_DELAY);
// Clear the display
lcd_command(LCD_CLEAR_DISPLAY_CMD);
task_delay(LCD_SHORT_DELAY);
// Increase the cursor
lcd_command(LCD_ENTRY_MODE_CMD | LCD_ENTRY_MODE_INCREASE);
task_delay(LCD_SHORT_DELAY);
lcd_command(LCD_DISPLAY_CTRL_CMD | LCD_DISPLAY_CTRL_DISPLAY_ON);
task_delay(LCD_SHORT_DELAY);
}
int setupTimer(int timer, int frequency, int priority)
{
int tX_on;
int tX_source_int;
int tX_int_on;
int tX_ps_1_X;
long countTo = SYS_FREQ / frequency;
switch (timer)
{
case 1:
tX_on = T1_ON;
tX_source_int = T1_SOURCE_INT;
tX_int_on = T1_INT_ON;
while (1)
{
if (countTo >= 65536)
{
countTo = countTo / 8;
if (countTo >= 65536)
{
countTo = countTo / 8;
if (countTo >= 65536)
{
countTo = countTo / 8;
if (countTo >= 65536)
{
return 0;
}
tX_ps_1_X = T1_PS_1_256;
break;
}
tX_ps_1_X = T1_PS_1_64;
break;
}
tX_ps_1_X = T1_PS_1_8;
break;
}
else
{
tX_ps_1_X = T1_PS_1_1;
break;
}
}
OpenTimer1(tX_on | tX_source_int | tX_ps_1_X, countTo);
ConfigIntTimer1(tX_int_on | priority);
break;
case 2:
tX_on = T2_ON;
tX_source_int = T2_SOURCE_INT;
tX_int_on = T2_INT_ON;
while (1)
{
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
return 0;
}
tX_ps_1_X = T2_PS_1_256;
break;
}
tX_ps_1_X = T2_PS_1_64;
break;
}
tX_ps_1_X = T2_PS_1_32;
break;
}
tX_ps_1_X = T2_PS_1_16;
break;
}
tX_ps_1_X = T2_PS_1_8;
break;
}
tX_ps_1_X = T2_PS_1_4;
break;
}
tX_ps_1_X = T2_PS_1_2;
break;
}
else
{
tX_ps_1_X = T2_PS_1_1;
break;
}
}
OpenTimer2(tX_on | tX_source_int | tX_ps_1_X, countTo);
ConfigIntTimer2(tX_int_on | priority);
break;
case 3:
tX_on = T3_ON;
tX_source_int = T3_SOURCE_INT;
tX_int_on = T3_INT_ON;
while (1)
{
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
return 0;
}
tX_ps_1_X = T3_PS_1_256;
break;
}
tX_ps_1_X = T3_PS_1_64;
break;
}
tX_ps_1_X = T3_PS_1_32;
break;
}
tX_ps_1_X = T3_PS_1_16;
break;
}
tX_ps_1_X = T3_PS_1_8;
break;
}
tX_ps_1_X = T3_PS_1_4;
break;
}
tX_ps_1_X = T3_PS_1_2;
break;
}
else
{
tX_ps_1_X = T3_PS_1_1;
break;
}
}
OpenTimer3(tX_on | tX_source_int | tX_ps_1_X, countTo);
ConfigIntTimer3(tX_int_on | priority);
break;
case 4:
tX_on = T4_ON;
tX_source_int = T4_SOURCE_INT;
tX_int_on = T4_INT_ON;
while (1)
{
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
countTo = countTo / 2;
if (countTo >= 65536)
{
return 0;
}
tX_ps_1_X = T4_PS_1_256;
break;
}
tX_ps_1_X = T4_PS_1_64;
break;
}
tX_ps_1_X = T4_PS_1_32;
break;
}
tX_ps_1_X = T4_PS_1_16;
break;
}
tX_ps_1_X = T4_PS_1_8;
break;
}
tX_ps_1_X = T4_PS_1_4;
break;
}
tX_ps_1_X = T4_PS_1_2;
break;
}
else
{
tX_ps_1_X = T4_PS_1_1;
break;
}
}
OpenTimer4(tX_on | tX_source_int | tX_ps_1_X, countTo);
ConfigIntTimer4(tX_int_on | priority);
break;
}
return 1;
}
int main(void)
{
int value;
int junk;
millisec = 0;
value = SYSTEMConfigWaitStatesAndPB( GetSystemClock() );
// Enable the cache for the best performance
CheKseg0CacheOn();
//Setupt input for inteface button JF8 (RA01) (0x02)
TRISASET = 0x02;
//RED LED - JF9 (RA04) (0x10)
TRISACLR = 0x10;
ODCACLR = 0x10;
LATASET = 0x10;
//Green LED -JF7 (RE9) (0x200)
TRISECLR = 0x200;
ODCECLR = 0x200;
LATESET = 0x200;
//Setupt Input for DataFlag Button - JF10 - RA5 0x20
TRISASET = 0x20;
//Setup Output for Clutch Hold (Launch) JE1 RD14 0x4000
//This function is active low, driving the FET on the PDU
TRISDCLR = 0x4000;
ODCDCLR = 0x4000;
LATDSET = 0x4000; //Default state is high (off)
CAN1Init();//CAN1 ACCL 500kbs
CAN2Init();//Motec 1mbs
DelayInit();
initUART2(); // GPS UART
prevButton1 = 0;
prevButton2 = 0;
millisec = 0;
// Configure Timer 2 to request a real-time interrupt once per millisecond.
// The period of Timer 2 is (16 * 5000)/(80 MHz) = 1 ms.
OpenTimer2(T2_ON | T2_IDLE_CON | T2_SOURCE_INT | T2_PS_1_16 | T2_GATE_OFF, 5000);
// Configure the CPU to respond to Timer 2's interrupt requests.
INTEnableSystemMultiVectoredInt();
INTSetVectorPriority(INT_TIMER_2_VECTOR, INT_PRIORITY_LEVEL_2);
INTClearFlag(INT_T2);
INTEnable(INT_T2, INT_ENABLED);
//UART GPS Interrupts
INTSetVectorPriority(INT_UART_2_VECTOR ,INT_PRIORITY_LEVEL_1); //Make sure UART interrupt is top priority
INTClearFlag(INT_U2RX);
INTEnable(INT_U2RX, INT_ENABLED);
value = OSCCON;
while (!(value & 0x00000020))
{
value = OSCCON; // Wait for PLL lock to stabilize
}
deviceAttached = FALSE;
//Initialize the stack
USBInitialize(0);
shouldLog = FALSE;
shouldStop = FALSE;
//count = 0;
angularRateInfoRec = FALSE;
accelerationSensorRec = FALSE;
HRaccelerationSensorRec = FALSE;
//init tim er 3 to convert adc at 100hz
OpenTimer3(T3_ON|T3_PS_1_256|T3_SOURCE_INT, 1562);
//initialize i2c for the psoc
initI2CPSoC();
state = wait;
logNum = 0;
initI2CEEPROM();
short addy = 0x0000;
BYTE num = 0x00;
logNum = readEEPROM(addy);
if(logNum >= 0xEF) //Address stored in EEPROM if greater than 0xEF reset to zero, limited to a single byte with current code configuration
{
writeEEPROM(addy, 0x00);
}
char GroupString[550];//Group Names (Line1)
char UnitString[550];//Units (line2)
char ParamString[650];//Paramater Names (line3)
sprintf(GroupString,"Time,Accelerometer,Accelerometer,Accelerometer,Accelerometer,Accelerometer,Accelerometer,Accelerometer,Accelerometer,Accelerometer,Engine,Engine,Engine,Engine,Engine,Engine,Engine,Engine,Engine,Engine,Drivetrain,Drivetrain,Electrical,Drivetrain,Drivetrain,Drivetrain,Drivetrain,Engine,Engine,Engine,Engine,Electrical,Electrical,Electrical,Electrical,Electrical,Electrical,Suspension,Suspension,Suspension,Suspension,Suspension,Drivetrain,Driver\n");
sprintf(UnitString,"ms,deg/s,deg/s,deg/s,m/s^2,m/s^2,m/s^2,m/s^2,m/s^2,m/s^2,rpm,%,kpa,degF,degF,lambda,psi,degF,na,na,psi,psi,V,mph,mph,mph,mph,s,gal,degF,degBTDC,mV,mV,mV,mV,mV,mV,mV,mV,mV,mV,mV,mV,\n");
sprintf(ParamString, "Millisec,pitch(deg/sec),roll(deg/sec),yaw(deg/sec),lat(m/s^2),long(m/s^2),vert(m/s^2),latHR(m/s^2),longHR(m/s^2),vertHR(m/s^2),rpm,tps(percent),MAP(kpa),AT(degF),ect(degF),lambda,fuel pres,egt(degF),launch,neutral,brake pres,brake pres filtered,BattVolt(V),ld speed(mph), lg speed(mph),rd speed(mph),rg speed(mph),run time(s),fuel used,Oil Temp (deg F), Ignition Adv (degBTDC),Overall Consumption(mV),Overall Production(mV),Fuel Pump(mV),Fuel Injector(mV),Ignition(mV),Vref(mV),Back Left(mV),Back Right(mV),Front Left(mV),Front Right(mV),Steering Angle(mV),Brake Temp(mV),Data Flag,GPRMC,Time,Valid,Lat,N/S,Long,E/W,Speed,Course,Date,Variation,E/W\n");
LATACLR = 0x10; //Turn on Red LED
// LATECLR = 0x200;
UARTSendString(UART2,PMTK_HOT_RESTART);
int i = 0;
while(!UARTTransmissionHasCompleted(UART2)){
i++;
}
while(1)
{
GPSDataRead();
GPSSentenceParse();
ClutchHold(); //This function handles the venting direction of the clutch actuator
DataFlagFunc(); //This function handles the updates of the data flag variable
//USB stack process function
USBTasks();
switch(state){
case wait:
USBTasks();
millisec = 0;
if(CheckLogStateChange() == 1){ //start the transition from wait to log
state = startLog;
}
break;
case startLog:
//if thumbdrive is plugged in
if(USBHostMSDSCSIMediaDetect())
{
deviceAttached = TRUE;
//now a device is attached
//See if the device is attached and in the right format
if(FSInit())
{
//Opening a file in mode "w" will create the file if it doesn't
// exist. If the file does exist it will delete the old file
// and create a new one that is blank.
logNum = readEEPROM(addy);
sprintf(nameString, "test%d.csv", logNum);
myFile = FSfopen(nameString,"w");
FSfwrite(GroupString,1,strlen(GroupString),myFile);
FSfwrite(UnitString,1,strlen(UnitString),myFile);
FSfwrite(ParamString,1, strlen(ParamString),myFile);
millisec = 0;
//LATDSET = 0x4000; //Send sync pulse (aeroprobe)
// while(millisec < 1000){} //Wait 1s then move to log, the aeroprobe ADC waits 1s.
state = log;
LATECLR = 0x200; //Turn on Green
LATASET = 0x10; //Turn off Red
}
}
break;
case log:
//This uses MOTEC as the master timer. Data is only written to the USB after all the motec Data is received
if(motec0Read && motec1Read && motec2Read && motec3Read && motec4Read && motec5Read){
WriteToUSB();
}
else{}//Wait for motec data to write the next row
if(CheckLogStateChange() == 2){ //Start the transition from log to wait
state = stopLog;
}
if(millisec > 2000){
LATDCLR = 0x4000; //After 2 seconds pass no need to keep output high
}
//Add a function to check for a flag button and set a variable
break;
case stopLog:
//Always make sure to close the file so that the data gets written to the drive.
FSfwrite("endFile", 1, 7, myFile);
FSfclose(myFile);
state = wait;
logNum++;
writeEEPROM(addy, logNum);
LATACLR = 0x10; //Turn on Red
LATESET = 0x200; //Turn off Green
break;
default:
state = wait;
break;
}
//CAN Handlers
CANRxMessageBuffer* CAN1RxMessage = CAN1RxMsgProcess();
if(CAN1RxMessage){
WriteAccelData(CAN1RxMessage); //Accel is on CAN 1
}
CANRxMessageBuffer* CAN2RxMessage = CAN2RxMsgProcess();
if(CAN2RxMessage){
writeCan2Msg(CAN2RxMessage); //Motec is on CAN 2
}
}
return 0;
}
void init(void)
{
unsigned char msgdata[ 8 ];
vscp18f_init( TRUE );
// Initialize the uP
// PortA
// RA0 - SENS - Input
// RA1 - - Output
// RA2 - - Output
// RA3 - - Output
// RA4 - - Output
// RA5 - - Output
// RA6 - OSC
TRISA = 0b00000001;
PORTA = 0b00000000;
// PortB
// RB0 - RFID_RX- Input
// RB1 - - Output
// RB2 - CAN TX - Output
// RB3 - CAN RX - input
// RB4 - - input
// RB5 - - input
// RB6 - - input
// RB7 - - input
TRISB = 0b11111001;
PORTB = 0b00000000;
// RC0 - - Output
// RC1 - Button - Input
// RC2 - PWM - Output
// RC3 - - Output
// RC4 - - Output
// RC5 - - Output
// RC6 - - Output
// RC7 - - Output
TRISC = 0b00000010;
PORTC = 0b00000000;
// TIMERS
OpenTimer0(TIMER_INT_OFF &
T0_16BIT &
T0_SOURCE_INT &
T0_PS_1_1
);
OpenTimer1(TIMER_INT_ON &
T1_16BIT_RW &
T1_SOURCE_INT &
T1_PS_1_1 &
T1_OSC1EN_OFF
);
OpenTimer2(TIMER_INT_OFF &
T2_PS_1_1 &
T2_POST_1_1
);
// ADC
OpenADC(ADC_FOSC_64 &
ADC_RIGHT_JUST &
ADC_20_TAD ,
ADC_CH0 &
ADC_INT_OFF &
ADC_REF_VDD_VREFMINUS /*ADC_VREFPLUS_VDD*/ &
ADC_REF_VREFPLUS_VSS /*ADC_VREFMINUS_VSS*/ ,
0x0E);
// PWM 125 kHz
PWM_Calibr(&PWM_f,&PWM_adc);
OpenPWM1(PWM_f);// 79
SetDCPWM1((PWM_f*2)-6); // 156
PWM_enable = ON;
RCONbits.IPEN = 1; // enable HI and LOW priorities
// INT priority
IPR1bits.TMR1IP = 0; // Timer1 LOW priority
OpenRB0INT( PORTB_CHANGE_INT_ON & RISING_EDGE_INT & PORTB_PULLUPS_OFF );
// Global INT ebable
INTCONbits.GIEH = 1;
INTCONbits.GIEL = 1;
return;
}
int main()
{
// Configure the device for maximum performance but do not change the PBDIV
// Given the options, this function will change the flash wait states, RAM
// wait state and enable prefetch cache but will not change the PBDIV.
// The PBDIV value is already set via the pragma FPBDIV option above..
SYSTEMConfig(F_SYS, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
// Auto-configure the PIC32 for optimum performance at the specified operating frequency.
SYSTEMConfigPerformance(F_SYS);
// osc source, PLL multipler value, PLL postscaler , RC divisor
OSCConfig(OSC_POSC_PLL, OSC_PLL_MULT_20, OSC_PLL_POST_1, OSC_FRC_POST_1);
// Configure the PB bus to run at 1/4th the CPU frequency, so 20MHz.
OSCSetPBDIV(OSC_PB_DIV_4);
// Enable multi-vector interrupts
INTEnableSystemMultiVectoredInt();
INTEnableInterrupts();
// Configure Timer 2 using PBCLK as input. We configure it using a 1:16 prescalar, so each timer
// tick is actually at F_PB / 16 Hz, so setting PR2 to F_PB / 16 / 100 yields a .01s timer.
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_16, F_PB / 16 / 100);
// Set up the timer interrupt with a medium priority of 4.
INTClearFlag(INT_T2);
INTSetVectorPriority(INT_TIMER_2_VECTOR, INT_PRIORITY_LEVEL_4);
INTSetVectorSubPriority(INT_TIMER_2_VECTOR, INT_SUB_PRIORITY_LEVEL_0);
INTEnable(INT_T2, INT_ENABLED);
/******************************** Your custom code goes below here ********************************/
int check;
OledInit();
AdcInit();
LEDS_INIT();
check = GameInit();
if(check == STANDARD_ERROR) {
FATAL_ERROR();
}
float currPage;
float binSize;
float titleSize;
float descSize;
float numPages;
uint8_t roomExit;
uint16_t adcValue = 0;
while(1) {
roomExit = GameGetCurrentRoomExits();
LEDS_SET(roomExit);
while(buttonEvents == 0) {
descSize = GameGetCurrentRoomDescription(roomData.description);
titleSize = GameGetCurrentRoomTitle(roomData.title);
numPages = ((titleSize + descSize) / MAX_OLED_PIXELS);
binSize = (ADC_MAX_VALUE / numPages);
if(AdcChanged()) {
adcValue = AdcRead();
}
currPage = (adcValue / binSize);
if(currPage < 1) {
char titleArray[TITLE_OLED_SPACE] = {0};
char descriptionBuffer[FIRST_PG_DESCRIPTION_OLED_SPACE] = {0};
strncpy(descriptionBuffer, roomData.description, DESCRIPTION_COPY);
sprintf(titleArray, "%s\n%s", roomData.title, descriptionBuffer);
OledClear(OLED_COLOR_BLACK);
OledDrawString(titleArray);
} else {
char buffer[MAX_OLED_PIXELS] = {0};
int buffIndex;
buffIndex = (int)currPage * MAX_OLED_PIXELS;
strncpy(buffer, (roomData.description + buffIndex - OFFSET), MAX_OLED_PIXELS);
OledClear(OLED_COLOR_BLACK);
OledDrawString(buffer);
}
OledUpdate();
}
if((buttonEvents & BUTTON_EVENT_4UP) && (roomExit & GAME_ROOM_EXIT_NORTH_EXISTS)) {
GameGoNorth();
} else if((buttonEvents & BUTTON_EVENT_3UP) && (roomExit & GAME_ROOM_EXIT_EAST_EXISTS)) {
GameGoEast();
} else if((buttonEvents & BUTTON_EVENT_2UP) && (roomExit & GAME_ROOM_EXIT_SOUTH_EXISTS)) {
GameGoSouth();
} else if((buttonEvents & BUTTON_EVENT_1UP) && (roomExit & GAME_ROOM_EXIT_WEST_EXISTS)) {
GameGoWest();
}
buttonEvents = BUTTON_EVENT_NONE;
}
/**************************************************************************************************/
while (1);
}
int main(int argc, char** argv) {
/*Configuring POSC with PLL, with goal FOSC = 80 MHZ */
// Configure PLL prescaler, PLL postscaler, PLL divisor
// Fin = 8 Mhz, 8 * (40/2/2) = 80
PLLFBD = 18; // M=40 // change to 38 for POSC 80 Mhz - this worked only on a single MCU for uknown reason
CLKDIVbits.PLLPOST = 0; // N2=2
CLKDIVbits.PLLPRE = 0; // N1=2
// Initiate Clock Switch to Primary Oscillator with PLL (NOSC=0b011)
//__builtin_write_OSCCONH(0x03);
// tune FRC
OSCTUN = 23; // 23 * 0.375 = 8.625 % -> 7.37 Mhz * 1.08625 = 8.005Mhz
// Initiate Clock Switch to external oscillator NOSC=0b011 (alternative use FRC with PLL (NOSC=0b01)
__builtin_write_OSCCONH(0b011);
__builtin_write_OSCCONL(OSCCON | 0x01);
// Wait for Clock switch to occur
while (OSCCONbits.COSC!= 0b011);
// Wait for PLL to lock
while (OSCCONbits.LOCK!= 1);
// local variables in main function
int status = 0;
int i = 0;
int ax = 0, ay = 0, az = 0;
int statusProxi[8];
int slowLoopControl = 0;
UINT16 timerVal = 0;
float timeElapsed = 0.0;
//extern UINT8 pwmMotor;
extern UINT16 speakerAmp_ref;
extern UINT16 speakerFreq_ref;
extern UINT8 proxyStandby;
UINT16 dummy = 0x0000;
setUpPorts();
delay_t1(50);
PWMInit();
delay_t1(50);
ctlPeltier = 0;
PeltierVoltageSet(ctlPeltier);
FanCooler(0);
diagLED_r[0] = 100;
diagLED_r[1] = 0;
diagLED_r[2] = 0;
LedUser(diagLED_r[0], diagLED_r[1],diagLED_r[2]);
// Speaker initialization - set to 0,1
spi1Init(2, 0);
speakerAmp_ref = 0;
speakerAmp_ref_old = 10;
speakerFreq_ref = 1;
speakerFreq_ref_old = 10;
int count = 0;
UINT16 inBuff[2] = {0};
UINT16 outBuff[2] = {0};
while (speakerAmp_ref != speakerAmp_ref_old) {
if (count > 5 ) {
// Error !
//LedUser(100, 0, 0);
break;
}
inBuff[0] = (speakerAmp_ref & 0x0FFF) | 0x1000;
chipSelect(slaveVib);
status = spi1TransferWord(inBuff[0], outBuff);
chipDeselect(slaveVib);
chipSelect(slaveVib);
status = spi1TransferWord(inBuff[0], &speakerAmp_ref_old);
chipDeselect(slaveVib);
count++;
}
count = 0;
while (speakerFreq_ref != speakerFreq_ref_old) {
if (count > 5 ) {
// Error !
//LedUser(0, 100, 0);
break;
}
inBuff[0] = (speakerFreq_ref & 0x0FFF) | 0x2000;
chipSelect(slaveVib);
status = spi1TransferWord(inBuff[0], outBuff);
chipDeselect(slaveVib);
chipSelect(slaveVib);
status = spi1TransferWord(inBuff[0], &speakerFreq_ref_old);
chipDeselect(slaveVib);
count++;
}
accPin = aSlaveR;
accPeriod = 1.0 / ACC_RATE * 1000000.0; // in us; for ACC_RATE = 3200 Hz it should equal 312.5 us
status = adxl345Init(accPin);
ax = status;
delay_t1(5);
/* Init FFT coefficients */
TwidFactorInit(LOG2_FFT_BUFF, &Twiddles_array[0],0);
delta_freq = (float)ACC_RATE / FFT_BUFF;
// read 100 values to calculate bias
int m;
int n = 0;
for (m = 0; m < 100; m++) {
status = readAccXYZ(accPin, &ax, &ay, &az);
if (status <= 0) {
//
}
else {
ax_b_l += ax;
ay_b_l += ay;
az_b_l += az;
n++;
}
delay_t1(1);
}
ax_b_l /= n;
ay_b_l /= n;
az_b_l /= n;
_SI2C2IE = 0;
_SI2C2IF = 0;
// Proximity sensors initalization
I2C1MasterInit();
status = VCNL4000Init();
// Cooler temperature sensors initalization
status = adt7420Init(0, ADT74_I2C_ADD_mainBoard);
delay_t1(1);
muxCh = I2C1ChSelect(1, 6);
status = adt7420Init(0, ADT74_I2C_ADD_flexPCB);
// Temperature sensors initialization
statusTemp[0] = adt7320Init(tSlaveF, ADT_CONT_MODE | ADT_16_BIT);
delay_t1(5);
statusTemp[1] = adt7320Init(tSlaveR, ADT_CONT_MODE | ADT_16_BIT);
delay_t1(5);
statusTemp[2] = adt7320Init(tSlaveB, ADT_CONT_MODE | ADT_16_BIT);
delay_t1(5);
statusTemp[3] = adt7320Init(tSlaveL, ADT_CONT_MODE | ADT_16_BIT);
delay_t1(5);
// Temperature estimation initialization
for (i = 0; i < 50; i++) {
adt7320ReadTemp(tSlaveF, &temp_f);
delay_t1(1);
adt7320ReadTemp(tSlaveL, &temp_l);
delay_t1(1);
adt7320ReadTemp(tSlaveB, &temp_b);
delay_t1(1);
adt7320ReadTemp(tSlaveR, &temp_r);
delay_t1(1);
}
tempBridge[0] = temp_f;
tempBridge[1] = temp_r;
tempBridge[2] = temp_b;
tempBridge[3] = temp_l;
if (statusTemp[0] != 1)
temp_f = -1;
if (statusTemp[1] != 1)
temp_r = -1;
if (statusTemp[2] != 1)
temp_b = -1;
if (statusTemp[3] != 1)
temp_l = -1;
// CASU ring average temperature
temp_casu = 0;
tempNum = 0;
tempSensors = 0;
for (i = 0; i < 4; i++) {
if (statusTemp[i] == 1 && tempBridge[i] > 20 && tempBridge[i] < 60) {
tempNum++;
temp_casu += tempBridge[i];
tempSensors++;
}
}
if (tempNum > 0)
temp_casu /= tempNum;
else
temp_casu = -1;
temp_casu1 = temp_casu;
temp_wax = temp_casu;
temp_wax1 = temp_casu;
temp_model = temp_wax;
temp_old[0] = temp_f;
temp_old[1] = temp_r;
temp_old[2] = temp_b;
temp_old[3] = temp_l;
temp_old[4] = temp_flexPCB;
temp_old[5] = temp_pcb;
temp_old[6] = temp_casu;
temp_old[7] = temp_wax;
for (i = 0; i < 4; i++) {
uref_m[i] = temp_wax;
}
// Configure i2c2 as a slave device and interrupt priority 5
I2C2SlaveInit(I2C2_CASU_ADD, BB_I2C_INT_PRIORITY);
// delay for 2 sec
for(i = 0; i < 4; i ++) {
delay_t1(500);
ClrWdt();
}
while (i2cStarted == 0) {
delay_t1(200);
ClrWdt();
}
dma0Init();
dma1Init();
CloseTimer4();
ConfigIntTimer4(T4_INT_ON | TEMP_LOOP_PRIORITY);
OpenTimer4(T4_ON | T4_PS_1_256, ticks_from_ms(2000, 256));
CloseTimer5();
ConfigIntTimer5(T5_INT_ON | FFT_LOOP_PRIORITY);
OpenTimer5(T5_ON | T5_PS_1_256, ticks_from_ms(1000, 256));
diagLED_r[0] = 0;
diagLED_r[1] = 0;
diagLED_r[2] = 0;
LedUser(diagLED_r[0], diagLED_r[1],diagLED_r[2]);
start_acc_acquisition();
while(1) {
ConfigIntTimer2(T2_INT_OFF); // Disable timer interrupt
IFS0bits.T2IF = 0; // Clear interrupt flag
OpenTimer2(T2_ON | T2_PS_1_256, 65535); // Configure timer
if (!proxyStandby) {
statusProxi[0] = I2C1ChSelect(1, 2); // Front
proxy_f = VCNL4000ReadProxi();
delay_t1(1);
statusProxi[1] = I2C1ChSelect(1, 4); // Back right
proxy_br = VCNL4000ReadProxi();
delay_t1(1);
statusProxi[2] = I2C1ChSelect(1, 3); // Front right
proxy_fr = VCNL4000ReadProxi();
delay_t1(1);
statusProxi[3] = I2C1ChSelect(1, 5); // Back
proxy_b = VCNL4000ReadProxi();
delay_t1(1);
statusProxi[4] = I2C1ChSelect(1, 0); // Back left
proxy_bl = VCNL4000ReadProxi();
delay_t1(1);
statusProxi[5] = I2C1ChSelect(1, 1); // Front left
proxy_fl = VCNL4000ReadProxi();
delay_t1(1);
}
else {
proxy_f = 0; // Front
proxy_br = 0; // Back right
proxy_fr = 0; // Front right
proxy_b = 0; // Back
proxy_bl = 0; // Back left
proxy_fl = 0; // Front left
}
if (timer4_flag == 1) {
// every 2 seconds
CloseTimer4();
ConfigIntTimer4(T4_INT_ON | TEMP_LOOP_PRIORITY);
timer4_flag = 0;
if (dma_spi2_started == 0) {
OpenTimer4(T4_ON | T4_PS_1_256, ticks_from_ms(2000, 256));
skip_temp_filter++;
tempLoop();
}
else {
OpenTimer4(T4_ON | T4_PS_1_256, ticks_from_ms(50, 256));
}
}
if (dma_spi2_done == 1) {
fftLoop();
dma_spi2_done = 0;
}
if ((timer5_flag == 1) || (new_vibration_reference == 1)) {
// every 1 seconds
CloseTimer5();
ConfigIntTimer5(T5_INT_ON | FFT_LOOP_PRIORITY);
OpenTimer5(T5_ON | T5_PS_1_256, ticks_from_ms(1000, 256));
timer5_flag = 0;
if (new_vibration_reference == 1) {
//if(1){
CloseTimer3();
dma0Stop();
dma1Stop();
spi2Init(2, 0);
dma0Init();
dma1Init();
chipDeselect(aSlaveR);
IFS0bits.DMA0IF = 0;
delay_t1(30); // transient response
}
new_vibration_reference = 0;
start_acc_acquisition();
}
// Cooler fan control
if (fanCtlOn == 1) {
if (temp_pcb >= 25 && fanCooler == FAN_COOLER_OFF)
fanCooler = FAN_COOLER_ON;
else if (temp_pcb <= 24 && fanCooler == FAN_COOLER_ON)
fanCooler = FAN_COOLER_OFF;
// In case of I2C1 fail turn on the fan
if ((proxy_f == 0xFFFF) && (proxy_fr == 0xFFFF) && (proxy_br == 0xFFFF) && (proxy_b == 0xFFFF) && (proxy_bl == 0xFFFF) && (proxy_fl == 0xFFFF))
fanCooler = FAN_COOLER_ON;
}
else if (fanCtlOn == 2)
fanCooler = FAN_COOLER_ON;
else
fanCooler = FAN_COOLER_OFF;
//TEST
// temp_f = temp_model;
// if (temp_ref < 30) {
// temp_r = smc_parameters[0] * 10;
// }
// else {
// temp_r = smc_parameters[0] / 2.0 * 10.0;
// }
// temp_r = alpha*10;
// temp_b = sigma_m * 10;
// temp_l = sigma * 10;
//temp_flexPCB = temp_ref_ramp;
/*
proxy_f = dma_spi2_started;
proxy_fl = dma_spi2_done;
proxy_bl = new_vibration_reference;
proxy_b = timer5_flag;
proxy_br = timer4_flag;
*/
int dummy_filt = 0;
for (i = 0; i < 8; i++) {
if (index_filter[i] > 0){
dummy_filt++;
}
}
if (dummy_filt > 0) {
filtered_glitch = dummy_filt;
//for (i = 0; i< 8; index_filter[i++] = 0);
}
else {
filtered_glitch = 0;
}
updateMeasurements();
timerVal = ReadTimer2();
CloseTimer2();
timeElapsed = ms_from_ticks(timerVal, 256);
//if (timeElapsed < MAIN_LOOP_DUR)
// delay_t1(MAIN_LOOP_DUR - timeElapsed);
ClrWdt(); //Clear watchdog timer
} // end while(1)
return (EXIT_SUCCESS);
}
// === Main ======================================================
void main(void) {
//SYSTEMConfigPerformance(PBCLK);
ANSELA = 0; ANSELB = 0;
// === config threads ==========
// turns OFF UART support and debugger pin, unless defines are set
PT_setup();
// === setup system wide interrupts ========
INTEnableSystemMultiVectoredInt();
CloseADC10(); // ensure the ADC is off before setting the configuration
#define PARAM1 ADC_FORMAT_INTG16 | ADC_CLK_AUTO | ADC_AUTO_SAMPLING_OFF //
// define setup parameters for OpenADC10
// ADC ref external | disable offset test | disable scan mode | do 1 sample | use single buf | alternate mode off
#define PARAM2 ADC_VREF_AVDD_AVSS | ADC_OFFSET_CAL_DISABLE | ADC_SCAN_OFF | ADC_SAMPLES_PER_INT_1 | ADC_ALT_BUF_OFF | ADC_ALT_INPUT_OFF
// Define setup parameters for OpenADC10
// use peripherial bus clock | set sample time | set ADC clock divider
// ADC_CONV_CLK_Tcy2 means divide CLK_PB by 2 (max speed)
// ADC_SAMPLE_TIME_5 seems to work with a source resistance < 1kohm
#define PARAM3 ADC_CONV_CLK_PB | ADC_SAMPLE_TIME_5 | ADC_CONV_CLK_Tcy2 //ADC_SAMPLE_TIME_15| ADC_CONV_CLK_Tcy2
// define setup parameters for OpenADC10
// set AN11 and as analog inputs
#define PARAM4 ENABLE_AN11_ANA // pin 24
// define setup parameters for OpenADC10
// do not assign channels to scan
#define PARAM5 SKIP_SCAN_ALL
// use ground as neg ref for A | use AN11 for input A
// configure to sample AN11
SetChanADC10( ADC_CH0_NEG_SAMPLEA_NVREF | ADC_CH0_POS_SAMPLEA_AN11 ); // configure to sample AN4
OpenADC10( PARAM1, PARAM2, PARAM3, PARAM4, PARAM5 ); // configure ADC using the parameters defined above
EnableADC10(); // Enable the ADC
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_1, 400);
mPORTAClearBits(BIT_0 ); //Clear bits to ensure light is off.
mPORTASetPinsDigitalOut(BIT_0 ); //Set port as output
int CVRCON_setup;
// set up the Vref pin and use as a DAC
// enable module| eanble output | use low range output | use internal reference | desired step
CVREFOpen( CVREF_ENABLE | CVREF_OUTPUT_ENABLE | CVREF_RANGE_LOW | CVREF_SOURCE_AVDD | CVREF_STEP_0 );
// And read back setup from CVRCON for speed later
// 0x8060 is enabled with output enabled, Vdd ref, and 0-0.6(Vdd) range
CVRCON_setup = CVRCON; //CVRCON = 0x8060
// Open the desired DMA channel.
// We enable the AUTO option, we'll keep repeating the same transfer over and over.
DmaChnOpen(dmaChn, 0, DMA_OPEN_AUTO);
// set the transfer parameters: source & destination address, source & destination size, number of bytes per event
// Setting the last parameter to one makes the DMA output one byte/interrut
//DmaChnSetTxfer(dmaChn, sine_table, (void*) &CVRCON, sizeof(sine_table), 1, 1);
// set the transfer event control: what event is to start the DMA transfer
// In this case, timer2
DmaChnSetEventControl(dmaChn, DMA_EV_START_IRQ(_TIMER_2_IRQ));
// once we configured the DMA channel we can enable it
// now it's ready and waiting for an event to occur...
//DmaChnEnable(dmaChn);
int i;
for(i=0; i <256; i++){
ball_scored[i] = 0x60|((unsigned char)((float)255/2*(sin(6.2832*(((float)i)/(float)256))+1))) ;
//ball_lost[i]
// game_over
}
// init the threads
PT_INIT(&pt_timer);
PT_INIT(&pt_adc);
PT_INIT(&pt_launch);
PT_INIT(&pt_anim);
// init the display
tft_init_hw();
tft_begin();
tft_fillScreen(ILI9340_BLACK);
tft_setRotation(1); // Use tft_setRotation(1) for 320x240
while (1){
PT_SCHEDULE(protothread_timer(&pt_timer));
PT_SCHEDULE(protothread_adc(&pt_adc));
PT_SCHEDULE(protothread_launch_balls(&pt_launch));
PT_SCHEDULE(protothread_anim_balls(&pt_anim));
}
} // main
void configureTimeout(int secondes) {
numberOfMillis = secondes * 1000;
mT2ClearIntFlag();
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_64, 625);
ConfigIntTimer2(T2_INT_ON | T2_INT_PRIOR_2);
}
void setupPWMTimer()
{
OpenTimer2(T2_ON | T2_PS_1_4, 1000); // 20kHz PWM: 80000000Hz / 4ps / 1000 = 20 kHz
}
void InitApp()
{
_TRISA0 = 0; //led en sortie
_TRISA1 = 0;
led = 0;
led2 = 0;
//Sortie enable
_TRISB9 = 0;
_TRISB11 = 0;
_ODCB9 = 1; //Open drain RB9 (dir 1)
_ODCB11 = 1; //Open drain RB11 (dir 2)
_ODCB10 = 1; //open drain RB10 PWM1H3
//Le microswicth sur la pin RC5 (par exemple), on la met en entrée
_TRISC5 = 1; //bumper bas de pince
//Et on active la pullup qui va bien (registres CNPU1 et CNPU2)
_CN26PUE = 1;
_ODCC9 = 1; // Open drain sur la pin RC9 (pour les AX12)
_TRISA4 = 1;
_TRISA8 = 1;
_TRISA9 = 1;
_TRISB2 = 1; //RTS ?
_TRISB3 = 1; //FLush ?
_TRISA2 = 1; //CLK12 ?
_TRISB4 = 1; // Arret d'urgence
_CN1PUE = 1; // avec pullup
_TRISB12 = 1; // switch 1
_CN14PUE = 1; // avec pullup
_TRISB13 = 1; // switch 2
_CN13PUE = 1; // avec pullup
_TRISB14 = 1; // switch 3
_CN12PUE = 1; // avec pullup
_TRISB15 = 1; // Laisse
_CN11PUE = 1; // avec pullup
OpenUART2(UART_EN & UART_IDLE_CON & UART_IrDA_DISABLE & UART_MODE_FLOW
& UART_UEN_00 & UART_DIS_WAKE & UART_DIS_LOOPBACK
& UART_DIS_ABAUD & UART_UXRX_IDLE_ONE & UART_BRGH_SIXTEEN
& UART_NO_PAR_8BIT & UART_1STOPBIT,
UART_INT_TX_BUF_EMPTY & UART_IrDA_POL_INV_ZERO
& UART_SYNC_BREAK_DISABLED & UART_TX_ENABLE & UART_TX_BUF_NOT_FUL & UART_INT_RX_CHAR
& UART_ADR_DETECT_DIS & UART_RX_OVERRUN_CLEAR,
BRGVALAX12);
ConfigIntUART2(UART_RX_INT_PR4 & UART_RX_INT_EN
& UART_TX_INT_PR4 & UART_TX_INT_DIS);
OpenTimer2(T2_ON & T2_GATE_OFF & T2_PS_1_256 & T2_32BIT_MODE_OFF & T2_SOURCE_INT, 1500);
ConfigIntTimer2(T2_INT_PRIOR_3 & T2_INT_ON); //Interruption ON et priorite 3
OpenTimer5(T5_OFF & T5_GATE_OFF & T5_PS_1_1 & T5_SOURCE_INT, 40000);
ConfigIntTimer5(T5_INT_PRIOR_2 & T5_INT_ON);
OpenQEI1(QEI_DIR_SEL_QEB & QEI_INT_CLK & QEI_INDEX_RESET_DISABLE & QEI_CLK_PRESCALE_1
& QEI_NORMAL_IO & QEI_MODE_x4_MATCH & QEI_UP_COUNT,0);
// ConfigIntQEI1(QEI_INT_DISABLE);
// WriteQEI1(65535); //Valeur pour declencher l'interruption du module QEI
_QEA1R = 5; //Module QEI 1 phase A sur RB5
_QEB1R = 6; //Module QEI 1 phase B sur RB6
POS1CNT = 0; //valeur QEI
IFS2bits.SPI2IF = 0; // Flag SPI2 Event Interrupt Priority
IPC8bits.SPI2IP = 2; // Priority SPI2 Event Interrupt Priority
IEC2bits.SPI2IE = 1; //Enable SPI2 Event Interrupt Priority
// activation de la priorité des interruptions
_NSTDIS = 0;
}
// main() ---------------------------------------------------------------------
//
int main(void)
{
int pbClk; // Peripheral bus clock
// Configure the device for maximum performance, but do not change
// the PBDIV clock divisor. Given the options, this function will
// change the program Flash wait states, RAM wait state and enable
// prefetch cache, but will not change the PBDIV. The PBDIV value
// is already set via the pragma FPBDIV option above.
pbClk = SYSTEMConfig(CPU_HZ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
// The pic32 has 2 programming i/f's: ICD/ICSP and JTAG. The
// starter kit uses JTAG, whose pins are muxed w/ RA0,1,4 & 5.
// If we wanted to disable JTAG to use those pins, we'd need:
#if defined M4557_DUINOMITE
DDPCONbits.JTAGEN = 0; // Disable the JTAG port.
#endif
// Pins that share ANx functions (analog inputs) will default to
// analog mode (AD1PCFG = 0x0000) on reset. To enable digital I/O
// Set all ones in the ADC Port Config register. (I think it's always
// PORTB that is shared with the ADC inputs). PORT B is NOT 5v tolerant!
// Also, RB6 & 7 are the ICD/ICSP lines.
AD1PCFG = 0xffff; // Port B as digital i/o.
//Initialize the DB_UTILS IO channel
DBINIT();
#if defined ST7565_M4557_PROTOTYPE_STARTERKIT
// Enable pullup resistors for Starter Kit's 3 switches.
//CNPUE = (CN15_PULLUP_ENABLE | CN16_PULLUP_ENABLE | CN19_PULLUP_ENABLE);
mCNOpen(CN_ON, CN15_ENABLE | CN16_ENABLE,
CN15_PULLUP_ENABLE | CN16_PULLUP_ENABLE | CN19_PULLUP_ENABLE);
// Read the port to clear any mismatch on change notice pins
dummy = mPORTDRead();
// Clear change notice interrupt flag
ConfigIntCN(CHANGE_INT_ON | CHANGE_INT_PRI_2);
// Ok now to enable multi-vector interrupts
INTEnableSystemMultiVectoredInt();
// Display the introduction
DBPUTS("SW1:Set contrast; SW2:Halt display\n");
//DBPRINTF("DBPRINTF: The build date and time is (" __DATE__ "," __TIME__ ")\n");
// Init ports for ST7565 parallel prototype setup (using pic32 starter kit
// and i/o expansion board): TODO: This belongs somewhere else!!
//
// PIC32 NHD Display
// RB10 /CS1, /RES, A0, /WR, /RD
// RE0..7 D0..7
LATBSET = 0x7C00; // Set the control bits high (inactive)
TRISBCLR = 0x7C00; // Set the control bits as outputs.
// Init ESI touch-screen controller's (TSC2046) CS line as output
LATFSET = BIT_5; // Set CSn inactive...
TRISFCLR = BIT_5; // and set as output
// Data is on port E. The LCD controller (ST7565) uses its parallel
// mode on port E, RE0..7. The touch screen controller shares port
// shares a serial interface on some of these bits.
TRISECLR = 0x00ff; // Set the cmd/data bits as outputs.
#elif defined M4557_DUINOMITE
// Init ports for the M4557.
//
// Control bits are on port B:
//
// bit M4557 function
// ---- --------------
// 3 /CS1 - LCD Chip sel (ST7565 controller)
// 4 /RES - Reset
// 6 A0 -
// 7 /WR - Write
// 9 /RD - Read
// 10 /TPCS - Touch panel Chip Sel (TSC2046)
//
// Set the control bits low, and enable as outputs.
LATBSET = (BIT_3|BIT_4|BIT_6|BIT_7|BIT_9|BIT_10);
TRISBCLR = (BIT_3|BIT_4|BIT_6|BIT_7|BIT_9|BIT_10);
// Data is on port E. The LCD controller (ST7565) uses its parallel
// mode on port E, RE0..7. The touch screen controller shares port
// shares a serial interface on some of these bits.
TRISECLR = 0x00ff; // Set the cmd/data bits as outputs.
#else
#error Need product defined
#endif
Nop();
lcdInit(5,35); // Init lcd controller
Nop();
// Output Compare (PWM) pins
//
// OCn 64pin 100pin/port SKII-J11- Duinomite
// --- ----- ----------- -------------- ----------
// OC1 46 72/RD0 19 (LED1,Red) SOUND
// OC2 49 76/RD1 20 (LED2,Yel) D13,SD_CLK
// OC3 50 77/RD2 17 (LED3,Grn) D12,SD_MISO
// OC4 51 78/RD3 18 D11,SD_MOSI
// OC5 52 81 15 vga_hsync
//
// Init Timer 2 for use by the OC (PWM) module(s).
// This will set the PWM frequency, f = pbClk/reloadValue.
// Examples (pcClk = 40MHz):
// f = pbClk/100000 = 400Hz
// f = pbClk/10000 = 4kHz
// f = pbClk/2500 = 20kHz
//
//OpenTimer2(T2_ON | T2_32BIT_MODE_ON, 100000); // f = pbClk/100000 = 400Hz
//OpenTimer2(T2_ON | T2_32BIT_MODE_ON, 10000); // f = pbClk/10000 = 4kHz
OpenTimer2(T2_ON | T2_32BIT_MODE_ON, 2500); // f = pbClk/2500 = 16kHz
// I tried the uChip example using "OpenOC2", and as is ofter the
// case, I can't get it to work, the documentation is lacking, and
// it's easier to just read the datasheet and program the bloody
// OCxCON register directly.
//OpenOC2( OC_ON | OC_TIMER_MODE32 | OC_TIMER2_SRC | OC_CONTINUE_PULSE | OC_LOW_HIGH , 40000, 30000 );
SetDCOC2PWM(0);
OC2CON = 0x8026; // OC on; 32bit-mode; PWM mode.
SetDCOC3PWM(0);
OC3CON = 0x8026; // OC on; 32bit-mode; PWM mode.
/*
int testOnly = 1;
uint32_t loadVal = 0;
int i;
while(testOnly)
{
// Try the dimmer's 16 levels (0..15)
for(i=0; i<16; i++)
{
loadVal = pwmTable1[i];
SetDCOC2PWM(loadVal);
delay_ms(300);
}
}
CloseOC2();
*/
// Do ESI M4557 demo application (dimmer-control type demo w/ touchscreen)
esi_M4557();
return 0;
}
void main(void)
{
int8 i;
DisableInterrupts;
InitPorts();
InitADC();
OpenUSART(USART_TX_INT_OFF&USART_RX_INT_OFF&USART_ASYNCH_MODE&
USART_EIGHT_BIT&USART_CONT_RX&USART_BRGH_HIGH, _B38400);
OpenTimer0(TIMER_INT_OFF&T0_8BIT&T0_SOURCE_INT&T0_PS_1_16);
OpenTimer1(T1_8BIT_RW&TIMER_INT_OFF&T1_PS_1_8&T1_SYNC_EXT_ON&T1_SOURCE_CCP&T1_SOURCE_INT);
OpenCapture1(CAPTURE_INT_ON & C1_EVERY_FALL_EDGE); // capture mode every falling edge
CCP1CONbits.CCP1M0 = NegativePPM;
OpenTimer2(TIMER_INT_ON&T2_PS_1_16&T2_POST_1_16);
PR2 = TMR2_5MS; // set compare reg to 9ms
INTCONbits.TMR0IE = false;
// setup flags register
for ( i = 0; i<16; i++ )
Flags[i] = false;
_NoSignal = true;
InitArrays();
ReadParametersEE();
ConfigParam = 0;
ALL_LEDS_OFF;
Beeper_OFF;
LedBlue_ON;
INTCONbits.PEIE = true; // enable peripheral interrupts
EnableInterrupts;
LedRed_ON; // red LED on
Delay1mS(100);
IsLISLactive();
#ifdef ICD2_DEBUG
_UseLISL = 1; // because debugger uses RB7 (=LISL-CS) :-(
#endif
NewK1 = NewK2 = NewK3 = NewK4 =NewK5 = NewK6 = NewK7 = 0xFFFF;
PauseTime = 0;
InitBarometer();
InitDirection();
Delay1mS(COMPASS_TIME);
// send hello text to serial COM
Delay1mS(100);
ShowSetup(true);
Delay1mS(BARO_PRESS_TIME);
while(1)
{
// turn red LED on of signal missing or invalid, green if OK
// Yellow led to indicate linear sensor functioning.
if( _NoSignal || !Switch )
{
LedRed_ON;
LedGreen_OFF;
if ( _UseLISL )
LedYellow_ON;
}
else
{
LedGreen_ON;
LedRed_OFF;
LedYellow_OFF;
}
ProcessComCommand();
}
} // main
void configTimers (void)
{
//TIMER0
OpenTimer0 ( TIMER_INT_ON &
T0_8BIT &
T0_EDGE_FALL &
T0_PS_1_256 &
T0_SOURCE_INT
); // Clock Interno, contador de 8 bits e Prescaler 1/256
WriteTimer0 ( 0x3D ); // Gera um intervalo de 0,1 segundo a 4 mhz
//TMR0ON=1; // Liga o Timer0
//extern volatile __bit TMR0ON @ (((unsigned) &T0CON)*8) + 7;
//#define TMR0ON_bit BANKMASK(T0CON), 7
TMR0IF=0; // Zera o Overflow do Timer0
TMR0IE=1; // Habilita a Interrupcao para o Overflow do Timer0
//////////////////////////////////////////////////////////////////////
// TIMER1
OpenTimer1(TIMER_INT_ON &
T1_SOURCE_EXT &
T1_SYNC_EXT_OFF &
T1_PS_1_1 &
T1_OSC1EN_ON &
T1_16BIT_RW
);
//WriteTimer1( 0xBE5 ); // equivalemnte a 1/2 segundo em 4,00 mhz
WriteTimer1( 0x8000 ); // equivalente a 1 segundo em 32,768 khz
//TMR1ON = 1; // Liga o Timer1 -> Igual ao TIMER_INT_ON
TMR1IF = 0; // Zera o Overflow para o Timer1
TMR1IE=1; // Habilita Interrupcao para o Overflow do Timer1
//////////////////////////////////////////////////////////////////////
// PWM TIMER2
OpenPWM1(0x7C); // Inicializa o PWM com intervalo de 2khz e PS_1/16
// num clock de 4 mhz
SetDCPWM1(0x000F); // Configura o Duty Cycle Inicial
OpenTimer2(
TIMER_INT_OFF &
T2_PS_1_16
); // Para o PWM funcionar corretamente, a Interrupcao
// TIMER_INT_OFF (ou TMR2IE) deve ser desabilitada
// obs: como o PWM funciona como um "temporizador", nao precisa executar
// interrupcao ou acao; a propria porta de saida PWM1 ja executa
//TMR2=0; // Clear Timer2 -> Nao necessario para este exemplo
//T2CKPS1=1; // Pre-Scaler 16 (ja setado no T2_PS1_16), redundante
SetOutputPWM1( SINGLE_OUT , PWM_MODE_1 ); // Configura o CCP1CON
// apenas o PWM1: P1A modulated; P1B, P1C, P1D assigned as port pins
// no modo PxA,PxC active high, PxB,PxD active high */
//CCP1IE=1; // Habilita Interrupcao no modulo CCP1, Nao Necessario
//TMR2IF=0; // Limpando o flag de overflow do Timer2, Nao Necessario
TMR2ON=1; // Ligando o Timer2
//TMR2IE=0; // -> TIMER_INT_OFF , redundante
// Pisca Verde/Vermelho 2 vezes para sinalizar inicio do PWM
__delay_ms(100);LED_VERD=1;__delay_ms(100);LED_VERD=0;
__delay_ms(100);LED_VERM=1;__delay_ms(100);LED_VERM=0;
__delay_ms(100);LED_VERD=1;__delay_ms(100);LED_VERD=0;
__delay_ms(100);LED_VERM=1;__delay_ms(100);LED_VERM=0;
PEIE=1; // Habilita As Interrupcoes dos Perifericos
GIE=1; // Habilita as Interrupcoes Globais
}
/**********************************************************************
* 初期化.
**********************************************************************
t2config:
bit ---- --xx = prescale
bit -yyy y--- = postscale
bit 7--- ---- = interrupt enable
period: n (1〜255)
1/n
**********************************************************************
prescale xx:
00= 1/1
01= 1/4
1x= 1/16
postscale yyyy:
0000 = 1/1
0001 = 1/2
0010 = 1/3
・・・
1111 = 1/16
**********************************************************************
分周比 TMR2IF = 12MHz * prescale * period * postscale ;
*/
void timer2_init(uchar t2config,uchar period)
{
OpenTimer2(t2config);
PR2 = period;
}
int main(void)
{
//LOCALS
unsigned int temp;
unsigned int channel1, channel2;
M1_stepPeriod = M2_stepPeriod = M3_stepPeriod = M4_stepPeriod = 50; // in tens of u-seconds
unsigned char M1_state = 0, M2_state = 0, M3_state = 0, M4_state = 0;
SYSTEMConfig(GetSystemClock(), SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
/* TIMER1 - now configured to interrupt at 10 khz (every 100us) */
OpenTimer1(T1_ON | T1_SOURCE_INT | T1_PS_1_1, T1_TICK);
ConfigIntTimer1(T1_INT_ON | T1_INT_PRIOR_2);
/* TIMER2 - 100 khz interrupt for distance measure*/
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_1, T2_TICK);
ConfigIntTimer2(T2_INT_ON | T2_INT_PRIOR_3); //It is off until trigger
/* PORTA b2 and b3 for servo-PWM */
mPORTAClearBits(BIT_2 | BIT_3);
mPORTASetPinsDigitalOut(BIT_2 | BIT_3);
/* ULTRASONICS: some bits of PORTB for ultrasonic sensors */
PORTResetPins(IOPORT_B, BIT_8 | BIT_9| BIT_10 | BIT_11 );
PORTSetPinsDigitalOut(IOPORT_B, BIT_8 | BIT_9| BIT_10 | BIT_11); //trigger
/* Input Capture pins for echo signals */
//interrupt on every risging/falling edge starting with a rising edge
PORTSetPinsDigitalIn(IOPORT_D, BIT_8| BIT_9| BIT_10| BIT_11); //INC1, INC2, INC3, INC4 Pin
mIC1ClearIntFlag();
OpenCapture1( IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//front
ConfigIntCapture1(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
OpenCapture2( IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//back
ConfigIntCapture2(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
OpenCapture3( IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//left
ConfigIntCapture3(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
OpenCapture4( IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//right
ConfigIntCapture4(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
/* PINS used for the START (RD13) BUTTON */
PORTSetPinsDigitalIn(IOPORT_D, BIT_13);
#define CONFIG (CN_ON | CN_IDLE_CON)
#define INTERRUPT (CHANGE_INT_ON | CHANGE_INT_PRI_2)
mCNOpen(CONFIG, CN19_ENABLE, CN19_PULLUP_ENABLE);
temp = mPORTDRead();
/* PORT D and E for motors */
//motor 1
mPORTDSetBits(BIT_4 | BIT_5 | BIT_6 | BIT_7); // Turn on PORTD on startup.
mPORTDSetPinsDigitalOut(BIT_4 | BIT_5 | BIT_6 | BIT_7); // Make PORTD output.
//motor 2
mPORTCSetBits(BIT_1 | BIT_2 | BIT_3 | BIT_4); // Turn on PORTC on startup.
mPORTCSetPinsDigitalOut(BIT_1 | BIT_2 | BIT_3 | BIT_4); // Make PORTC output.
//motor 3 and 4
mPORTESetBits(BIT_0 | BIT_1 | BIT_2 | BIT_3 |
BIT_4 | BIT_5 | BIT_6 | BIT_7); // Turn on PORTE on startup.
mPORTESetPinsDigitalOut(BIT_0 | BIT_1 | BIT_2 | BIT_3 |
BIT_4 | BIT_5 | BIT_6 | BIT_7); // Make PORTE output.
// UART2 to connect to the PC.
// This initialization assumes 36MHz Fpb clock. If it changes,
// you will have to modify baud rate initializer.
UARTConfigure(UART2, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(UART2, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UART2, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART2, GetPeripheralClock(), BAUD);
UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
// Configure UART2 RX Interrupt
INTEnable(INT_SOURCE_UART_RX(UART2), INT_ENABLED);
INTSetVectorPriority(INT_VECTOR_UART(UART2), INT_PRIORITY_LEVEL_2);
INTSetVectorSubPriority(INT_VECTOR_UART(UART2), INT_SUB_PRIORITY_LEVEL_0);
/* PORTD for LEDs - DEBUGGING */
mPORTDClearBits(BIT_0 | BIT_1 | BIT_2);
mPORTDSetPinsDigitalOut(BIT_0 | BIT_1 | BIT_2);
// Congifure Change/Notice Interrupt Flag
ConfigIntCN(INTERRUPT);
// configure for multi-vectored mode
INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
// enable interrupts
INTEnableInterrupts();
counterDistanceMeasure=600; //measure ULTRASONICS distance each 60 ms
while (1) {
/***************** Robot MAIN state machine *****************/
unsigned char ret = 0;
switch (Robo_State) {
case 0:
MotorsON = 0;
Robo_State = 0;
InvInitialOrientation(RESET);
TestDog(RESET);
GoToRoom4short(RESET);
BackToStart(RESET);
InitialOrientation(RESET);
GoToCenter(RESET);
GoToRoom4long(RESET);
break;
case 1:
ret = InvInitialOrientation(GO);
if (ret == 1) {
Robo_State = 2;
}
break;
case 2:
ret = TestDog(GO);
if (ret == 1) {
Robo_State = 3; //DOG not found
} else if (ret == 2) {
Robo_State = 4; //DOG found
}
break;
case 3:
ret = GoToRoom4short(GO);
if (ret == 1) {
Robo_State = 0;
}
break;
case 4:
ret = BackToStart(GO);
if (ret == 1) {
Robo_State = 5;
}
break;
case 5:
ret = GoToCenter(GO);
if (ret == 1) {
Robo_State = 6;
}
break;
case 6:
ret = GoToRoom4long(GO);
if (ret == 1) {
Robo_State = 0;
}
break;
}
if (frontDistance < 30 || backDistance < 30 || leftDistance < 30 || rightDistance < 30)
mPORTDSetBits(BIT_0);
else
mPORTDClearBits(BIT_0);
/***************************************************************/
/***************** Motors State Machine ************************/
if (MotorsON) {
/****************************
MOTOR MAP
M1 O-------------O M2 ON EVEN MOTORS, STEPS MUST BE INVERTED
| /\ | i.e. FORWARD IS BACKWARD
| / \ |
| || |
| || |
M3 O-------------O M4
*****************************/
if (M1_counter == 0) {
switch (M1_state) {
case 0: // set 0011
step (0x3 , 1);
if (M1forward)
M1_state = 1;
else
M1_state = 3;
break;
case 1: // set 1001
step (0x9 , 1);
if (M1forward)
M1_state = 2;
else
M1_state = 0;
break;
case 2: // set 1100
step (0xC , 1);
if (M1forward)
M1_state = 3;
else
M1_state = 1;
break;
case 3: // set 0110
default:
step (0x6 , 1);
if (M1forward)
M1_state = 0;
else
M1_state = 2;
break;
}
M1_counter = M1_stepPeriod;
step_counter[0]--;
if (directionNow == countingDirection)
step_counter[1]--;
}
if (M2_counter == 0) {
switch (M2_state) {
case 0: // set 0011
step (0x3 , 2);
if (M2forward)
M2_state = 1;
else
M2_state = 3;
break;
case 1: // set 0110
step (0x6 , 2);
if (M2forward)
M2_state = 2;
else
M2_state = 0;
break;
case 2: // set 1100
step (0xC , 2);
if (M2forward)
M2_state = 3;
else
M2_state = 1;
break;
case 3: // set 1001
default:
step (0x9 , 2);
if (M2forward)
M2_state = 0;
else
M2_state = 2;
break;
}
M2_counter = M2_stepPeriod;
}
if (M3_counter == 0) {
switch (M3_state) {
case 0: // set 0011
step (0x3 , 3);
if (M3forward)
M3_state = 1;
else
M3_state = 3;
break;
case 1: // set 1001
step (0x9 , 3);
if (M3forward)
M3_state = 2;
else
M3_state = 0;
break;
case 2: // set 1100
step (0xC , 3);
if (M3forward)
M3_state = 3;
else
M3_state = 1;
break;
case 3: // set 0110
default:
step (0x6 , 3);
if (M3forward)
M3_state = 0;
else
M3_state = 2;
break;
}
M3_counter = M3_stepPeriod;
}
if (M4_counter == 0) {
switch (M4_state) {
case 0: // set 0011
step (0x3 , 4);
if (M4forward)
M4_state = 1;
else
M4_state = 3;
break;
case 1: // set 0110
step (0x6 , 4);
if (M4forward)
M4_state = 2;
else
M4_state = 0;
break;
case 2: // set 1100
step (0xC , 4);
if (M4forward)
M4_state = 3;
else
M4_state = 1;
break;
case 3: // set 1001
default:
step (0x9 , 4);
if (M4forward)
M4_state = 0;
else
M4_state = 2;
break;
}
M4_counter = M4_stepPeriod;
}
} else {
//motors off
mPORTDSetBits(BIT_4 | BIT_5 | BIT_6 | BIT_7);
mPORTCSetBits(BIT_1 | BIT_2 | BIT_3 | BIT_4);
mPORTESetBits(BIT_0 | BIT_1 | BIT_2 | BIT_3 |
BIT_4 | BIT_5 | BIT_6 | BIT_7);
}
/************************************************************/
/******* TEST CODE, toggles the servos (from 90 deg. to -90 deg.) every 1 s. ********/
/* if (auxcounter == 0) {
servo1_angle = 0;
if (servo2_angle == 90)
servo2_angle = -90;
else
servo2_angle = 90;
auxcounter = 20000; // toggle angle every 2 s.
}
*/
servo1_angle = 0;
servo2_angle = -90;
/*
if (frontDistance > 13 && frontDistance < 17) {
servo2_angle = 90;
}
else
servo2_angle = -90;
*/
/*******************************************************************/
/****************** SERVO CONTROL ******************/
/*
Changing the global servoX_angle at any point in the code will
move the servo to the desired angle.
*/
servo1_counter = (servo1_angle + 90)*(18)/180 + 6; // between 600 and 2400 us
if (servo1_period == 0) {
mPORTASetBits(BIT_2);
servo1_period = SERVOMAXPERIOD; /* 200 * 100us = 20000us period */
}
servo2_counter = (servo2_angle + 90)*(18)/180 + 6; // between 600 and 2400 us
if (servo2_period == 0) {
mPORTASetBits(BIT_3);
servo2_period = SERVOMAXPERIOD; /* 200 * 100us = 20000us period */
}
/*****************************************************/
} /* end of while(1) */
return 0;
}
/******************************************************************************
**** ****
** **
init()
** **
**** ****
******************************************************************************/
void init(void) {
// Force WDT off for now ... having it on tends to confuse novice
// users.
csk_wdt_off();
// Keep interrupts off for now ...
__disable_interrupt();
// All CSK control signals are active LOW.
#if defined(__PIC24FJ256GA110__) // PSPM D
// Minimal set of I/O ... only necessary control signals are configured as outputs.
TRISA = 0xFFFF;
TRISB = ~( BIT5); // TX3
TRISC = ~( BIT1); // -OE_USB
TRISD = ~( BIT8+BIT5+BIT2+BIT1); // HS3, HS4 & HS5, TX2
TRISE = ~( BIT8+BIT4+BIT3+BIT2); // IO.30, -ON_SD, -ON_MHX & -OE_MHX
TRISF = ~( BIT5+BIT3); // TX1 & TX0
PORTA = 0x0000;
PORTB = 0x0000+BIT5; // TX3 initially HIGH
PORTC = 0x0000+BIT1; // -OE_USB is OFF
PORTD = 0x0000+BIT8; // TX2 initially HIGH
PORTE = 0x0000+BIT4+BIT3+BIT2; // -ON_SD, -ON_MHX, -OE_MHX are OFF
PORTF = 0x0000+BIT3+BIT5; // TX0 & TX1 initially HIGH.
PORTG = 0x0000;
AD1PCFGL = 0xFFFF;
#elif defined(__PIC24FJ256GB110__) // PSPM E Rev A
// Minimal set of I/O ... only necessary control signals are configured as outputs.
TRISA = 0xFFFF;
TRISB = ~( BIT5 ); // TX3
TRISC = ~( BIT1 ); // -OE_USB
TRISD = ~( BIT9+BIT8+BIT7+ BIT5 ); // TX0, TX2, HS3, HS5
TRISE = ~( BIT8+ BIT4+BIT3+BIT2 ); // IO.30, -ON_SD, -ON_MHX & -OE_MHX
TRISF = ~( BIT5 ); // TX1
TRISG = ~(BIT15 ); // HS4
PORTA = 0x0000;
PORTB = 0x0000+BIT5; // TX3 initially HIGH
PORTC = 0x0000+BIT1; // -OE_USB is OFF
PORTD = 0x0000+BIT9+BIT8; // TX0, TX2 initially high
PORTE = 0x0000+BIT4+BIT3+BIT2; // -ON_SD, -ON_MHX, -OE_MHX are OFF
PORTF = 0x0000+BIT5; // TX1 initially high.
PORTG = 0x0000;
#elif defined(__PIC24FJ256GB210__) // PSPM E Rev B
// Minimal set of I/O ... only necessary control signals are configured as outputs.
TRISA = 0xFFFF;
TRISB = ~( BIT5 ); // TX3
TRISC = ~( BIT1 ); // -OE_USB
TRISD = ~( BIT9+BIT8+BIT7+ BIT5 ); // TX0, TX2, HS3, HS5
TRISE = ~( BIT8+ BIT4+BIT3+BIT2 ); // IO.30, -ON_SD, -ON_MHX & -OE_MHX
TRISF = ~( BIT5 ); // TX1
TRISG = ~(BIT15 ); // HS4
PORTA = 0x0000;
PORTB = 0x0000+BIT5; // TX3 initially HIGH
PORTC = 0x0000+BIT1; // -OE_USB is OFF
PORTD = 0x0000+BIT9+BIT8; // TX0, TX2 initially high
PORTE = 0x0000+BIT4+BIT3+BIT2; // -ON_SD, -ON_MHX, -OE_MHX are OFF
PORTF = 0x0000+BIT5; // TX1 initially high.
PORTG = 0x0000;
ANSA = 0x0000;
ANSB = 0x0000;
ANSC = 0x0000;
ANSD = 0x0000;
ANSE = 0x0000;
ANSF = 0x0000;
ANSG = 0x0000;
#else
#error PIC24F device not supported by CubeSat Kit
#endif
// High-level inits (works at any clock speed).
csk_mhx_close();
csk_mhx_pwr_off();
csk_usb_close();
csk_led_status_close();
// Set up to run with primary oscillator.
// See _CONFIG2 above. A configuration-word-centric setup of the
// oscillator(s) was chosen because of its relative simplicity.
// Note e.g. that PwrMgnt_OscSel() returns FALSE if clock switching
// (FCKSM) is disabled ...
// Set up Timer2 to run at system tick rate
ConfigIntTimer2(T2_INT_ON & T2_INT_PRIOR_1); // Timer is configured for 10 msec (100Hz), with interrupts
OpenTimer2(T2_ON & T2_IDLE_CON & T2_GATE_OFF & T2_PS_1_1 & T2_32BIT_MODE_OFF & T2_SOURCE_INT,
(MAIN_XTAL_FREQ/(2*100))); // A prescalar is not required because 8E6/200 < 16 bits.
#if defined(__PIC24FJ256GA110__) // PSPM D
// Configure I/O pins for UARTs via PIC24's PPS system.
// RP inputs must be configured as inputs!
// CSK UART0 is used as the terminal, via USB, IO.6(RP17) & IO.7(RP10)
// CSK UART0 (PIC24 UART1) TX/RX = IO.6/IO.7
iPPSInput(IN_FN_PPS_U1RX,IN_PIN_PPS_RP10);
iPPSOutput(OUT_PIN_PPS_RP17,OUT_FN_PPS_U1TX);
// CSK UART1 can talk to GPSRM 1 via IO.4(RP16) & IO.5(RP30)
// CSK UART1 (PIC24 UART2) TX/RX = IO.4/IO.5
iPPSInput(IN_FN_PPS_U2RX,IN_PIN_PPS_RP30);
iPPSOutput(OUT_PIN_PPS_RP16,OUT_FN_PPS_U2TX);
// CSK UART2 can talk to GPSRM 1 via IO.16(RP2) & IO.17(RP22)
// CSK UART2 (PIC24 UART3) TX/RX = IO.16/IO.17
iPPSInput(IN_FN_PPS_U3RX,IN_PIN_PPS_RP22);
iPPSOutput(OUT_PIN_PPS_RP2,OUT_FN_PPS_U3TX);
// CSK UART3 can talk to GPSRM 1 via IO.32(RP18) & IO.33(RP28)
// CSK UART3 (PIC24 UART4) TX/RX = IO.4/IO.5
iPPSInput(IN_FN_PPS_U4RX,IN_PIN_PPS_RP28);
iPPSOutput(OUT_PIN_PPS_RP18,OUT_FN_PPS_U4TX);
#elif defined(__PIC24FJ256GB110__) || defined(__PIC24FJ256GB210__)
iPPSInput(IN_FN_PPS_U1RX,IN_PIN_PPS_RP10); // RF4
iPPSOutput(OUT_PIN_PPS_RP17,OUT_FN_PPS_U1TX); // RF5
iPPSInput(IN_FN_PPS_U2RX,IN_PIN_PPS_RP30); // RF2
iPPSOutput(OUT_PIN_PPS_RP4,OUT_FN_PPS_U2TX); // RD9
iPPSInput(IN_FN_PPS_U3RX,IN_PIN_PPS_RP22); // RD3
iPPSOutput(OUT_PIN_PPS_RP2,OUT_FN_PPS_U3TX); // RD8
iPPSInput(IN_FN_PPS_U4RX,IN_PIN_PPS_RP28); // RB4
iPPSOutput(OUT_PIN_PPS_RP18,OUT_FN_PPS_U4TX); // RB5
#else
#error PIC24F device not supported by CubeSat Kit
#endif
// Init UARTs to 9600,N,8,1
// UARTs won't transmit until interrupts are enabled ...
csk_uart0_open(CSK_UART_9600_N81);
csk_uart1_open(CSK_UART_9600_N81);
csk_uart2_open(CSK_UART_9600_N81);
csk_uart3_open(CSK_UART_9600_N81);
csk_usb_open();
csk_uart0_puts(STR_CRLF STR_CRLF);
csk_uart0_puts("Pumpkin " STR_CSK_TARGET " " STR_APP_NAME "." STR_CRLF);
csk_uart0_puts(STR_VERSION "." STR_CRLF);
csk_uart0_puts(STR_WARNING "." STR_CRLF);
i2c1_open();
} /* init() */