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; }
void InitApp(void) { /* Setup analog functionality and port direction */ (PPSUnLock); TRISFbits.TRISF3 = 0; PORTFbits.RF3 = 1; PPSOutput(PPS_RP9, PPS_SCK1OUT); PPSOutput(PPS_RP8, PPS_SDO1); AD1PCFG = 0xFFFF; // Default all pins to digital AD1PCFGLbits.PCFG11 = 0; //Disable digital input on AN11 /* Initialize peripherals */ InitMatrixDisplay(); spi1Init(PRI_PRESCAL_1_1); initHD44780LCD(); initPWM(); initADC(); }
/** * 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; }
static inline void InitializePeripherals() { // Initialize power enable pin. ODC(EN_N_PIN) = 1; // Open-drain. LAT(EN_N_PIN) = 1; // Initially, power is off. TRIS(EN_N_PIN) = 0; // Set pin as output. // Initialize reset pin. LAT(RST_N_PIN) = 0; // Initially, hold in reset. TRIS(RST_N_PIN) = 0; // Set pin as output. // Initialize RS pin. TRIS(RS_PIN) = 0; // Set pin as output. // Initialize SS pin. LAT(SS_N_PIN) = 1; // Initially, de-asserted. TRIS(SS_N_PIN) = 0; // Set pin as output. // Initialize SPI. SPI2CON1 = 0x013B; // 1:2 divider = 35MHz. SPI2STAT = 0x8000; PPSOutput(OUT_FN_PPS_SCK2, OUT_PIN_PPS_RP43); PPSOutput(OUT_FN_PPS_SDO2, OUT_PIN_PPS_RP42); // Initialize TX DMA (channel 2). DMA2REQ = 0x0021; DMA2PAD = (uint16_t) &SPI2BUF; DMA2STAH = 0; // Initialize RX DMA (channel 3). // This is required to prevent the SPI RX buffer from overflowing as well as // to detect when sending is complete. DMA3REQ = 0x0021; DMA3PAD = (uint16_t) &SPI2BUF; DMA3STAL = (uint16_t) &spi_rx_discard; DMA3STAH = 0; _DMA3IP = configKERNEL_INTERRUPT_PRIORITY; // Initialize LED PWM. ODC(LED_N_PIN) = 1; // Configure pin for open-drain. PTPER = 0xFFFF; // PWM Period. PWMCON1 = 0x0080; // Disable dead-time. FCLCON1 = 0x0003; // Disable faults. FCLCON2 = 0x0003; // Disable faults. FCLCON3 = 0x0003; // Disable faults. IOCON1 = 0x5400; // Enable the PWM1L pin, inverted polarity. IOCON2 = 0x0000; // Disable PWM2 I/O control. IOCON3 = 0x0000; // Disable PWM3 I/O control. PTCON = 0x8000; // Enable the PWM module. }
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'); }
void initPWM() { uint32_t clock = 48e6; //RPOR3bits.RP7R = 0b10010; PPSOutput(PPS_RP21, PPS_OC1); TRISGbits.TRISG6 = 0; T3CONbits.TCKPS = 0b01; // 1:8 Prescale T3CONbits.TON = 1; uint32_t clockPWM = (clock/2)/8; /* Reset PWM */ OC1CON1 = 0x0000; OC1CON2 = 0x0000; /* set PWM for servo mid position (1.5ms high, 20ms period) */ OC1R = clock/(1000 / 1.5); /* set the duty cycle */ OC1RS = clockPWM/(1000 / 20); /* set the period */ /* configure PWM */ OC1CON2 = 0x001f; /* 0x001F = Sync with This OC module */ OC1CON1 = 0x0400 /* 0x0400 => src=Timer3 */; /* enable the PWM */ OC1CON1 |= 0x0006; /* Mode 6, Edge-aligned PWM Mode */ }
void setup() { ANSELBbits.ANSB0 = 0; // sets pin RB0 as digital TRISBbits.TRISB0 = 0; // configure pin RB as an output PPSOutput(2, RPB5, SDO1); // map SDO1 to RA1 //#define config1 SPI_MODE16_ON | SPI_CKE_ON | MASTER_ENABLE_ON // /* FRAME_ENABLE_OFF // * ENABLE_SDO_PIN -> SPI Output pin enabled // * SPI_MODE16_ON -> 16-bit SPI mode // * SPI_SMP_OFF -> Sample at middle of data output time // * SPI_CKE_ON -> Output data changes on transition from active clock // * to idle clock state // * SLAVE_ENABLE_OFF -> Manual SW control of SS // * MASTER_ENABLE_ON -> Master mode enable // */ //#define config2 SPI_ENABLE // /* SPI_ENABLE -> Enable SPI module // */ //// OpenSPI2(config1, config2); // // see pg 193 in plib reference #define spi_channel 1 // Use channel 2 since channel 1 is used by TFT display #define spi_brg 0 // Divider = 2 * (spi_brg + 1) // Divide by 2 to get SPI clock of FPBDIV/2 -> max SPI clock // SpiChnSetBrg(spi_channel, spi_brg); // see pg 203 in plib reference ////// ////// #define spi_divider 6 /* Unlike OpenSPIx(), config for SpiChnOpen describes the non-default * settings. eg for OpenSPI2(), use SPI_SMP_OFF (default) to sample * at the middle of the data output, use SPI_SMP_ON to sample at end. For * SpiChnOpen, using SPICON_SMP as a parameter will use the non-default * SPI_SMP_ON setting. */ #define config SPI_OPEN_MSTEN | SPI_OPEN_MODE8 | SPI_OPEN_DISSDI | SPI_OPEN_CKE_REV /* SPI_OPEN_MSTEN -> Master mode enable * SPI_OPEN_MODE16 -> 16-bit SPI mode * SPI_OPEN_DISSDI -> Disable SDI pin since PIC32 to DAC is a * master-to-slave only communication * SPI_OPEN_CKE_REV -> Output data changes on transition from active * clock to idle clock state */ SpiChnOpen(spi_channel, config, spi_divider); }
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; }
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
// 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 ) { // Initialize the processor and peripherals. if ( InitializeSystem() != TRUE ) { UART2PrintString( "\r\n\r\nCould not initialize USB Custom Demo App - system. Halting.\r\n\r\n" ); while (1); } if ( USBHostInit(0) == TRUE ) { UART2PrintString( "\r\n\r\n***** USB Custom Demo App Initialized *****\r\n\r\n" ); } else { UART2PrintString( "\r\n\r\nCould not initialize USB Custom Demo App - USB. Halting.\r\n\r\n" ); while (1); } btClientData.State = BT_STATE_IDLE; btClientData.Initialized = FALSE; mPORTAOutputConfig(0x3); mPORTAWrite(0x0); mPORTBOutputConfig(0x10); // OC 1 PPSOutput(PPS_RP4, PPS_OC1); //Enable Interrupt SetPriorityIntOC1(4); EnableIntOC1; OpenTimer2(T2_ON | T2_PS_1_8 ,0xffff); // OpenOC1(OC_IDLE_CON | OC_TIMER2_SRC | OC_PWM_EDGE_ALIGN ,OC_SYNC_TRIG_IN_TMR2,0,0); SetDCOC1PWM(0xc00,0); // Main Processing Loop while (1) { BTClientTasks(); // Maintain USB Host State USBHostTasks(); DelayMs(1); } return 0; } // main
int main(void) { // === config the uart, DMA, SPI =========== PT_setup(); // == SPI == //enable SPI at 10 MHz clock to meet digital potentiometer specifications SpiChnOpen(spiChn, SPI_OPEN_ON | SPI_OPEN_MODE16 | SPI_OPEN_MSTEN | SPI_OPEN_CKE_REV , spiClkDiv); // === setup system wide interrupts ==================== INTEnableSystemMultiVectoredInt(); // === set up i/o port pin =============================== //Port B bits, 3,7,8, and 9 are used to select digital output //Port B bit 4 is used as chip select for treble digital potentiometer //Port B bit 13 is used as a select signal for output effect selection multiplexer //Additional functionality would use the TFT to display which output was being //selected mPORTBSetPinsDigitalOut(BIT_4 | BIT_3|BIT_7 | BIT_8 | BIT_9 |BIT_13); //Set port as output //Port A Bits 0,2,and 3 are used to configure digital potentiometers (chip selects). Port A bit 4 is used //for multiplexing whether to have input from Digital effector chip, distortion, //or pure tonestack sound mPORTASetPinsDigitalOut(BIT_0 | BIT_2 | BIT_3 | BIT_4); // === now the threads =================================== // init the threads PT_INIT(&pt_cmd); PT_INIT(&pt_time); //==Digipot spi stuff // SCK2 is pin 26 // SDO1 (MOSI) is in PPS output group 1, could be connected to RB5 which is pin 14 PPSOutput(2, RPB5, SDO1); // control CS for DAC //mPORTBSetPinsDigitalOut(BIT_4); //CS mPORTBSetBits(BIT_4 | BIT_6); //=== mPORTASetBits(BIT_0 | BIT_2 | BIT_3 | BIT_4); //CS pins active high mPORTAClearBits(BIT_4); mPORTBClearBits(BIT_13); mPORTBSetBits(BIT_13); // schedule the threads while(1) { //cmd used as command center for all effects PT_SCHEDULE(protothread_cmd(&pt_cmd)); } } // main
/** * 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; }
void ChainInit() { // Initialize UART 2 at 115.2k. U2BRG = 151; U2MODE = 0x8008; U2STA = 0x0400; // Setup the TX pin. PPSOutput(OUT_FN_PPS_U2TX, OUT_PIN_PPS_RP20); // Configure DMA channel 0 to work with UART2 TX. DMA0PAD = (uint16_t) &U2TXREG; DMA0STAH = 0; }
void SetupMenu() // Set up menu { uint8 i; while(1) { i = GetMenuItem("TERMINAL SETUP","WiFi Setup","ESPUSB Fudge","Scan WiFi","Test Wifi","Exit"); if(i==1) SetupWIFI(); if(i==2) // Open USB in CDC Mode passthough to ESP-01 { SerialPurge(WIFI_UART); CLS(); LCDWriteStrAt(0,4, " USB <-> ESP01 "); LCDWriteStrAt(0,6, " PROGRAMMIING "); LCDWriteStrAt(0,10," PRESS KEY TO "); LCDWriteStrAt(0,12," CONTINUE "); PORTSetPinsDigitalIn(IOPORT_C, BIT_2 ); PPSUnLock; // Unlock PPS (Peripheral Pin Select) to allow PIN Mapping PPSOutput(4,RPC2,NULL); PPSLock; // lock PPS ESP_PGM(0); WIFI_PWR(1); i = WaitEvent(9999); CLS(); WIFI_PWR(0); ESP_PGM(1); DelayMs(500); WIFI_PWR(1); LCDWriteStrAt(0,4, " USB <-> ESP01 "); LCDWriteStrAt(0,6, " PASSTHROUGH "); LCDWriteStrAt(0,10," POWER OFF TO "); LCDWriteStrAt(0,12," RESUME "); while(1); } if(i==4) { if(CheckWIFI()) LCDInform("SUCCESS","Connection OK"); } if(i==3) { LCDInform("WARNING","Not Implemented"); } if(i==0 ||i==5) 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
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); } }
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(); } }
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(); } } } }
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 }
int main(void) { #if defined( DUMP_DIAGNOSTICS_VIA_UART ) char ButtonMeasString[133]; # if defined( UART_DUMP_RAW_COUNTS ) || \ defined( UART_DUMP_ALL_COUNTS ) UINT16 iHF_Read; # endif//defined( UART_DUMP_RAW_COUNTS )... #endif//defined( DUMP_DIAGNOSTICS_VIA_UART ) UINT16 CurrentButtonStatus, LastButtonStatus, CurrentButtonAsserts = 0, CurrentButtonMeasurements[MAX_ADC_CHANNELS], CurrentAveragedMeasurements[MAX_ADC_CHANNELS]; UINT16 CurrentWeights[MAX_ADC_CHANNELS]; CFGCONbits.JTAGEN = 0; // Disable JTAG // Initalize global interrupt enable INTEnableSystemMultiVectoredInt(); // Configure the device for maximum performance // 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. SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE); #if defined( DUMP_DIAGNOSTICS_VIA_UART ) // Setup UART2 for transmission of button data. // Taken from C:\Program Files\Microchip\mplabc32\v1.12\examples\plib_examples\uart\uart_basic 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(), 115200 ); UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_TX )); // RPS setup to bring U1TX out on pin 33 (RB4) to Switch 2 on board PPSOutput(4,RPC4,U2TX); #endif//defined( DUMP_DIAGNOSTICS_VIA_UART ) // Setup data structures for using Direct Keys mTouchCapApp_MatrixKeys_Create(); /* This is mandatory function call to initilize physical layer. Call this function before any application layer code. */ mTouchCapAPI_Init(); // Initial startup demo of board LEDs. PORTB = PORTB_ROW_ALL | PORTB_COL_ALL; //Turn on all LEDs PORTC = PORTC_ROW_ALL | PORTC_COL_ALL; DelayMs(1000); mTouchCapLED_PowerUpSequence(); // turn on each LED in sliding motion PORTB = PORTB_ROW_ALL | PORTB_COL_ALL; //Turn on all LEDs PORTC = PORTC_ROW_ALL | PORTC_COL_ALL; DelayMs(1000); PORTB = PORTB_ROW_NIL | PORTB_COL_NIL; //Turn off all LEDs PORTC = PORTC_ROW_NIL | PORTC_COL_NIL; // Start button measurements Set_ScanTimer_IE_Bit_State(ENABLE); //Enable interrupt Set_ScanTimer_ON_Bit_State(ENABLE); //Run timer // Setup for detection/interpretation LastButtonStatus = 0; while(1) { if(EmTouchDataReady == 1) //This flag is set by Timer ISR when all channels have been read { // Calculate new button values and return the measurement updates mTouchCapPhy_UpdateData(CurrentButtonMeasurements, CurrentAveragedMeasurements, CurrentWeights, TRUE, FILTER_METHOD_USECHANNEL); // Update button and LED status and return button status for use with mTouch GUI on PC CurrentButtonStatus = mTouchCapApp_MatrixKeys_Demo(); // Check for button asserts: If buttons were pressed before, but none pressed now if ( LastButtonStatus > 0 && CurrentButtonStatus == 0 ) { CurrentButtonAsserts = LastButtonStatus; //Buttons have fired. } else { // Commented out to provide memory of last button asserted. //ButtonAsserts = 0; } /* Determining Channel Load Order: Button Layout: Column: Col 1 Col 2 Col 3 Col 4 AN0 AN1 AN4 AN5 Row 1: AN8 Btn 0 Btn 1 Btn 2 Btn 3 Row 2: AN7 Btn 4 Btn 5 Btn 6 Btn 7 Row 3: AN6 Btn 8 Btn 9 Btn10 Btn11 Resulting load Order (AN8,AN0), (AN8,AN1), (AN8,AN4), (AN8,AN5), (AN7,AN0), (AN7,AN1), (AN7,AN4), (AN7,AN5), (AN6,AN0), (AN6,AN1), (AN6,AN4), (AN6,AN5), Removing channels already loaded: (AN8,AN0), (---,AN1), (---,AN4), (---,AN5), (AN7,---), (---,---), (---,---), (---,---), (AN6,---), (---,---), (---,---), (---,---), So the channels are loaded into memory in this order: Channel Load: #0, #1, #2, #3, #4, #5, #6 ADC Channel: AN8, AN0, AN1, AN4, AN5, AN13, AN12 Button Func: Row1, Col1, Col2, Col3, Col4, Row2, Row3 Sorting to output rows in order followed by columns: Channel Load: #0, #5, #6, #1, #2, #3, #4, Button Func: Row1, Row2, Row3, Col1, Col2, Col3, Col4, This order is used below to output measurements to the mTouch GUI or to a hyperterminal for later analysis. */ # if defined( UART_DUMP_RAW_COUNTS ) for ( iHF_Read = 0; iHF_Read < NUM_HF_READS; iHF_Read++ ) # elif defined( UART_DUMP_ALL_COUNTS ) for ( iHF_Read = 0; iHF_Read < 3*NUM_HF_READS; iHF_Read++ ) # endif # if defined( UART_DUMP_RAW_COUNTS ) || defined( UART_DUMP_ALL_COUNTS ) { sprintf(ButtonMeasString, "%05d,%05d,%05d," "%05d,%05d,%05d,%05d," "%05d,%05d,%05d,%05d," "%05d,%05d,%05d,%05d," "%05d\r\n", CurrentButtonStatus,CurrentButtonAsserts, CurRawData[iHF_Read][0],CurRawData[iHF_Read][5],CurRawData[iHF_Read][6], 0, CurRawData[iHF_Read][1],CurRawData[iHF_Read][2],CurRawData[iHF_Read][3],CurRawData[iHF_Read][4], 0,0,0,0, 0,0,0,0, iHF_Read+1); SendDataBuffer(ButtonMeasString, strlen(ButtonMeasString) ); } # endif #if defined( DUMP_DIAGNOSTICS_VIA_UART ) // Format report string sprintf(ButtonMeasString, "%05d,%05d,%05d," "%05d,%05d,%05d,%05d," "%05d,%05d,%05d,%05d\r\n", CurrentButtonStatus, CurrentButtonAsserts, 0, // Zero for slider value CurrentButtonMeasurements[0], //Row 1: AN14: Load #0 CurrentButtonMeasurements[5], //Row 2: AN13: Load #5 CurrentButtonMeasurements[6], //Row 3: AN12: Load #6 0, //Placeholder for unused row CurrentButtonMeasurements[1], //Col 1: AN8: Load #1 CurrentButtonMeasurements[2], //Col 2: AN9: Load #2 CurrentButtonMeasurements[3], //Col 3: AN10: Load #3 CurrentButtonMeasurements[4]);//Col 4: AN11: Load #4 // Send report string back to mTouch GUI via UART #2 SendDataBuffer(ButtonMeasString, strlen(ButtonMeasString) ); # endif//defined( DUMP_DIAGNOSTICS_VIA_UART ) LastButtonStatus = CurrentButtonStatus; //Remember button status EmTouchDataReady = 0; //clear flag Set_ScanTimer_IE_Bit_State(ENABLE); //Enable interrupt Set_ScanTimer_ON_Bit_State(ENABLE); //Run timer } // end if(EmTouchDataReady) } //end while (1) } // end main()
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(); } }
/************************************************************************************************** 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 } */ }
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]); } }
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(); } }