static void board_peripheral_pin_select()
{
// Disable I/O Lock (Peripheral pins can be mapped to PIO pins)
PPSUnLock;
// Map RP3 to UART1 Transmit (U1TX)
PPSOutput(PPS_RP3, PPS_U1TX);
// Map RP2 to UART1 Receive (U1RX)
PPSInput(PPS_U1RX, PPS_RP2);
// Map RP1 to UART2 Transmit (U2TX)
PPSOutput(PPS_RP1, PPS_U2TX);
// Map RP0 to UART2 Receive (U2RX)
PPSInput(PPS_U2RX, PPS_RP0);
// Map RP6 to SPI1 Data Input
PPSInput(PPS_SDI1, PPS_RP6);
// Map RP8 to SPI1 Clock Output
PPSOutput(PPS_RP8, PPS_SCK1OUT);
// Map RP9 to SPI1 Data Output
PPSOutput(PPS_RP9, PPS_SDO1);
// Map RP12 to External Interrupt 1 (IRQ1)
PPSInput(PPS_INT1, PPS_RP12);
// Enable I/O Lock
PPSLock;
}
/**
* Initializes all PIC functionality beyond the clock.
* * Maps all ECAN/UART pins
* * Assigns pins as input/output
* * Initializes the UART
*/
void Init(void)
{
// And configure the Peripheral Pin Select pins:
PPSUnLock;
#ifdef __dsPIC33FJ128MC802__
// To enable ECAN1 pins: TX on 7, RX on 4
PPSOutput(OUT_FN_PPS_C1TX, OUT_PIN_PPS_RP7);
PPSInput(IN_FN_PPS_C1RX, IN_PIN_PPS_RP4);
// To enable UART1 pins: TX on B11/P11, RX on B13/P13
PPSOutput(OUT_FN_PPS_U1TX, OUT_PIN_PPS_RP11);
PPSInput(IN_FN_PPS_U1RX, IN_PIN_PPS_RP13);
#elif __dsPIC33EP256MC502__
// To enable ECAN1 pins: TX on 39, RX on 36
PPSOutput(OUT_FN_PPS_C1TX, OUT_PIN_PPS_RP39);
PPSInput(IN_FN_PPS_C1RX, IN_PIN_PPS_RP36);
// To enable UART1 pins: TX on B11/P43, RX on B13/P45
PPSOutput(OUT_FN_PPS_U1TX, OUT_PIN_PPS_RP43);
PPSInput(IN_FN_PPS_U1RX, IN_PIN_PPS_RPI45);
#else
#error Invalid processor selected.
#endif
PPSLock;
// Initialize status LEDs for use.
// A3 (output): Red LED, off by default.
_TRISA3 = 0;
_LATA3 = 0;
// A4 (output): Amber LED, on by default.
_TRISA4 = 0;
_LATA4 = 1;
_TRISB7 = 0; // Set ECAN1_TX pin to an output
_TRISB4 = 1; // Set ECAN1_RX pin to an input;
_TRISB11 = 0; // Set UART1_TX pin to an output
_TRISB13 = 1; // Set UART1_RX pin to an input;
// Set up UART1 for 57600 baud. There's no round() on the dsPICs, so we implement our own.
double brg = (double) F_OSC / 2.0 / 16.0 / UART_BAUD - 1.0;
if (brg - floor(brg) >= 0.5) {
brg = ceil(brg);
} else {
brg = floor(brg);
}
Uart1Init((uint16_t)brg);
// Initialize the Canaconda interface library callback functions
commandFunction[COMMAND_FUNCTION_INDEX_OPEN] = CommandOpen;
commandFunction[COMMAND_FUNCTION_INDEX_CLOSE] = CommandClose;
commandFunction[COMMAND_FUNCTION_INDEX_SETUP] = CommandSetup;
commandFunction[COMMAND_FUNCTION_INDEX_TRANSMIT] = CommandTransmit;
}
int InitPPS( void)
{
// Setup Peripheral Pin Select for UART2, SPI1, SPI2,
// IC1, OC1, OC3, OC4 on PIC24 GB110 and GA110 PIMs
PPSUnLock;
// SPI1
PPSOutput( PPS_RP15, PPS_SDO1); // SDO1 =RP15 F8/pin 53
// SDO1 is the only pin we will use
// SPI2
PPSInput( PPS_SDI2, PPS_RP26); // SDI2 =RP26 G7/pin 11
PPSOutput( PPS_RP22, PPS_SCK2OUT); // SCK2 =RP21 G6/pin 10
PPSOutput( PPS_RP21, PPS_SDO2); // SDO2 =RP19 G8/pin 12
// UART
PPSInput( PPS_U2RX, PPS_RP10); // U2RX =RP10 F4/pin 49
PPSInput( PPS_U2CTS, PPS_RPI32); // U2CTS=RP32 F12/pin40
PPSOutput( PPS_RP17, PPS_U2TX); // U2TX =RP17 F5/pin 50
PPSOutput( PPS_RP31, PPS_U2RTS); // U2RTS=RP31 F13pin 39
// IC
PPSInput( PPS_IC1, PPS_RP2); // IC1 =RP2 D8/pin 68
// OC
PPSOutput( PPS_RP19, PPS_OC1); // OC1 =RP11 D0/pin 72
PPSOutput( PPS_RP11, PPS_OC2); // OC2 =RP24 D1/pin 76
PPSOutput( PPS_RP24, PPS_OC4); // OC4 =RP22 D3/pin 78
// GB110 PIM pin-remapping to accomodate additional USB pins
// GB110 shares usage of D2/pin 77 between SDI1 and OC3
// pin 54 SDI1 is remapped to Explorer pin 77/D2
// NOTE: we will use it only as OC3
// pin 55 SCK1 is remapped to Explorer pin 25/B0
// NOTE: pin 55 is input only, connecting it to SCK1
// restricts usage to "slave mode" only
// pin 56 RG3 is remapped to Explorer pin 89/G1
// pin 57 RG2 is remapped to Explorer pin 90/G0
#ifdef __PIC24FJ256GB110__
PPSOutput( PPS_RP23, PPS_OC3OUT); // OC3=RP23 D2/pin 77
#endif
// Done, lock the PPS configuration
PPSLock;
return 0;
} // InitPPS
inline void Pin_Setup(void)
{
TRISBbits.TRISB11 = 1;
/*Set RB11 as external interrupt INT1*/
PPSInput(PPS_INT1, PPS_RP11);
}
int main(void) {
char buffer[80];
unsigned int pb_clock;
float actual_baud;
const int baud = 500000; // max baud rate using arduino interface
pb_clock = SYSTEMConfigPerformance(SYS_CLK); // if sys_clock > 100MHz, pb_clock = sys_clock/2 else pb_clock = sys_clock
PORTSetPinsDigitalOut(IOPORT_E, BIT_4); // led
// setup UART
PPSUnLock;
PPSInput(1,U1RX,RPF4); // Rx - F4 (pin 49) 5V tolerent
PPSOutput(2,RPF5,U1TX); // Tx - F5 (pin 50) 5V tolerent
PPSLock;
actual_baud = U1_init(pb_clock, baud);
sprintf(buffer, "SYSCLK: %d\r\n", SYS_CLK);
U1_write(buffer);
sprintf(buffer, "PBCLK: %d\r\n", pb_clock);
U1_write(buffer);
sprintf(buffer, "U1BRG: %d\r\n", U1BRG);
U1_write(buffer);
sprintf(buffer, "target baud: %d\r\n", baud);
U1_write(buffer);
sprintf(buffer, "actual baud: %f\r\n", actual_baud);
U1_write(buffer);
timer1_init();
timer_delay_test();
}
void SERIAL_Init(void) {
transmitBuffer = (struct CircBuffer*) &outgoingUart; //set up buffer for receive
newCircBuffer(transmitBuffer);
receiveBuffer = (struct CircBuffer*) &incomingUart; //set up buffer for transmit
newCircBuffer(receiveBuffer);
UARTConfigure(UART1, 0x00);
UARTSetDataRate(UART1, F_PB, 115200);
UARTSetFifoMode(UART1, UART_INTERRUPT_ON_RX_NOT_EMPTY | UART_INTERRUPT_ON_TX_BUFFER_EMPTY);
INTSetVectorPriority(INT_UART_1_VECTOR, INT_PRIORITY_LEVEL_4); //set the interrupt priority
//RPC5R = 1;
PPSOutput(1, RPC5, U1TX);
PORTSetPinsDigitalIn(IOPORT_C, BIT_3);
//U1RXRbits.U1RXR = 0b111;
PPSInput(3, U1RX, RPC3);
UARTEnable(UART1, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_TX | UART_RX));
INTEnable(INT_U1RX, INT_ENABLED);
//INTSetFlag(INT_U1RX);
//INTEnable(INT_U1TX, INT_ENABLED);
//PutChar('z');
}
// Initialization.
void hc05_init(void) {
// PPS UART2
PPSInput (PPS_U2RX, PPS_RP6); // U2RX = RP6
PPSOutput(PPS_RP15, PPS_U2TX); // U2TX = RP15
// UART2 init
U2BRG = 34; // Baud Rate = 115200 (Fcy = 16 MHz)
U2MODE = 0x8008; // UART is enabled, BRGH = 1
U2STA = 0x0400; // Transmit enabled
}
static void map_peripherals()
{
/* unlock PPS sequence */
SYSKEY = 0x0; /* make sure it is locked */
SYSKEY = 0xAA996655; /* Key 1 */
SYSKEY = 0x556699AA; /* Key 2 */
CFGCONbits.IOLOCK=0; /* now it is unlocked */
/* map SPI and PWM pins */
PPSInput(4, SS2, RPB14); /* CS */
PPSInput(3, SDI2, RPB13); /* MOSI */
PPSOutput(2, RPB11, SDO2); /* MISO */
PPSOutput(1, RPA0, OC1); /* PWM 0 */
PPSOutput(2, RPA1, OC2); /* PWM 1 */
PPSOutput(4, RPB0, OC3); /* PWM 2 */
/* lock PPS sequence */
CFGCONbits.IOLOCK=1; /* now it is locked */
SYSKEY = 0x0; /* lock register access */
}
int main(void)
{
initPic32();
PORTSetPinsDigitalIn(IOPORT_A, BIT_0);
PORTSetPinsDigitalIn(IOPORT_A, BIT_1);
PORTSetPinsDigitalIn(IOPORT_B, BIT_14);
PPSInput(1, SS1, RPA0);
PPSInput(2, SDI1, RPA1);
#ifndef NO_SDO
PPSOutput(3, RPA2, SDO1);
#endif
SpiChnOpen(1, SPI_OPEN_MODE8|SPI_OPEN_SLVEN|SPI_OPEN_SSEN
#ifdef NO_SDO
|SPI_OPEN_DISSDO
#endif
, 2);
init();
uint8_t lastByteReceived = 0;
uint8_t cmd[8];
uint8_t length=0;
uint8_t toRead = 1;
while(1) {
if(SpiChnTxBuffEmpty(1))
SpiChnPutC(1, lastByteReceived);
lastByteReceived = 0;
while(!SpiChnDataRdy(1))
loop();
uint8_t byte = SpiChnGetC(1);
cmd[length++] = byte;
toRead--;
if(toRead==0)
toRead = commandReceived(cmd, length);
}
}
/**
* Initialize pin mappings and set pins as digital.
*/
void initPins(void)
{
// And configure the Peripheral Pin Select pins:
PPSUnLock;
// To enable ECAN1 pins: TX on 7, RX on 4
PPSOutput(OUT_FN_PPS_C1TX, OUT_PIN_PPS_RP39);
PPSInput(PPS_C1RX, PPS_RP20);
// To enable UART2 pins: TX on 11, RX on 13
PPSOutput(OUT_FN_PPS_U2TX, OUT_PIN_PPS_RP43);
PPSInput(PPS_U2RX, PPS_RPI45);
// enable the SPI stuff: clock, in, out
PPSOutput(OUT_FN_PPS_SCK2, OUT_PIN_PPS_RP41);
PPSOutput(OUT_FN_PPS_SDO2, OUT_PIN_PPS_RP40);
PPSInput(PPS_SDI2, PPS_RP42);
PPSLock;
// Disable A/D functions on pins
ANSELA = 0;
ANSELB = 0;
}
inline void INT2_Setup(void) //Setup External Interrupt 0
{
_INT2IF = 0;
//For INT2EP: 0=Positive Edge, 1=Negative Edge
_INT2EP = 0;
TRISBbits.TRISB6 = IN;
PPSInput(PPS_INT2, PPS_RP6);
_INT2IE = 1; //Turn on INT2 Interrupt
return;
}
inline void INT1_Setup(void) //Setup External Interrupt 1
{
_INT1IF = 0;
//For INT1EP: 0=Positive Edge, 1=Negative Edge
_INT1EP = 0;
TRISBbits.TRISB5 = IN;
PPSInput(PPS_INT1, PPS_RP5);
_INT1IE = 1; //Turn on INT1 Interrupt
return;
}
inline void INT2_Setup(void) //Setup External Interrupt 0
{
_INT2IF = 0;
//For INT2EP: 0=Positive Edge, 1=Negative Edge
_INT2EP = 0;
TRISBbits.TRISB6 = IN;
PPSInput(IN_FN_PPS_INT2, IN_PIN_PPS_RP6);
_INT2IE = 0; //Turn on INT2 Interrupt
printf("INT2 Setup\r\n");
return;
}
inline void INT1_Setup(void) //Setup External Interrupt 1
{
_INT1IF = 0;
//For INT1EP: 0=Positive Edge, 1=Negative Edge
_INT1EP = 0;
TRISBbits.TRISB5 = IN;
PPSInput(IN_FN_PPS_INT1, IN_PIN_PPS_RP5);
_INT1IE = 0; //Turn on INT1 Interrupt
printf("INT1 Setup\r\n");
return;
}
//===================== Main ======================= //
void main(void) {
SYSTEMConfig( SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
ANSELA = 0; ANSELB = 0; CM1CON = 0; CM2CON = 0;
PT_setup();
INTEnableSystemMultiVectoredInt();
// initialize the threads
PT_INIT(&pt_blink);
PT_INIT(&pt_capture);
// initialize the display
tft_init_hw();
tft_begin();
tft_fillScreen(ILI9340_BLACK);
tft_setRotation(0); //240x320 vertical display
// initialize the comparator
CMP1Open(CMP_ENABLE | CMP_OUTPUT_ENABLE | CMP1_NEG_INPUT_IVREF);
// initialize the timer2
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_64, 0xffffffff);
// initialize the input capture, uses timer2
OpenCapture1( IC_EVERY_RISE_EDGE | IC_FEDGE_RISE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON);
ConfigIntCapture1(IC_INT_ON | IC_INT_PRIOR_3 | IC_INT_SUB_PRIOR_3 );
INTClearFlag(INT_IC1);
// initialize the input/output I/O
mPORTBSetPinsDigitalOut(BIT_3);
mPORTBClearBits(BIT_3);
PPSOutput(4, RPB9, C1OUT); //set up output of comparator for debugging
PPSInput(3, IC1, RPB13); //Either Pin 6 or Pin 24 idk
//round-robin scheduler for threads
while(1) {
PT_SCHEDULE(protothread_blink(&pt_blink));
PT_SCHEDULE(protothread_capture(&pt_capture));
}
} //main
void Setup_SPI1()
{
OpenSPI1(
(
ENABLE_SCK_PIN &//
// FIFO_BUFFER_DISABLE &
ENABLE_SDO_PIN &//
SPI_MODE16_OFF &//
SPI_SMP_ON &//
SPI_CKE_ON &//
SLAVE_ENABLE_OFF &//
CLK_POL_ACTIVE_HIGH &//
MASTER_ENABLE_ON &//
SEC_PRESCAL_4_1 &//
PRI_PRESCAL_4_1//
)
,
(
FRAME_ENABLE_OFF & //NOT USED
FRAME_SYNC_OUTPUT & //NOT USED
FRAME_POL_ACTIVE_HIGH & //NOT USED
FRAME_SYNC_EDGE_PRECEDE //NOT USED
)
,
(
SPI_ENABLE &//
SPI_IDLE_CON &//
SPI_RX_OVFLOW_CLR //
)
);
ConfigIntSPI1(SPI_INT_EN & SPI_INT_PRI_5);
PPSOutput(OUT_FN_PPS_SCK1, OUT_PIN_PPS_RP8);//CLK
PPSOutput(OUT_FN_PPS_SDO1, OUT_PIN_PPS_RP7);//MOSI
PPSInput(IN_FN_PPS_SDI1, IN_PIN_PPS_RP6); //MISO
TRISBbits.TRISB8 = 0;//Clk
TRISBbits.TRISB7 = 0;//MOSI
TRISBbits.TRISB6 = 1;//MISO
printf("SPI1 Setup\r\n");
return;
}
void HilNodeInit(void)
{
// Set a unique node ID for this node.
nodeId = CAN_NODE_HIL;
// And configure the Peripheral Pin Select pins:
PPSUnLock;
// To enable ECAN1 pins: TX on 7, RX on 4
PPSOutput(OUT_FN_PPS_C1TX, OUT_PIN_PPS_RP7);
PPSInput(PPS_C1RX, PPS_RP4);
// To enable UART1 pins: TX on 11, RX on 13
PPSOutput(OUT_FN_PPS_U1TX, OUT_PIN_PPS_RP11);
PPSInput(PPS_U1RX, PPS_RP13);
// Configure SPI1 so that:
// * (input) SPI1.SDI = B8
PPSInput(PPS_SDI1, PPS_RP10);
// * SPI1.SCK is output on B9
PPSOutput(OUT_FN_PPS_SCK1, OUT_PIN_PPS_RP9);
// * (output) SPI1.SDO = B10
PPSOutput(OUT_FN_PPS_SDO1, OUT_PIN_PPS_RP8);
PPSLock;
// Enable pin A4, the amber LED on the CAN node, as an output. We'll blink this at 1Hz. It'll
// stay lit when in HIL mode with it turning off whenever packets are received.
_TRISA4 = 0;
// Initialize communications for HIL.
HilInit();
// Set Timer4 to be a 4Hz timer. Used for blinking the amber status LED.
Timer4Init(HilNodeBlink, 39062);
// Set up Timer2 for a 100Hz timer. This triggers CAN message transmission at the same frequency
// that the sensors actually do onboard the boat.
Timer2Init(HilNodeTimer100Hz, 1562);
// Initialize ECAN1
Ecan1Init();
// Set a schedule for outgoing CAN messages
// Transmit the rudder angle at 10Hz
if (!AddMessageRepeating(&sched, SCHED_ID_RUDDER_ANGLE, 10)) {
FATAL_ERROR();
}
// Transmit the rudder status at 10Hz
if (!AddMessageRepeating(&sched, SCHED_ID_RUDDER_LIMITS, 10)) {
FATAL_ERROR();
}
// Transmit the throttle status at 100Hz
if (!AddMessageRepeating(&sched, SCHED_ID_THROTTLE_STATUS, 10)) {
FATAL_ERROR();
}
// Transmit the RC status at 2Hz
if (!AddMessageRepeating(&sched, SCHED_ID_RC_STATUS, 2)) {
FATAL_ERROR();
}
// Transmit latitude/longitude at 5Hz
if (!AddMessageRepeating(&sched, SCHED_ID_LAT_LON, 5)) {
FATAL_ERROR();
}
// Transmit heading & speed at 5Hz
if (!AddMessageRepeating(&sched, SCHED_ID_COG_SOG, 5)) {
FATAL_ERROR();
}
// Transmit heading & speed at 5Hz
if (!AddMessageRepeating(&sched, SCHED_ID_GPS_FIX, 5)) {
FATAL_ERROR();
}
}
UINT16 SetupUART(void)
{
PPSOutput(OUT_FN_PPS_U1TX, OUT_PIN_PPS_RP37);
PPSInput(PPS_U1RX, PPS_RP20);
OpenUART1(UART_EN &
UART_IDLE_CON &
UART_IrDA_DISABLE &
UART_MODE_SIMPLEX &
UART_UEN_00 &
UART_EN_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_SYNC_BREAK_DISABLED &
UART_TX_ENABLE &
UART_INT_RX_CHAR &
UART_ADR_DETECT_DIS
,
23
//BAUD = 9600
);
U1STAbits.UTXINV = 0; //make TX active low
//U1STAbits.URXISEL = 0x00; //force interrupt on every 8 bits recieved
ConfigIntUART1(UART_RX_INT_EN &
UART_RX_INT_PR4 &
UART_TX_INT_DIS
);
/*This is a copy of UART setup working for TX
OpenUART1(UART_EN &
UART_IDLE_CON &
UART_IrDA_DISABLE &
UART_MODE_SIMPLEX &
UART_UEN_00 &
UART_EN_WAKE &
UART_DIS_LOOPBACK &
UART_DIS_ABAUD &
UART_UXRX_IDLE_ZERO &
UART_BRGH_SIXTEEN &
UART_NO_PAR_8BIT &
UART_1STOPBIT
,
UART_INT_TX_BUF_EMPTY &
UART_SYNC_BREAK_DISABLED &
UART_TX_ENABLE &
UART_INT_RX_BUF_FUL &
UART_ADR_DETECT_DIS
,
23
//BAUD = 9600
);
U1STAbits.UTXINV = 0;
*/
return 0; //return success
}
void initIO()
{
ANSELB = 0x3400; //AN0 - AN15
ANSELGbits.ANSG6 = 0; //AN16
ANSELGbits.ANSG7 = 0; //AN17
ANSELGbits.ANSG8 = 0; //AN18
ANSELGbits.ANSG9 = 0; //AN19
ANSELEbits.ANSE2 = 0; //AN20
ANSELEbits.ANSE4 = 0; //AN21
ANSELEbits.ANSE5 = 0; //AN22
ANSELEbits.ANSE6 = 0; //AN23
ANSELEbits.ANSE7 = 0; //AN27
ANSELDbits.ANSD1 = 0; //AN24
ANSELDbits.ANSD2 = 0; //AN25
ANSELDbits.ANSD3 = 0; //AN26
//Configure analog pins IO
TRISBbits.TRISB0 = 0;
TRISBbits.TRISB1 = 1;
TRISBbits.TRISB2 = 1;
TRISBbits.TRISB3 = 0;
TRISBbits.TRISB4 = 0;
TRISBbits.TRISB5 = 0;
TRISBbits.TRISB8 = 1;
TRISBbits.TRISB9 = 0;
TRISBbits.TRISB10 = 1;
TRISBbits.TRISB11 = 0;
TRISBbits.TRISB12 = 1;
TRISBbits.TRISB13 = 1;
TRISBbits.TRISB14 = 0;
TRISBbits.TRISB15 = 0;
TRISEbits.TRISE0 = 0;
TRISEbits.TRISE1 = 0;
TRISEbits.TRISE2 = 0;
TRISEbits.TRISE3 = 0;
TRISEbits.TRISE4 = 0;
TRISEbits.TRISE5 = 0;
TRISEbits.TRISE6 = 0;
TRISEbits.TRISE7 = 0;
TRISD = 0x001C;
TRISGbits.TRISG6 = 0;
TRISGbits.TRISG7 = 1; //pin RG7 is configured as SPI input
TRISGbits.TRISG8 = 0;
TRISGbits.TRISG9 = 0;
TRISC = 0x0000; //RC1-RC4 extra pins
/* ********************* Assign UART 2 signals onto pins using PPS *********************************** */
PPSInput(4, U4RX, RPB2); //Assign U2RX to pin RPD8
PPSOutput(3, RPB0, U4TX); //Assign U2TX to pin RPD9
/* ********************* Assign Encoders signals onto pins using PPS ************************************/
PPSInput(3, T4CK, RPD4); //Assign T4CK to pin RPD4
PPSInput(2, T5CK, RPB1); //Assign T5CK to pin RPD11
/* ********************* Assign SDI/O 2 signals onto pins using PPS *********************************** */
PPSInput(2, SDI2, RPG7); //Assign SDI2 to pin RPG7
PPSOutput(1, RPG8, SDO2); //Assign SDO2 to pin RPG8
/* ********************* Assign OC1 & OC2************************************************************** */
PPSOutput(4, RPD1, OC1);
PPSOutput(4, RPD5, OC2);
//mappingMode = 1;
//fastMode = 0;
}
int main(void)
#endif
{
BYTE i, j;
BYTE TxSynCount = 0;
BOOL bReceivedMessage = FALSE;
_U16 m;
#define BAUDRG 77
/*******************************************************************/
// Initialize the system
/*******************************************************************/
ANCON0 = 0XFF; /*desactiva entradas analogicas*/
ANCON1 = 0XFF; /*desactiva entradas analogicas*/
PPSUnLock();
PPSOutput(PPS_RP10, PPS_TX2CK2); // TX2 RP17/RC6
PPSInput(PPS_RX2DT2, PPS_RP9); // RX2 RP18/RC7
PPSOutput(PPS_RP23, PPS_SDO2); // SDO2 RP23/RD6
PPSInput(PPS_SDI2, PPS_RP24); // SDI2 RP24/RD7
PPSOutput(PPS_RP22, PPS_SCK2); // SCK2 RP22/RD5
PPSLock();
System_PeripheralPinSelect( ExternalInterrupt3, 19); /*external interrupt 3 B3*/
BoardInit();
ConsoleInit();
Open2USART(USART_TX_INT_OFF & USART_RX_INT_OFF & USART_EIGHT_BIT & USART_ASYNCH_MODE & USART_ADDEN_OFF, BAUDRG);
baud2USART(BAUD_IDLE_TX_PIN_STATE_HIGH & BAUD_IDLE_RX_PIN_STATE_HIGH & BAUD_AUTO_OFF & BAUD_WAKEUP_OFF & BAUD_16_BIT_RATE & USART_RX_INT_OFF);
Gpios_PinDirection(GPIOS_PORTD, 7, GPIOS_INPUT); /*pin C0 como salida para SDI*/
Gpios_PinDirection(GPIOS_PORTD, 6, GPIOS_OUTPUT); /*pin C1 como salida para SDO*/
Gpios_PinDirection(GPIOS_PORTD, 5, GPIOS_OUTPUT); /*pin C2 como salida para SCK*/
Spi_Init(SPI_PORT1, SPI_64DIV); /*Inicializamos SPI2*/
Spi_Init(SPI_PORT2, SPI_64DIV); /*Inicializamos SPI2*/
//Spi_SetMode(SPI_PORT1, 1);
//Spi_SetMode(SPI_PORT1, 1);
LED_1 = 1;
LED_2 = 1;
Read_MAC_Address();
LED_1 = 0;
LED_2 = 0;
ConsolePutROMString((ROM char *)"\r\n<MAC Addr:");
PrintChar(myLongAddress[3]);
PrintChar(myLongAddress[2]);
PrintChar(myLongAddress[1]);
PrintChar(myLongAddress[0]);
ConsolePutROMString((ROM char *)"\r>");
Printf("\r\nStarting Testing Interface for MiWi(TM) PRO Stack ...");
#if defined(MRF24J40)
Printf("\r\n RF Transceiver: MRF24J40");
#elif defined(MRF49XA)
Printf("\r\n RF Transceiver: MRF49XA");
#elif defined(MRF89XA)
Printf("\r\n RF Transceiver: MRF89XA");
#endif
Printf("\r\n Demo Instruction:");
Printf("\r\n Press Enter to bring up the menu.");
Printf("\r\n Type in hyper terminal to choose");
Printf("\r\n menu item. ");
Printf("\r\n\r\n");
/*******************************************************************/
// Following block display demo information on LCD of Explore 16 or
// PIC18 Explorer demo board.
/*******************************************************************/
#if defined(MRF49XA)
LCDDisplay((char *)"MiWi PRO Test Interface MRF49XA", 0, TRUE);
#elif defined(MRF24J40)
LCDDisplay((char *)"MiWi PRO Test Interface MRF24J40", 0, TRUE);
#elif defined(MRF89XA)
LCDDisplay((char *)"MiWi PRO Test Interface MRF89XA", 0, TRUE);
#endif
//if( (PUSH_BUTTON_1 == 0) || ( MiApp_ProtocolInit(TRUE) == FALSE ) )
if (PUSH_BUTTON_1 == 1)
{
MiApp_ProtocolInit(FALSE);
LED_1 = 0;
LED_2 = 0;
#ifdef ENABLE_ACTIVE_SCAN
myChannel = 0xFF;
ConsolePutROMString((ROM char *)"\r\nStarting Active Scan...");
LCDDisplay((char *)"Active Scanning", 0, FALSE);
/*******************************************************************/
// Function MiApp_SearchConnection will return the number of
// existing connections in all channels. It will help to decide
// which channel to operate on and which connection to add.
// The return value is the number of connections. The connection
// data are stored in global variable ActiveScanResults.
// Maximum active scan result is defined as
// ACTIVE_SCAN_RESULT_SIZE
// The first parameter is the scan duration, which has the same
// definition in Energy Scan. 10 is roughly 1 second. 9 is a
// half second and 11 is 2 seconds. Maximum scan duration is 14,
// or roughly 16 seconds.
// The second parameter is the channel map. Bit 0 of the
// double word parameter represents channel 0. For the 2.4GHz
// frequency band, all possible channels are channel 11 to
// channel 26. As the result, the bit map is 0x07FFF800. Stack
// will filter out all invalid channels, so the application
// only needs to pay attention to the channels that are not
// preferred.
/*******************************************************************/
i = MiApp_SearchConnection(10, 0x02000000);
if( i > 0 )
{
// now print out the scan result.
Printf("\r\nActive Scan Results: \r\n");
for(j = 0; j < i; j++)
{
Printf("Channel: ");
PrintDec(ActiveScanResults[j].Channel );
Printf(" RSSI: ");
PrintChar(ActiveScanResults[j].RSSIValue);
Printf("\r\n");
myChannel = ActiveScanResults[j].Channel;
Printf("PeerInfo: ");
PrintChar( ActiveScanResults[j].PeerInfo[0]);
}
}
#endif
/*******************************************************************/
// Function MiApp_ConnectionMode sets the connection mode for the
// protocol stack. Possible connection modes are:
// - ENABLE_ALL_CONN accept all connection request
// - ENABLE_PREV_CONN accept only known device to connect
// - ENABL_ACTIVE_SCAN_RSP do not accept connection request, but
// allow response to active scan
// - DISABLE_ALL_CONN disable all connection request, including
// active scan request
/*******************************************************************/
MiApp_ConnectionMode(ENABLE_ALL_CONN);
if( i > 0 )
{
/*******************************************************************/
// Function MiApp_EstablishConnection try to establish a new
// connection with peer device.
// The first parameter is the index to the active scan result, which
// is acquired by discovery process (active scan). If the value
// of the index is 0xFF, try to establish a connection with any
// peer.
// The second parameter is the mode to establish connection, either
// direct or indirect. Direct mode means connection within the
// radio range; Indirect mode means connection may or may not
// in the radio range.
/*******************************************************************/
if( MiApp_EstablishConnection(0, CONN_MODE_DIRECT) == 0xFF )
{
Printf("\r\nJoin Fail");
}
}
else
{
/*******************************************************************/
// Function MiApp_StartConnection tries to start a new network
//
// The first parameter is the mode of start connection. There are
// two valid connection modes:
// - START_CONN_DIRECT start the connection on current
// channel
// - START_CONN_ENERGY_SCN perform an energy scan first,
// before starting the connection on
// the channel with least noise
// - START_CONN_CS_SCN perform a carrier sense scan
// first, before starting the
// connection on the channel with
// least carrier sense noise. Not
// supported on currrent radios
//
// The second parameter is the scan duration, which has the same
// definition in Energy Scan. 10 is roughly 1 second. 9 is a
// half second and 11 is 2 seconds. Maximum scan duration is
// 14, or roughly 16 seconds.
//
// The third parameter is the channel map. Bit 0 of the
// double word parameter represents channel 0. For the 2.4GHz
// frequency band, all possible channels are channel 11 to
// channel 26. As the result, the bit map is 0x07FFF800. Stack
// will filter out all invalid channels, so the application
// only needs to pay attention to the channels that are not
// preferred.
/*******************************************************************/
#ifdef ENABLE_ED_SCAN
//LCDDisplay((char *)"Active Scanning Energy Scanning", 0, FALSE);
ConsolePutROMString((ROM char *)"\r\nActive Scanning Energy Scanning");
MiApp_StartConnection(START_CONN_ENERGY_SCN, 10, 0x02000000);
#endif
}
// Turn on LED 1 to indicate ready to accept new connections
LED_1 = 1;
}
else
{
//LCDDisplay((char *)" Network Freezer ENABLED", 0, TRUE);
Printf("\r\nNetwork Freezer Feature is enabled. There will be no hand-shake process.\r\n");
LED_1 = 1;
DumpConnection(0xFF);
}
LCDDisplay((char *)"Start Connection on Channel %d", currentChannel, TRUE);
LCDDisplay((char *)"Testing Menu on Hyper Terminal", 0, FALSE);
while(1)
{
/*******************************************************************/
// Function MiApp_MessageAvailable will return a boolean to indicate
// if a message for application layer has been received by the
// transceiver. If a message has been received, all information will
// be stored in the rxMessage, structure of RECEIVED_MESSAGE.
/*******************************************************************/
if( MiApp_MessageAvailable() )
{
/*******************************************************************/
// If a packet has been received, following code prints out some of
// the information available in rxFrame.
/*******************************************************************/
if( rxMessage.flags.bits.secEn )
{
ConsolePutROMString((ROM char *)"Secured ");
}
if( rxMessage.flags.bits.broadcast )
{
ConsolePutROMString((ROM char *)"Broadcast Packet with RSSI ");
}
else
{
ConsolePutROMString((ROM char *)"Unicast Packet with RSSI ");
}
PrintChar(rxMessage.PacketRSSI);
if( rxMessage.flags.bits.srcPrsnt )
{
ConsolePutROMString((ROM char *)" from ");
if( rxMessage.flags.bits.altSrcAddr )
{
PrintChar(rxMessage.SourceAddress[1]);
PrintChar(rxMessage.SourceAddress[0]);
}
else
{
for(i = 0; i < MY_ADDRESS_LENGTH; i++)
{
PrintChar(rxMessage.SourceAddress[MY_ADDRESS_LENGTH-1-i]);
}
}
}
ConsolePutROMString((ROM char *)": ");
for(i = 0; i < rxMessage.PayloadSize; i++)
{
ConsolePut(rxMessage.Payload[i]);
}
// Toggle LED2 to indicate receiving a packet.
LED_2 ^= 1;
/*******************************************************************/
// Function MiApp_DiscardMessage is used to release the current
// received message. After calling this function, the stack can
// start to process the next received message.
/*******************************************************************/
MiApp_DiscardMessage();
bReceivedMessage = TRUE;
/*******************************************************************/
// Following block update the total received and transmitted messages
// on the LCD of the demo board.
/*******************************************************************/
LCDTRXCount(TxNum, ++RxNum);
}
else
{
++m;
if(m > 8000)
{
m=0;
//LED_1 ^= 1;
MiApp_FlushTx();
MiApp_WriteData('H');
MiApp_WriteData('o');
MiApp_WriteData('l');
MiApp_WriteData('a');
MiApp_WriteData('a');
MiApp_WriteData('a');
MiApp_WriteData(0x0D);
MiApp_WriteData(0x0A);
MiApp_BroadcastPacket(FALSE);
}
if ( ConsoleIsGetReady() )
{
//ProcessMenu();
}
}
}
}
void main(void)
{
#define BAUDRG 77
BYTE SecNum = 0;
BOOL Tx_Success = FALSE;
BYTE Tx_Trials = 0, scanresult = 0;
/*******************************************************************/
// Initialize the system
/*******************************************************************/
ANCON0 = 0XFF; /*desactiva entradas analogicas*/
ANCON1 = 0XFF; /*desactiva entradas analogicas*/
PPSUnLock();
PPSOutput(PPS_RP10, PPS_TX2CK2); // TX2 RP17/RC6 icsp
PPSInput(PPS_RX2DT2, PPS_RP9); // RX2 RP18/RC7
PPSOutput(PPS_RP23, PPS_SDO2); // SDO2 RP23/RD6
PPSInput(PPS_SDI2, PPS_RP24); // SDI2 RP24/RD7
PPSOutput(PPS_RP22, PPS_SCK2); // SCK2 RP22/RD5
PPSLock();
System_PeripheralPinSelect( ExternalInterrupt3, 19); /*external interrupt 3 B3*/
BoardInit();
ConsoleInit();
Gpios_PinDirection(GPIOS_PORTC, 7, GPIOS_INPUT); /*pin C0 como salida para SDI*/
Gpios_PinDirection(GPIOS_PORTC, 6, GPIOS_OUTPUT); /*pin C1 como salida para SDO*/
//Gpios_PinDirection(GPIOS_PORTD, 4, GPIOS_OUTPUT); /*pin D4 como salida */
Open1USART(USART_TX_INT_OFF & USART_RX_INT_OFF & USART_EIGHT_BIT & USART_ASYNCH_MODE & USART_ADDEN_OFF, BAUDRG);
baud1USART(BAUD_IDLE_TX_PIN_STATE_HIGH & BAUD_IDLE_RX_PIN_STATE_HIGH & BAUD_AUTO_OFF & BAUD_WAKEUP_OFF & BAUD_16_BIT_RATE & USART_RX_INT_OFF);
Open2USART(USART_TX_INT_OFF & USART_RX_INT_OFF & USART_EIGHT_BIT & USART_ASYNCH_MODE & USART_ADDEN_OFF, BAUDRG);
baud2USART(BAUD_IDLE_TX_PIN_STATE_HIGH & BAUD_IDLE_RX_PIN_STATE_HIGH & BAUD_AUTO_OFF & BAUD_WAKEUP_OFF & BAUD_16_BIT_RATE & USART_RX_INT_OFF);
OpenTimer1( TIMER_INT_OFF &T1_16BIT_RW &T1_SOURCE_FOSC_4 & T1_PS_1_8 &T1_OSC1EN_OFF &T1_SYNC_EXT_OFF, TIMER_GATE_OFF & TIMER_GATE_INT_OFF);
Gpios_PinDirection(GPIOS_PORTD, 7, GPIOS_INPUT); /*pin C0 como salida para SDI*/
Gpios_PinDirection(GPIOS_PORTD, 6, GPIOS_OUTPUT); /*pin C1 como salida para SDO*/
Gpios_PinDirection(GPIOS_PORTD, 5, GPIOS_OUTPUT); /*pin C2 como salida para SCK*/
Spi_Init(SPI_PORT1, SPI_64DIV); /*Inicializamos SPI2*/
Spi_Init(SPI_PORT2, SPI_64DIV); /*Inicializamos SPI2*/
//Adc_Init(ADC_10BITS);
LED_1 = 1;
LED_2 = 0;
//RLY_1 = 0;
RLY_2 = 0;
ON_RADIO = 1;
ON_MAC = 1;
ON_TEMP = 1;
StartWirelessConnection();
//myDevicesRequiredStatus[0] = 0x55;
EEPROMRead(&myDevicesRequiredStatus, 0, 1);
if(myDevicesRequiredStatus[0] == 0x55)
{
RLY_1 = 1;
EEPROMCHG = 1;
ConsolePutROMString((ROM char *)"RELAY ON ");
}
if(myDevicesRequiredStatus[0] == 0xAA)
{
RLY_1 = 0;
EEPROMCHG = 0;
ConsolePutROMString((ROM char *)"RELAY OFF ");
}
for(j=0;j<10;j++)
{
DelayMs(50);
LED_1 ^= 1;
LED_2 ^= 1;
}
LED_1 = 0;
LED_2 = 0;
//RLY_1 = 0;
RLY_2 = 0;
TickScaler = 4;
EndDevStateMachine =0;
/*
while(!Tx_Success)
{
if(myChannel < 8)
scanresult = MiApp_SearchConnection(10, (0x00000001 << myChannel));
else if(myChannel < 16)
scanresult = MiApp_SearchConnection(10, (0x00000100 << (myChannel-8)));
else if(myChannel < 24)
scanresult = MiApp_SearchConnection(10, (0x00010000 << (myChannel-16)));
else
scanresult = MiApp_SearchConnection(10, (0x01000000 << (myChannel-24)));
if(scanresult == 0)
{
Tx_Trials++;
if(Tx_Trials > 2) break;
}
else Tx_Success = TRUE;
}
if(Tx_Success)
{
ConsolePutROMString((ROM char *)"RADIO OK ");
}
else
{
ConsolePutROMString((ROM char *)"RADIO FAIL ");
}
*/
//.VBGOE = 0;
//ANCON1bits.VBGEN = 1; // Enable Band gap reference voltage
//DelayMs(10);
//VBGResult = Adc_u16Read(15);
//ANCON1bits.VBGEN = 0; // Disable Bandgap
//Adc_Init(ADC_10BITS);
ANCON0 = 0xFF;
ANCON1 = 0x9F;
ANCON1bits.VBGEN = 1; // Enable Band gap reference voltage
ADCON0bits.VCFG = 0; // vreff VDD-VSS
ADCON0bits.CHS = 0x0F; // VBG channel select
ADCON1 = 0xBE;
ADCON0bits.ADON = 1;
//for(j=0;j<16;j++)
//{
//myDevicesOutputStatus[j] = j;
//}
//EEPROMWRITE(myDevicesOutputStatus,0,16);
//for(j=0;j<16;j++)
//{
//myDevicesOutputStatus[j] = 0;
//}
//DelayMs(500);
EEPROMRead(&myDevicesOutputStatus, 0, 16);
ConsolePutROMString((ROM char *)"EEPROM READ: ");
//PrintChar(TemperatureCalibrationValue);
for(j=0;j<1;j++)
{
PrintChar(myDevicesOutputStatus[j]);
}
SwTimer3 = 0;
SwTimer4 = 0;
TRISB&=0xEF; //JL: Configuro el pin B4 como salida si modificar el estado de los demas pines
while(1)
{
/*
WirelessTxRx();
WirelesStatus();
Bypass();
*/
//No se utilizaron
//Menu();
//Timer1Tick();
//WirelessTxRxPANCOORD();
//TaskScheduler();
//JLEstas funciones deben habilitarse para trabajar como repetidora
Timer1Tick();
Repeater();
}
}
int main(void) {
int a = 0;
unsigned char data_mix = 0, data_mix_old = 0;
SDEV_TYPE1 S1 = {0}, *S1_p = &S1;
char comm_buffer[MAXSTRLEN];
int update_rate = 4;
int eresult = 0, records = 0, file_errors = 0;
// Init remote device data
S1.obits.out_byte = 0xff;
// Enable multi-vectored interrupts
INTEnableSystemMultiVectoredInt();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//STEP 1. Configure cache, wait states and peripheral bus clock
// 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(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
srand(ReadCoreTimer()); // Seed the pseudo random generator
// SCLK1 pin 25 - SD pin 5
PORTSetPinsDigitalOut(IOPORT_B, BIT_14); // Clock output
// SCLK2 pin 26 - PIC pin 18
PORTSetPinsDigitalOut(IOPORT_B, BIT_15); // Clock output
PPSInput(2, SDI1, RPB8); //Assign SDI1 to pin 17 - SD pin 7
PORTSetPinsDigitalIn(IOPORT_B, BIT_8); // Input for SDI1
PPSInput(3, SDI2, RPB13); //Assign SDI2 to pin 24
PORTSetPinsDigitalIn(IOPORT_B, BIT_13); // Input for SDI2
PPSOutput(2, RPB11, SDO1); // Set 22 pin as output for SDO1 - SD pin 2
PPSOutput(2, RPB5, SDO2); // Set 14 pin as output for SDO2
PORTSetPinsDigitalOut(IOPORT_B, BIT_2); // CS line pin 6 - SD pin 1
mPORTBSetBits(BIT_2); // deselect SDCARD
PORTSetPinsDigitalOut(IOPORT_B, BIT_3); // select pin enable for SPI slaves bit 2 to 74hc138
mPORTBSetBits(BIT_3); // deselect Slave1 bit2
PORTSetPinsDigitalOut(IOPORT_A, BIT_3); // spare digital output
mPORTASetBits(BIT_3); //
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Diag Led pins
PORTSetPinsDigitalOut(IOPORT_A, BIT_0 | BIT_1); // bi-color LED
PORTSetPinsDigitalOut(IOPORT_B, BIT_0 | BIT_1); // programming inputs /device select outputs address for SPI slaves bits [0..1] 74hc138
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// STEP 3. initialize the port pin states = outputs low
mPORTASetBits(BIT_0 | BIT_1);
mPORTBClearBits(BIT_0 | BIT_1);
RTC_Init(); // Start Timer5 for background processes and 1ms soft timers
Blink_Init(); // Start Timer4 background blink driver
blink_led(RED_LED, LED_ON, FALSE);
init_spi_ports();
ps_select(0); // select the pic18 slave1 on spi port 2, select 0
// send some text to clean the buffers
SpiStringWrite("\r\n \n\r");
eresult = f_mount(&FatFs, "0:", 1);
if (eresult) {
sprintf(comm_buffer, "\r\n Mount error %i ", eresult);
SpiStringWrite(comm_buffer); /* Register work area to the logical drive 1 */
blink_led(GREEN_LED, LED_OFF, FALSE);
blink_led(RED_LED, LED_ON, FALSE);
} else {
Show_MMC_Info();
blink_led(RED_LED, LED_OFF, FALSE);
blink_led(GREEN_LED, LED_ON, TRUE);
}
/* Create destination file on the drive 1 */
eresult = f_open(&File[0], "0:logfile.txt", FA_CREATE_ALWAYS | FA_WRITE);
while (1) { // loop and move data
V.Timer1 = update_rate;
while (V.Timer1);
/* loop back testing */
data_mix_old = data_mix; // save the old data
data_mix = rand(); // make new data
if (S1_p->char_ready || !S1_p->ibits.in_bits.eject) {
S1_p->rec_data = S1_p->rec_tmp;
// led1_green();
} else {
// led1_off();
}
S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
if (S1_p->ibits.in_bits.card_detect) {
S1_p->obits.out_bits.eject_led = OFF;
SD_NOTRDY = STA_NOINIT;
} else {
S1_p->obits.out_bits.eject_led = ~S1_p->obits.out_bits.eject_led;
}
for (S1_p->chan_no = 0; S1_p->chan_no < 4; S1_p->chan_no++) {
S1_p->adc_data[S1_p->chan_no] = SpiADCRead(S1_p->chan_no);
}
a = 0;
if (((records % 100)) == 0 && !eresult) {
if (S1_p->char_ready) {
snprintf(comm_buffer, 64, "\r\n %x , %i, %x , %i , %i , %i , %i ", S1_p->rec_data, records, S1_p->ibits.in_byte, S1_p->adc_data[0], S1_p->adc_data[1], S1_p->adc_data[2], S1_p->adc_data[3]);
} else {
snprintf(comm_buffer, 64, "\r\n %x , %i , %i , %i , %i , %i ", S1_p->ibits.in_byte, records, S1_p->adc_data[0], S1_p->adc_data[1], S1_p->adc_data[2], S1_p->adc_data[3]);
}
S1_p->rec_tmp = SpiStringWrite(comm_buffer);
}
if (SpiSerialReadOk() || !S1_p->ibits.in_bits.eject) {
S1_p->char_ready = TRUE;
if ((S1_p->rec_tmp == 'f') || !S1_p->ibits.in_bits.eject) {
if (S1_p->ibits.in_bits.card_detect) { // no disk
blink_led(0, LED_ON, FALSE);
S1_p->obits.out_bits.eject_led = OFF;
S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
SpiStringWrite("\r\n Insert Disk! y/n ");
while (!SpiSerialReadReady() && S1_p->ibits.in_bits.card_detect) S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
V.Timer1 = update_rate;
while (V.Timer1);
if (!S1_p->ibits.in_bits.card_detect) {
SpiStringWrite("/\r\n Mounting Disk ");
S1_p->obits.out_bits.eject_led = ON;
S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
eresult = f_mount(&FatFs, "0:", 1);
if (eresult) {
sprintf(comm_buffer, "\r\n Mount error %i ", eresult);
SpiStringWrite(comm_buffer); /* Register work area to the logical drive 1 */
blink_led(GREEN_LED, LED_OFF, FALSE);
blink_led(RED_LED, LED_ON, FALSE);
} else {
Show_MMC_Info();
blink_led(RED_LED, LED_OFF, FALSE);
blink_led(GREEN_LED, LED_ON, TRUE);
}
/* Create destination file on the drive 1 */
eresult = f_open(&File[0], "0:logfile.txt", FA_CREATE_ALWAYS | FA_WRITE);
SpiStringWrite("\r\n Mount Complete ");
S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
if (S1_p->ibits.in_bits.card_detect) SD_NOTRDY = STA_NOINIT;
}
} else { // Eject current disk
blink_led(0, LED_ON, FALSE);
S1_p->obits.out_bits.eject_led = OFF;
S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
f_close(&File[0]);
SpiStringWrite("\r\n Eject Disk? y/n ");
while (!SpiSerialReadReady() && !S1_p->ibits.in_bits.card_detect) S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
V.Timer1 = update_rate;
while (V.Timer1);
if (S1_p->ibits.in_bits.card_detect) {
SpiStringWrite("\r\n Ejecting Disk ");
S1_p->obits.out_bits.eject_led = ON;
S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
if (f_mount(0, "0:", 0)) SpiStringWrite("\r\n UMount error "); /* Unregister work area from the logical drive 1 */
SpiStringWrite("\r\n Ejection Complete ");
eresult = 1;
S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
if (S1_p->ibits.in_bits.card_detect) SD_NOTRDY = STA_NOINIT;
}
}
}
} else {
S1_p->char_ready = FALSE;
}
V.Timer1 = update_rate;
while (V.Timer1);
// only GREEN if the data sent and received match or eject button is pressed
if (S1_p->ibits.in_bits.eject && (S1_p->rec_data != data_mix_old)) {
// blink_led(0, LED_ON, TRUE);
} else {
// blink_led(0, LED_ON, FALSE);
}
if (!eresult) {
a = f_puts(comm_buffer, &File[0]);
blink_led(RED_LED, LED_OFF, FALSE);
blink_led(GREEN_LED, LED_ON, TRUE);
records++;
} else {
file_errors++;
if ((file_errors % 100) == 0) {
SpiStringWrite("\r\n not logged ");
blink_led(GREEN_LED, LED_OFF, FALSE);
blink_led(RED_LED, LED_ON, FALSE);
}
}
if (a == (-1)) {
if ((file_errors % 100) == 0) {
sprintf(comm_buffer, "\r\n File Write error %i ", a);
SpiStringWrite(comm_buffer);
blink_led(GREEN_LED, LED_OFF, FALSE);
blink_led(RED_LED, LED_ON, FALSE);
}
}
f_sync(&File[0]);
}
}
/**************************************************************************************************
Initialise the video components
***************************************************************************************************/
void initVideo(void) {
AutoLineWrap = 1;
// test if there is a monitor plugged into the VGA connector
CNPUASET = (1 << 4); // set a pullup on the video output pin
uSec(300); // allow it to settle
//vga = !PORTAbits.RA4; // the pin will be pulled low if the monitor is there
CNPUACLR = (1 << 4);
////////////////////////////
// setup SPI2 which is the video generator. the output of this module is a stream of bits which are the pixels in a horiz scan line
//if(vga)
PPSOutput(3, RPA4, SDO2); // B5 is the video out for VGA [color]]
//else
// PPSOutput(3, RPB2, SDO2); // B2 is the video out for composite
PPSInput(4, SS2, RPB9); // B9 is the framing input [horizontal synch]
#define P_VIDEO_SPI 2 // the SPI peripheral used for video
#define P_SPI_INPUT SPI2BUF // input buffer for the SPI peripheral
#define P_SPI_INTERRUPT _SPI2_TX_IRQ // interrupt used by the SPI peripheral when it needs more data
////////////////////////////
// the horizontal sync uses Timer 3 and Output Compare 3 to generate the pulse and interrupt level 7
PPSOutput(4, RPB14, OC3); // B14 is the horizontal sync output (ie, the output from OC3)
#define P_VID_OC_OPEN OpenOC3 // the function used to open the output compare
#define P_VID_OC_REG OC3R // the output compare register
////////////////////////////
// the vertical sync uses B13
TRISBCLR = (1<<13); // Vert sync output used by VGA
#define P_VERT_SET_HI LATBSET = (1 << 13) // set vert sync hi
#define P_VERT_SET_LO LATBCLR = (1 << 13) // set vert sync lo
// calculate the paramaters for each video mode and setup Timer 3 to generate the horiz synch and interrupt on its leading edge
//if(vga) {
// set up for VGA output
HRes = VGA_HRES; // HRes is the number of horiz pixels to use
HBuf = VGA_HBUFF * 32; // HBuf is the horiz buffer size (in pixels)
ConfigBuffers(Option[O_LINES24]); // setup the buffer pointers and VBuf, VRes
VC[0] = VGA_VSYNC_N; // setup the table used to count lines
VC[1] = VGA_POSTEQ_N;
P_VID_OC_OPEN(OC_ON | OC_TIMER3_SRC | OC_CONTINUE_PULSE, 0, VGA_HSYNC_T); // enable the output compare which is used to time the width of the horiz sync pulse
OpenTimer3( T3_ON | T3_PS_1_1 | T3_SOURCE_INT, VGA_LINE_T-1); // enable timer 3 and set to the horizontal scanning frequency
//}
/*else if(Option[O_PAL]) {
// this is for the PAL composite output and is the same as VGA with timing differences
VBuf = VRes = PAL_VRES;
HRes = PAL_HRES;
HBuf = PAL_HBUFF * 32; // HBuf is the horiz buffer size (in pixels)
ConfigBuffers(0);
SvSyncT = PAL_LINE_T - C_HSYNC_T;
VC[0] = C_VSYNC_N;
VC[1] = PAL_POSTEQ_N;
VC[2] = PAL_VRES;
VC[3] = PAL_PREEQ_N;
P_VID_OC_OPEN(OC_ON | OC_TIMER3_SRC | OC_CONTINUE_PULSE, 0, C_HSYNC_T); // enable the output compare which is used to time the width of the horiz sync pulse
OpenTimer3(T3_ON | T3_PS_1_1 | T3_SOURCE_INT, PAL_LINE_T-1); // enable timer 3 and set to the horizontal scanning frequency
}
*/
/*
else {
// this is for the NTSC composite output and is similar again
VBuf = VRes = NTSC_VRES;
HRes = NTSC_HRES;
HBuf = NTSC_HBUFF * 32; // HBuf is the horiz buffer size (in pixels)
ConfigBuffers(0);
SvSyncT = NTSC_LINE_T - C_HSYNC_T;
VC[0] = C_VSYNC_N;
VC[1] = NTSC_POSTEQ_N;
VC[2] = NTSC_VRES;
VC[3] = NTSC_PREEQ_N;
P_VID_OC_OPEN(OC_ON | OC_TIMER3_SRC | OC_CONTINUE_PULSE, 0, C_HSYNC_T); // enable the output compare which is used to time the width of the horiz sync pulse
OpenTimer3(T3_ON | T3_PS_1_1 | T3_SOURCE_INT, NTSC_LINE_T-1); // enable timer 3 and set to the horizontal scanning frequency
}
*/
// set priority level 7 for the timer 3 interrupt (horiz synch) and enable it
mT3SetIntPriority(7);
mT3IntEnable(1);
// initialise the state machine and set the count so that the first interrupt will increment the state
VState = SV_PREEQ;
VCount = 1;
// setup the SPI channel then DMA channel which will copy the memory bitmap buffer to the SPI channel
//if(vga) {
// open the SPI in framing mode. Note that SPI_OPEN_DISSDI will disable the input (which we do not need)
SpiChnOpen(P_VIDEO_SPI, SPICON_ON | SPICON_MSTEN | SPICON_MODE32 | SPICON_FRMEN | SPICON_FRMSYNC | SPICON_FRMPOL | SPI_OPEN_DISSDI, VGA_PIX_T);
SPI2CON2 = (1<<9) | (1<<8); // instruct the SPI module to ignore any errors that might occur
DmaChnOpen(1, 1, DMA_OPEN_DEFAULT); // setup DMA 1 to send data to SPI channel 2
DmaChnSetEventControl(1, DMA_EV_START_IRQ_EN | DMA_EV_START_IRQ(P_SPI_INTERRUPT));
DmaChnSetTxfer(1, (void*)VideoBuf, (void *)&P_SPI_INPUT, HBuf/8, 4, 4);
//}
/*
else {
SpiChnOpen(P_VIDEO_SPI, SPICON_ON | SPICON_MSTEN | SPICON_MODE32 | SPICON_FRMEN | SPICON_FRMSYNC | SPICON_FRMPOL | SPI_OPEN_DISSDI, C_PIX_T);
SPI2CON2 = (1<<9) | (1<<8); // instruct the SPI module to ignore any errors that might occur
DmaChnOpen(1, 1, DMA_OPEN_DEFAULT); // setup DMA 1 is the blank padding at the start of a scan line
DmaChnSetEventControl(1, DMA_EV_START_IRQ_EN | DMA_EV_START_IRQ(P_SPI_INTERRUPT));
DmaChnSetTxfer(1, (void*)zero, (void *)&P_SPI_INPUT, C_BLANKPAD, 4, 4);
DmaChnOpen( 0, 0, DMA_OPEN_DEFAULT); // setup DMA 0 to pump the data from the graphics buffer to the SPI peripheral
DmaChnSetEventControl(0, DMA_EV_START_IRQ_EN | DMA_EV_START_IRQ(P_SPI_INTERRUPT));
DmaChnSetTxfer(0, (void*)VideoBuf, (void *)&P_SPI_INPUT, HBuf/8 + 6, 4, 4);
DmaChnSetControlFlags(0, DMA_CTL_CHAIN_EN | DMA_CTL_CHAIN_DIR); // chain DMA 0 so that it will start on completion of the DMA 1 transfer
}
*/
}
void ImuNodeInit(uint32_t f_osc)
{
// And configure the Peripheral Pin Select pins:
PPSUnLock;
PPSUnLock;
#ifdef __dsPIC33FJ128MC802__
// To enable ECAN1 pins: TX on 7, RX on 4
PPSOutput(OUT_FN_PPS_C1TX, OUT_PIN_PPS_RP7);
PPSInput(IN_FN_PPS_C1RX, IN_PIN_PPS_RP4);
// To enable UART1 pins: TX on 9, RX on 8
PPSOutput(OUT_FN_PPS_U1TX, OUT_PIN_PPS_RP9);
PPSInput(IN_FN_PPS_U1RX, IN_PIN_PPS_RP8);
#elif __dsPIC33EP256MC502__
// To enable ECAN1 pins: TX on 39, RX on 36
PPSOutput(OUT_FN_PPS_C1TX, OUT_PIN_PPS_RP39);
PPSInput(IN_FN_PPS_C1RX, IN_PIN_PPS_RP36);
// To enable UART1 pins: TX on 41, RX on 40
PPSOutput(OUT_FN_PPS_U1TX, OUT_PIN_PPS_RP41);
PPSInput(IN_FN_PPS_U1RX, IN_PIN_PPS_RP40);
#endif
PPSLock;
// Also disable analog functionality on B8 so we can use it for UART1 RX.
// This only applies to the dsPIC33E family.
#ifdef __dsPIC33EP256MC502__
ANSELBbits.ANSB8 = 0;
#endif
// Initialize status LEDs for use.
// A3 (output): Red LED, off by default, and is solid when the system hit a fatal error.
_TRISA3 = 0;
_LATA3 = 0;
// A4 (output): Amber LED, blinks at 1Hz when disconnected from the IMU, 2Hz otherwise.
_TRISA4 = 0;
_LATA4 = 0;
_TRISB7 = 0; // Set ECAN1_TX pin to an output
_TRISB4 = 1; // Set ECAN1_RX pin to an input;
// Set up UART1 for 115200 baud. There's no round() on the dsPICs, so we implement our own.
double brg = (double)f_osc / 2.0 / 16.0 / 115200.0 - 1.0;
if (brg - floor(brg) >= 0.5) {
brg = ceil(brg);
} else {
brg = floor(brg);
}
Uart1Init((uint16_t)brg);
// Initialize ECAN1 for input and output using DMA buffers 0 & 2
Ecan1Init(f_osc, NODE_CAN_BAUD);
// Set the node ID
nodeId = CAN_NODE_IMU_SENSOR;
// Set up all of our tasks.
// Blink at 1Hz
if (!AddMessageRepeating(&taskSchedule, TASK_BLINK, RATE_TRANSMIT_BLINK_DEFAULT)) {
FATAL_ERROR();
}
// Transmit node status at 2Hz
if (!AddMessageRepeating(&taskSchedule, TASK_TRANSMIT_STATUS, RATE_TRANSMIT_NODE_STATUS)) {
FATAL_ERROR();
}
// Transmit IMU data at 25Hz
if (!AddMessageRepeating(&taskSchedule, TASK_TRANSMIT_IMU, RATE_TRANSMIT_IMU_DATA)) {
FATAL_ERROR();
}
}
