void _send_nibble(unsigned char data) { LCD_DATA_W &= ~DATA_MASK; // clear old data bits LCD_DATA_W |= DATA_MASK & data; // put in new data bits // clock Delay100TCYx(4); LCD_EN = 1; Delay100TCYx(4); LCD_EN = 0; Delay100TCYx(4); }
void main(void) { unsigned char data = 0; signed char err0 = 0, err1 = 0, err2 = 0; Delay100TCYx(10); //let the device startup //initialize uart usart_init(); spi_init(); printf("Var is %i\r\n", data); printf("Starting\r\n"); printf("SSPCON1 is x%x\r\n", SSPCON1); printf("SSPADD is x%x\r\n", SSPADD); printf("SSPSTAT is x%x\r\n", SSPSTAT); PORTCbits.RC2 = 1; // pin high while(1){ PORTCbits.RC2 = 0; // CS low Delay1TCY(); // delay at least 5 ns WriteSPI(0x80); // b'10000000, read single byte 000000 //WriteSPI(0xB2); // b'10101100, read single byte data = ReadSPI(); PORTCbits.RC2 = 1; // CS high Delay1TCY(); // delay at least 5 ns //data = data>>1; printf("Data is 0x%02X \r\n", data); } }
void main() { LEDTris = 0;//Set LED Pin data direction to OUTPUT LEDPin = 1;//Set LED Pin OpenUSART( USART_TX_INT_OFF & USART_RX_INT_OFF & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_HIGH, 77); // 38400 bps, set your virtual com port to that speed! cls(); hideCursor(); while(1) { int i, carb0,carb1,carb2,carb3; LEDPin = ~LEDPin;//Toggle LED Pin carb0 = ADC_call(0); carb1 = ADC_call(1); carb2 = ADC_call(2); carb3 = ADC_call(3); i = 1; while(i--) Delay100TCYx(5); } }
/*call function release*/ void release(void) { /* this function halts execution *until switchs are released */ unsigned char count = 0; while(1) { Delay100TCYx(100); if(SWITCH_0==1&&SWITCH_1==1) count++; else count = 0; if(count >= 5) break; }//end while }//end release
void main(void) { //timer vars int result; float final_result; Delay100TCYx(10); //let the device startup usart_init(); i2c_init(); printf("Starting\r\n"); // let sonar initialize, delay 250 ms Delay1KTCYx(625); TRISBbits.TRISB3 = 1; // data pin input while(1) { while(PORTBbits.RB3 == 0); // configure timer0 OpenTimer0(TIMER_INT_OFF & T0_16BIT & T0_SOURCE_INT & T0_PS_1_1); WriteTimer0( 0 ); // restart timer while(PORTBbits.RB3 == 1); //Delay1TCY(); result = ReadTimer0(); // read timer printf("Timer is %u \r\n", result); final_result = (float)result / (float)(2.5*147); printf("X / (4*147) = %i \r\n", (int)final_result); } }
void lcd_init(){ PIN_LCD_E = 0; PIN_LCD_RS = 0; PIN_LCD_D4 = 0; PIN_LCD_D5 = 0; PIN_LCD_D6 = 0; PIN_LCD_D7 = 0; LCD_DELAY_LONG(); lcd_send_nibble(3); Delay10KTCYx(6); //5ms lcd_send_nibble(3); Delay100TCYx(25); //200us lcd_send_nibble(3); Delay100TCYx(25); //200us lcd_send_nibble(2); Delay10KTCYx(6); //5ms lcd_send_nibble(2); lcd_send_nibble(8); //4bits 2lines Delay10KTCYx(6); //5ms lcd_send_nibble(0); lcd_send_nibble(8); //no shift, hide cursor Delay10KTCYx(6); //5ms lcd_send_nibble(0); lcd_send_nibble(1); //clear Delay10KTCYx(6); //5ms lcd_send_nibble(0); lcd_send_nibble(6); //left to right Delay10KTCYx(6); //5ms lcd_send_nibble(0); lcd_send_nibble(0xC); //turn on Delay10KTCYx(6); //5ms LCD_DELAY_LONG(); }
/******************************* * DisplayLCD(char * tempPtr, int init): * This subroutine is called with a string to be displayed on the LCD * It sends the bytes of the string to the LCD. The first * byte sets the cursor position. The remaining bytes are displayed, beginning * at that position. * This subroutine expects a normal one-byte cursor-positioning code, 0xhh, or * an occasionally used two-byte cursor-positioning code of the form 0x00hh. The * init variable defines if the LCD is being initialized (init = 1) or if just * displaying a message on the LCD (init = 0) *******************************/ void DisplayLCD(char * tempPtr, int init) { char currentChar; if (init == 1) { Delay1KTCYx(250); // Wait 0.1 s to bypass LCD startup PORTEbits.RE0 = 0; // Drive RS pin low for cursor-positioning code while (*tempPtr != 0) // if the byte is not zero { currentChar = *tempPtr; PORTEbits.RE1 = 1; // Drive E pin high PORTD = currentChar; // Send upper nibble PORTEbits.RE1 = 0; // Drive E pin low so LCD will accept nibble Delay100TCYx(250); // Wait 10 ms currentChar <<= 4; // Shift lower nibble to upper nibble PORTEbits.RE1 = 1; // Drive E pin high again PORTD = currentChar; // Write lower nibble PORTEbits.RE1 = 0; // Drive E pin low so LCD will process byte Delay100TCYx(250); // Wait 10 ms tempPtr++; // Increment pointerto next character } } else { PORTEbits.RE0 = 0; // Drive RS pin low for cursor-positioning code while (*tempPtr) // if the byte is not zero { currentChar = *tempPtr; PORTEbits.RE1 = 1; // Drive E pin high PORTD = currentChar; // Send upper nibble PORTEbits.RE1 = 0; // Drive E pin low so LCD will accept nibble currentChar <<= 4; // Shift lower nibble to upper nibble PORTEbits.RE1 = 1; // Drive E pin high again PORTD = currentChar; // Write lower nibble PORTEbits.RE1 = 0; // Drive E pin low so LCD will process byte Delay10TCYx(10); // Wait 40 usec PORTEbits.RE0 = 1; // Drive RS pin high for displayable characters tempPtr++; // Increment pointerto next character } } }
/****************************************************************************** int Delay() This function is called to create a 1ms delay multiplied by the integer given to it to make a specific delay time ******************************************************************************/ void Delay() { int delay = 2; int index = 0; for( index = 0; index < delay; index++ ) { Delay100TCYx(25); // each delay cost .001 of a second (1ms) } }
void DelayRXBitUART (void) // p/ detalhes do delay veja no cabeçalho deste arquivo { Delay1KTCYx (1); Delay100TCYx (2); Delay10TCYx (2); nop() ; nop() ; nop() ; nop() ; nop() ; nop() ; }//
void sendString(rom char* data, int length) ///Works { int i; unsigned char temp; Delay10KTCYx(100); while(BusyUSART()); for(i = 0; i < length; i++) { temp = data[i]; putcUSART(temp); Delay100TCYx(100); } }
void sawtooth (unsigned char m) { PORTD=0x00; while (SWITCH_1==1) //if RA5 not pressed { PORTD=PORTD+4;//output sawtooth Delay100TCYx(m);//f=(double) 1/ (1/15600 + n*0.000709+0.00007); } }
//---------------------------------------------------------------------------------- char sht_measure(unsigned char mode) //---------------------------------------------------------------------------------- // makes a measurement (humidity/temperature) with checksum { unsigned error=0; unsigned int i; unsigned char LSB; unsigned char MSB; unsigned char tmp = 0; unsigned char bits = 8; sht_crc_init(); sht_transstart(); //transmission start switch(mode){ //send command to sensor case TEMP : error+=sht_write_byte(MEASURE_TEMP); sht_crc_shuffle_byte(MEASURE_TEMP);break; case HUMI : error+=sht_write_byte(MEASURE_HUMI); sht_crc_shuffle_byte(MEASURE_HUMI);break; default : break; } for (i=0;i<40000;i++) { if(DATA_IN==0) { break; //wait until sensor has finished the measurement } Delay100TCYx(4); //50 us } if(DATA_IN) { error+=1; // or timeout (~2 sec.) is reached } MSB = sht_read_byte(ACK); //read the first byte (MSB) sht_crc_shuffle_byte(MSB); LSB = sht_read_byte(ACK); //read the second byte (LSB) sht_crc_shuffle_byte(LSB); CurrentValue = MSB * 256 + LSB; CheckSum = sht_read_byte(noACK); //read checksum while( bits--) { tmp >>=1; if( sht_crc & 0b10000000) tmp |= 0b10000000; sht_crc <<=1; } if (tmp != CheckSum) { SHTdevice_table[CurrentSensorIndex].crc++; return 1; } return error; }
void main(void) { unsigned char outputData[2]; unsigned int result = 0; unsigned char data = 0; Delay100TCYx(10); //let the device startup usart_init(); i2c_init(); printf("Starting\r\n"); /* ******************************* Compass code and ADSL Code ********************** */ //Tests compass by getting slave address //it should be 0x21 Delay10TCYx(0); printf("Slave Address: 0x%02X \r\n", HMC6352_getSlaveAddress()); HMC6352_setOpMode(HMC6352_CONTINUOUS , 1, 20); printf("Op Mode: 0x%02X \r\n", HMC6352_getOpMode()); printf("Output Mode: 0x%02X \r\n", HMC6352_getOutputMode()); while(1) { StartI2C(); WriteI2C((HMC6352_I2C_ADDRESS << 1) | 1); outputData[0] = ReadI2C(); NotAckI2C(); outputData[1] = ReadI2C(); NotAckI2C(); StopI2C(); result = outputData[0]; result = result << 8; result = result | outputData[1]; /* if(data2 <275 || data2 > 3599) printf("North \r\n"); */ printf("Heading: %i \r\n", result-255); } }
/* * move the motor to the given location */ void move(int location) { int posn = 0; ADCON0bits.GO = 1; //ConvertADC(); while (0 == ADCON0bits.GO); // spin while busy posn = ((((unsigned int)ADRESH)<<8)|(ADRESL) - location) / ADC_PRECISION; while (0 != posn) { // move forward or back depending on the location if (posn < 0) { adjustMotor(1); } else { adjustMotor(0); } Delay100TCYx(1); ADCON0bits.GO = 1; //ConvertADC(); // determine new location and if any change is needed while (0 == ADCON0bits.GO); // spin while busy posn = ((((unsigned int)ADRESH)<<8)|(ADRESL) - location) / ADC_PRECISION; } PORTDbits.RD6 = 1; // lock the reader PORTDbits.RD7 = 1; }
void sinewave (unsigned char m) { unsigned char i,n; unsigned char s[31]; float PI=3.141593; n=31;//32 samples for(i=0;i<=n;i++) {s[i]=(unsigned char)(sin(2*PI/(n+1)*i)*127+128); } while (SWITCH_1==1)//if RA5 not pressed { for(i=0;i<=n;i++) { PORTD=s[i]; //PORTD=(unsigned char)(sin(2*PI/(n+1)*i)*127+128);//output sine wave Delay100TCYx(m);//f=(double) 1/ (1/44.6 + n*0.00035); } } }
void transmit_data( unsigned char *TX_Data ) { unsigned char i, data, cmd; SPI_CSN = 0; //clear previous ints spi_Send_Read(0x27); spi_Send_Read(0x7E); SPI_CSN = 1; SPI_CSN = 0; //PWR_UP = 1 spi_Send_Read(0x20); spi_Send_Read(0x3A); SPI_CSN = 1; SPI_CSN = 0; //clear TX fifo //the data sheet says that this is supposed to come up 0 after POR, but that doesn't seem to be the case spi_Send_Read(0xE1); SPI_CSN = 1; SPI_CSN = 0; //fill byte payload spi_Send_Read(0xA0); for (i = 0; i< RF_PAYLOAD; i++) spi_Send_Read( TX_Data[i] ); SPI_CSN = 1; //Pulse CE to start transmission SPI_CE = 1; Delay100TCYx(2); SPI_CE = 0; }//
void main(void) { char mensagem[]="Pronto > "; ADCON1=0xF; // torna todas portas AN0 a AN12 como digitais // na PIC18F2525 somente AN0 a AN4 e AN8 a AN12 // nas PICs com 40 pinos, todos ANs de 0 a 12 // // PCFG3:PCFG0: A/D Port Configuration Control bits // Note 1: // The POR value of the PCFG bits depends on the value of // the PBADEN Configuration bit. When PBADEN = 1, // PCFG<2:0> = 000; when PBADEN = 0, PCFG<2:0> = 111. TRISB=0; // output do LCD na PORTB / LCD output in PORTB initLCD(); // inicia comandos de configuracao do LCD // LCD init commands /* * obs: a biblioteca XLCD.H da PLIB para PIC18, considera como default o LCD * conectado na PORTB com as seguintes pinagens: * Lower Nibble = LCD DATA in PORT B0, B1, B2, B3 (DATA_PORT) RW_PIN in B6 ( PORT for LCD RW , can also be grounded) RS_PIN in B5 ( PORT for LCD RS ) E_PIN in B4 ( PORT for LCD Enable Pin ) */ TRISA2=1; // entrada do BOTAO / push-BOTTON input TRISC0=0; // led verde 1 TRISC1=0; // led verde 2 TRISC2=0; // led verde 3 TRISC3=0; // led verde 4 TRISC4=0; //buzzer TRISC5=0; //led vermelho LED_VERMELHO=1; LED1=1; Delay10KTCYx(1000); while(BusyXLCD()); WriteCmdXLCD(0x01); // comando para limpar LCD / command to clear LCD while(BusyXLCD()); putrsXLCD ("Serial IO EUSART"); // somente logotipo / just a start logo SetDDRamAddr(0x40); // Linha 2 do Display LCD / second line of LCD while(BusyXLCD()); putrsXLCD ("RS232 PIC18F2525"); // somente logotipo / just a start logo SetDDRamAddr(0x00); // volta cursor para linha 0 e posicao 0 do LCD // put cursor in position 0,0 of LCD contadorDisplay=0; // zerando a posicao de caracteres do LCD // reseting the LCD character count // Habilitacao dos pinos C6 e C7 para uso da EUSART (explicacao abaixo): // Enabling pins C6 and C7 for EUSART (explanation bellow): TRISC6=1; TRISC7=1; RCSTAbits.SPEN=1; /* The pins of the Enhanced USART are multiplexed with PORTC. In order to configure RC6/TX/CK and RC7/RX/DT as a USART: ? SPEN bit (RCSTA<7>) must be set (= 1) ? TRISC<7> bit must be set (= 1) ? TRISC<6> bit must be set (= 1) Note: The EUSART control will automatically reconfigure the pin from input to output as needed. */ LED1=1; LED2=0; LED_VERMELHO=0; CloseUSART(); // fecha qualquer USART que estaria supostamente aberta antes // just closes any previous USART open port Delay10KTCYx(1); //Passing 0 (zero) results in a delay of 2,560,000 cycles Delay10KTCYx(1000); //PORTC=1; Delay10TCYx(50); PORTC=0; OpenUSART( USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_LOW, 51 ); // Baud Rate "51" para 2400bps @ 8mhz em modo assincrono // de acordo com DS39626E-page 207 do Datasheet em PDF da PIC18F2525 // These are common comands for 2400 bps running at 8 mhz, assyncronous mode // just as being showed in PIC18F2525 Datasheet (DS39626E-page 207) //baudUSART (BAUD_8_BIT_RATE | BAUD_AUTO_OFF); // page 1158 do pic18_plib.pdf (capitulo 8.17.1.3.3 baud_USART) // Set the baud rate configuration bits for enhanced usart operation // These functions are only available for processors with // enhanced usart capability (EUSART) /* The Enhanced Universal Synchronous Asynchronous Receiver Transmitter (EUSART) module is one of the two serial I/O modules. (Generically, the USART is also known as a Serial Communications Interface or SCI.) The EUSART can be configured as a full-duplex asynchronous system that can communicate with peripheral devices, such as CRT terminals and personal computers. It can also be configured as a half- duplex synchronous system that can communicate with peripheral devices, such as A/D or D/A integrated circuits, serial EEPROMs, etc. The Enhanced USART module implements additional features, including automatic baud rate detection and calibration, automatic wake-up on Sync Break recep- tion and 12-bit Break character transmit. These make it ideally suited for use in Local Interconnect Network bus (LIN bus) systems. (DS39626E-page 201) */ INTCONbits.PEIE = 1; // interrupcoes para perifericos INTCONbits.GIE = 1; // interrupcoes globais while(BusyUSART()); putrsUSART("\n\rLed1 e LedVermelho = Interrupcao; Led2 = while wait; Led3/4 = Err"); while(BusyUSART()); putrsUSART("\n\rComandos ^E (echo), ^P (lcd), ^L (cls), ^S (status)"); while(BusyUSART()); putrsUSART("\n\rTerminal Serial: "); while(BusyUSART()); putsUSART(mensagem); LED_VERMELHO=0; LED1=1; LED2=1; //LED4=1; while (1){ //LED4=RCIF; // o LED4 mostra o status da Interrupcao da RX Serial // Led4 shows the status of RX interrupt //LED3=TXIF; // o LED3 mostra o status da suposta interrupcao de TX // Led3 shows the suposed TX interrupt state LED3=OERR; LED4=FERR; /* bit 2 FERR: Framing Error bit 1 = Framing error (can be cleared by reading RCREG register and receiving next valid byte) 0 = No framing error * bit 1 OERR: Overrun Error bit 1 = Overrun error (can be cleared by clearing bit, CREN) 0 = No overrun error */ LED2=~LED2; Delay10KTCYx(10); // quando esta no modo de espera de tecla* (interrupcao), fica piscando // os tres leds para demonstrar a despreocupacao do loop while // *na verdade essa espera de tecla eh o RX da serial // when being in wait mode (for interrupt *keypress )just flashes the tree // leds to demonstrate the un-commitment of while loop to keypress // * this keypress event is the serial RX // Check for overrun error condition if (OERR == 1) { // Clear the overrun error condition BUZZ=1; CREN = 0; CREN = 1; Delay100TCYx(10); BUZZ=0; } LED_VERMELHO = RCIF; // buffer de recepcao cheio } return; }
void DelayPORXLCD(void) // minimum 15ms { Delay100TCYx(0xA0); // 100TCY * 160 return; }
void DelayXLCD(void) // minimum 5ms { Delay100TCYx(0x36); // 100TCY * 54 return; }
void main(void) { WDTCON = 0x00; //TRISA = 0xC0; TRISB = 0xFF; TRISC = 0xFF; UartTxCnt = 0; UartRxCnt = 0; CanRxBuff = 0; UartTxBuff = 0; // Initialize TIMER0 INTCON2bits.TMR0IP = 0; //Timer0 INT-LOW OpenTimer0(TIMER_INT_ON & T0_16BIT & T0_SOURCE_INT & T0_PS_1_128); // 24Mhz/4/128 := 46875 -> 65536 - 46875 = 18661 WriteTimer0(49911); // 1Sec interval at 8Mhz /* EEAddres.Bytes[0] = Read_b_eep(0); EEAddres.Bytes[1] = Read_b_eep(1); EEAddres.Bytes[2] = Read_b_eep(2); EEAddres.Bytes[3] = Read_b_eep(3); EEAddres.SE_ID = 0x20123456; */ // Initialize CAN module with no message filtering // 8MHz Fosc 250Kb/s // 8MHz -> 2MHz @ 250Khz = 8Tq (1+2+3+2) CANInitialize(1 ,0x02 ,2 ,3 ,2 , CAN_CONFIG_VALID_XTD_MSG); //256kb at 8Mhz crystal /*CANSetOperationMode(CAN_OP_MODE_CONFIG); CANSetFilter(CAN_FILTER_B1_F1, Can_bootF.SE_ID, CAN_CONFIG_XTD_MSG); CANSetFilter(CAN_FILTER_B1_F2, Can_nodeF.SE_ID, CAN_CONFIG_XTD_MSG); CANSetMask(CAN_MASK_B1, Can_Mask1.SE_ID, CAN_CONFIG_XTD_MSG); CANSetFilter(CAN_FILTER_B2_F1, Can_addrLO.SE_ID, CAN_CONFIG_XTD_MSG); CANSetMask(CAN_MASK_B2, Can_Mask2.SE_ID, CAN_CONFIG_XTD_MSG); */ CANSetOperationMode(CAN_OP_MODE_NORMAL); //ADC configuration //reference is connected to A0 //voltage output connected to A1 LATA = 0x00; PORTA=0; TRISA=0xFF; //A port as input ADCON1 = 0b00111101;//VSS,VDD ref. AN0 analog only //ADCON2 = 0b00001001;//ADCON2 setup: Left justified, Tacq=2Tad, Tad=2*Tosc (or Fosc/2) ADCON2 = 0b10101011; ADCON0bits.ADON = 0x01;//Enable A/D module INTCONbits.GIE = 1; //enable global interrupts Tcombo int2byte; UartRx_Msg.Data[4] = 1;//CanRx_Msg.Data[0]; UartRx_Msg.Data[5] = 2;//CanRx_Msg.Data[0]; UartRx_Msg.Data[6] = 3;//CanRx_Msg.Data[7]; UartRx_Msg.Data[7] = 4;//CanRx_Msg.Data[7]; while(1) { ClrWdt(); /********************************/ //cobtinuasly reading of current*/ /********************************/ //ADC chanel A0 - voltage ADCON0bits.CHS0 = 0;//clear ADCON0 to select channel 0 (AN0) ADCON0bits.CHS1 = 0;//clear ADCON0 to select channel 0 (AN0) ADCON0bits.CHS2 = 0;//clear ADCON0 to select channel 0 (AN0) ADCON0bits.CHS3 = 0;//clear ADCON0 to select channel 0 (AN0) Delay100TCYx (2); ADCON0bits.GO = 1; while (ADCON0bits.GO); //wait for conversion current_ad_value=ADRES; ClrWdt(); Delay100TCYx (2); //ADC chanel A1 - rederence ADCON0bits.CHS0 = 1; //select channel 1 (AN1) Delay100TCYx (2); ADCON0bits.GO = 1; while (ADCON0bits.GO); //wait for conversion reference_ad_value= ADRES; //delta ADC = reference votlatge - real voltage //we filter it thru buffer count++; if(count>=100) count=0; delta_ad[count] = reference_ad_value-current_ad_value; if (UTicTac >= 1) { UTicTac = 0; //current conversion //I=1.6V*200/1024*0.625 * delta_ad ==0.52083333333333333333333333333333 *delta_ad //reference votlatge - real voltage current=0; for(char i=0;i<100;i++){ current+=delta_ad[i]; } //current *= 0.0052083; //above formula /100 current *= 0.00463541637; //above formula with correction factor of 0.89 int2byte.Int = (int)current; UartRx_Msg.Data[0] = int2byte.Char[1]; UartRx_Msg.Data[1] = int2byte.Char[0]; //capcity capacity += (current/3600); int2byte.Int=(int)capacity; UartRx_Msg.Data[2] = int2byte.Char[1]; UartRx_Msg.Data[3] = int2byte.Char[0]; // CAN adresses UartRx_Msg.Address.SE_ID = 0x010000F2; CANSendMessage(UartRx_Msg.Address.SE_ID, &UartRx_Msg.Data[0], 8, CAN_TX_PRIORITY_0 & CAN_TX_XTD_FRAME & CAN_TX_NO_RTR_FRAME); ClrWdt(); } if (CANIsRxReady()) // Check for CAN message { CANReceiveMessage(&CanRx_Msg.Address.SE_ID, &CanRx_Msg.Data[0], &CanRx_Msg.Length.Len, &RecFlags); // if ( RecFlags & CAN_RX_OVERFLOW ) // { // // Rx overflow occurred; handle it // } if ( RecFlags & CAN_RX_INVALID_MSG ) { // Invalid message received; handle it } else { /* if ( RecFlags & CAN_RX_RTR_FRAME ) { // RTR frame received //UartRx_Msg.Data[6]++; CanRxBuff++; if (CanRxBuff >= BuffNO) CanRxBuff = 0; } else { // Regular frame received. //UartRx_Msg.Data[7]++; CanRxBuff++; if (CanRxBuff >= BuffNO) CanRxBuff = 0; }*/ if(CanRx_Msg.Address.SE_ID==0x020000F2) capacity=(char)CanRx_Msg.Data[0]; /*UartRx_Msg.Data[4] = CanRx_Msg.Data[0]; UartRx_Msg.Data[5] = CanRx_Msg.Data[1]; UartRx_Msg.Data[6] = CanRx_Msg.Data[6]; UartRx_Msg.Data[7] = CanRx_Msg.Data[7];*/ } // if ( RecFlags & CAN_RX_XTD_FRAME ) // { // // Extended Identifier received; handle it // } // else // { // // Standard Identifier received. // } // // Extract receiver filter match, if it is to be used // RxFilterMatch = RecFlags & CAN_RX_FILTER_BITS; } // Process received message /* if ((BusyUSART() == 0) && (UartSync == 1)) { if (UartTxCnt > 0) // Preveri èe posiljamo CAN telegram na UART { WriteUSART(CanRx_Msg[UartTxBuff].Array[UartTxCnt]); // Pošlji znak UartTxCnt++; // poveèaj stevec za naslednji znak if ((UartTxCnt) >= (J1939_MSG_LENGTH + J1939_DATA_LENGTH)) // Preveri èe je zadni znak { UartTxCnt = 0; // Postavi na prvi znak UartTxBuff++; // Premakni na novi Buffer if (UartTxBuff >= BuffNO) // Preveri da nismo cez mejo UartTxBuff =0; } } else { if (CanRxBuff != UartTxBuff) { WriteUSART(CanRx_Msg[UartTxBuff].Array[UartTxCnt]); // Pošlji ga na UART UartTxCnt++; // Poveèaj števec na naslednji znak } } } if (UartRxCnt >= (J1939_MSG_LENGTH + J1939_DATA_LENGTH)) // Ali imamo vse znake. { if (CANIsTxReady()) // Preveri ali ja CAN prost { // void CANSendMessage(unsigned long id, BYTE *Data, BYTE DataLen enum CAN_TX_MSG_FLAGS MsgFlags); CANSendMessage(UartRx_Msg.Address.SE_ID, &UartRx_Msg.Data[0], 8, CAN_TX_PRIORITY_0 & CAN_TX_XTD_FRAME & CAN_TX_NO_RTR_FRAME); UartRxCnt = 0; // Pripravi za sprejem novega telegrama iz UART-a LATAbits.LATA5 = !LATAbits.LATA5; } } if DataRdyUSART() // Preveri ali v UART èaka nov znak { UTicTac = 0; tp_char = ReadUSART(); // Preber znak v polje if (UartSync) { UartRx_Msg.Array[UartRxCnt] = tp_char; UartRxCnt++; // in poveèaj stevec prebranih znakov iz UART-a } else { if (tp_char == '#') UartSync = 1; } } if (UTicTac > 5) // Èe je števec èez mejo, telegram ni veljeven { UartRxCnt = 0; // Postavi na prvi znak v telegramu UTicTac = 0; }*/ } // Do this forever }
void DelayMS(UINT08 x) { while(x--)Delay100TCYx(40); }
void high_isr(void) { //Timer for servo if(INTCONbits.TMR0IF) { PORTBbits.RB3 = 1; if(servoState == 0){ Delay1TCY(); Delay1TCY(); //Delay10TCYx(6); }else{ Delay1TCY(); Delay1TCY(); Delay1TCY(); Delay1TCY(); Delay1TCY(); Delay1TCY(); Delay1TCY(); Delay10TCYx(5); Delay100TCYx(4); } PORTBbits.RB3 = 0; INTCONbits.TMR0IF = 0; // Clear interrupt flag for timer 0 WriteTimer0(64911); } //code for servo state = 1 and regular timer if(PIR1bits.TMR1IF && servoState == 1){ valveCounter++; if(valveCounter == valveTotalTick){ closeValve(); valveCounter = 0; } PIR1bits.TMR1IF = 0; // Clear interrupt flag for timer 0 } else if(PIR1bits.TMR1IF && plantTimerCount == totalTimerCount){ //Waters all the plants moveToLocation(plantBeingWatered); openValve(); if(plantBeingWatered == totalplants){ plantTimerCount = 0; plantBeingWatered = -1; } plantBeingWatered++; PIR1bits.TMR1IF = 0; // Clear interrupt flag for timer 0 } //Timer for timed water sequence else if(PIR1bits.TMR1IF) { plantTimerCount++; PIR1bits.TMR1IF = 0; // Clear interrupt flag for timer 0 } // interupt for button to water plant 0 if(INTCONbits.INT0IF){ moveToLocation(0); openValve(); INTCONbits.INT0IF = 0; } // interupt for button to water plant 1 if(INTCON3bits.INT1IF){ moveToLocation(1); openValve(); INTCON3bits.INT1IF = 0; } // interupt for button to water plant 2 if(INTCON3bits.INT2IF){ moveToLocation(2); openValve(); INTCON3bits.INT2IF = 0; } }
/** * Entering this method could mean that the transceiver is malfunctioning. * Xbee may be down or may have lost sync with his neighbor. * So, try to send a reset message to the transceiver and rejoin the mote. * A 100 ms delay is necessary to perform a full reset before send any command. */ void BSP_onDsWdtWakeUp(void) { XBee_reset(); Delay100TCYx(UINT_MAX); XBee_join(); }
/*! ********************************************************************** * Function: range(void) * * Include: Range.h * * @brief Samples the range * * Description: Takes a number of samples of the ultrasonic sensor at a specified * rate. Continues to sample the IR sensor at a different rate while * sampling the ultrasonic. Then combines the ranges and sets the * target state * * Arguments: None * * Returns: the range *************************************************************************/ unsigned int range(void) { #define range_IR sumIR //Come conenient name changes #define range_US sumUS char i; unsigned int k; unsigned int temp; unsigned long int sumUS = 0; unsigned long int sumIR = 0; int IR_samples = 0; unsigned char delayUS = 100 / rateUS; //100Hz will give 1 delay increment of 10ms unsigned char delayIR = 10000 / rateIR; //10KHz will give 1 delay increment of 0.1ms //Multiplex onto the IR sensor // SetChanADC(ADC_IR_READ); ADCON0 = ADC_IR_READ; for (i = 0; i < numSamples; i++) { configureRange(); //Still have to reconfigure each time??? beginUS(); //Continue sampling the IR while waiting for the ultrasonic while (measuringUS) { ADCON0bits.GO = 1; while (ADCON0bits.GO_NOT_DONE); temp = ADRES; if (temp > 100) sumIR += IR_CONV(temp); else IR_samples--; //sumIR += IR_CONV(ADRES >> 6); IR_samples++; Delay100TCYx(delayIR); //Delays in inrements of 100Tcy, which is 100 x 1us for 4MHz clock -> 0.1ms or 10KHz } //get range of ultrasonic reading sumUS += rangeUS(25); ///Standard room temperature for now @todo Read in temperature for US calculation Delay10KTCYx(delayUS); //Delays in increments of 10KTcy, which is 10,000 * 1us for a 4MHz clock } if (numSamples) sumUS = sumUS / numSamples; //Calculate the average Ultrasonic range else sumUS = 0; //Average all IR samples taken, and convert to distance if (IR_samples) range_IR = sumIR / IR_samples; else sumIR = 0; // Save the range value for printing raw rang lastIRRange = range_IR; lastUSRange = range_US; // Eliminate out of range values if (range_IR > m_maxRange) range_IR = 0; if (range_US > m_maxRange) range_US = 0; if (range_IR < m_minRange) range_IR = 0; if (range_US < m_minRange) range_US = 0; return lastRange = fuseRange(range_US, range_IR); #undef range_IR #undef range_US }
void Delay1KTCYx(unsigned char unit) { int i; for(i = 0; i < 10; i++) { Delay100TCYx(unit); } };