void TaskSensores(void *pdata) { #if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif struct AdcMsg *m; INT16U value = 0; INT16U ValorTeclado = 0; INT8U err; for(;;) { m = (struct AdcMsg *) OSMemGet(dMemory,&err); if(err == OS_NO_ERR){ OSSemPend(STeclado,0,&err); ValorTeclado = NumeroSensores; OSSemPost(STeclado); m->adc0 = 0; m->adc1 = 0; m->adc2 = 0; switch(ValorTeclado){ case 3: Delay10TCYx(100); SetChanADC(ADC_CH2); ConvertADC(); while( BusyADC() ); value = ReadADC(); m->adc2 = Temp(value); case 2: Delay10TCYx(100); SetChanADC(ADC_CH1); ConvertADC(); while( BusyADC() ); value = ReadADC(); m->adc1 = Temp(value); case 1: Delay10TCYx(100); SetChanADC(ADC_CH0); ConvertADC(); while( BusyADC() ); value = ReadADC(); m->adc0 = Temp(value); default: break; } err = OSQPost(QueueADC0,m); if(err == OS_Q_FULL){ OSMemPut(dMemory,m); OSSemPost(STaskTxSerial); } }else{ OSSemPost(STaskTxSerial); } //OSSemPost(STask2); OSTimeDly(1); } }
/* switch to ADC chan 8 (shorted to ground) to reset ADC measurement cap to zero before next measurement */ void ADC_zero(void) { ClrWdt(); // reset the WDT timer SetChanADC(ADC_CH8); // F3 grounded input Delay10TCYx(ADC_CHAN_DELAY); ConvertADC(); while (BusyADC()); }
void main (void) { int count = 0; int analogTemp = 0; // A temporary place holder is needed // since ADC will screw with the number // you are assigning to, and we could // switch threads during that time. TRISB = 0; // Output for relay TRISD = 0; // Output for seven segment display TRISC = 0; // More output for seven segment display TRISAbits.TRISA0 = 1; // Analog input writeNum(0); // Enable timer interrupt Flags.Byte = 0; INTCON = 0x20; //disable global and enable TMR0 interrupt INTCON2 = 0x84; //TMR0 high priority RCONbits.IPEN = 1; //enable priority levels TMR0H = 0; //clear timer TMR0L = 0; //clear timer T0CON = 0x84; //set up timer0 - prescaler 1:8 INTCONbits.GIEH = 1; //enable interrupts while(1){ OpenADC(ADC_FOSC_8 & ADC_RIGHT_JUST & ADC_0_TAD, ADC_CH0 & ADC_INT_OFF & ADC_VREFPLUS_VDD & ADC_VREFMINUS_VSS, 0b1011); SetChanADC(ADC_CH0); ConvertADC(); // Start conversion while( BusyADC() ); // Wait for ADC conversion analogTemp = ReadADC(); // Read result and put in temp CloseADC(); analogInput = analogTemp >> 6; // Get only the most significant bits // If we didn't change values since last time, we are in a holding state if( analogPrevious == analogInput && !hold) hold = 1; else if (analogPrevious != analogInput){ acceptedNum = 0; hold = 0; } // Turn off potential for activating the relay if we aren't on 0 if(analogInput) PORTB = 0; // If we are allowing the second relay activation and we are on 0 if(secondRun && !analogInput) { PORTB = 0xFF; secondRun = 0; passDigit = 0; } analogPrevious = analogInput; writeNum(analogInput); } }
unsigned int ADC_read(unsigned char ADC_channel) { unsigned int ad_res; SetChanADC(ADC_channel); Delay10TCYx(5); ConvertADC(); while(BusyADC()); ad_res = ReadADC(); return ad_res; }
int readADC(BYTE address) { int data; // Choosing ADC channel (override ADC_CH0) switch(address) { case 0: SetChanADC(ADCCHAN(0)); break; case 1: SetChanADC(ADCCHAN(1)); break; case 2: SetChanADC(ADCCHAN(2)); break; case 3: SetChanADC(ADCCHAN(3)); break; case 4: SetChanADC(ADCCHAN(4)); break; default: return -1; // non existing channel } delay_us(125); // wait until channel selection is stable ConvertADC(); // Start conversion while (BusyADC()); // Wait for ADC conversion data = ReadADC(); // Read result return data; }
void measureCarbon() { //Perform Measurement and convert to correct format //Choose a channel adc channel AN1 // OpenADC(ADC_FOSC_4 & ADC_RIGHT_JUST & ADC_8ANA_0REF , ADC_CH1 & ADC_INT_OFF); SetChanADC(ADC_CH1); Delay10KTCYx(5); ConvertADC(); while(BusyADC()); carbon = ReadADC(); //take value read and divide by 204.8 to get voltage read }
void adc_int_handler(){ // adcbuffer[0] stores the count if(adcbuffer[0] < 3) // increment counter adcbuffer[0] = adcbuffer[0] + 1; else adcbuffer[0] = 1; // Converts ADRESH to a voltage int k = (int)ADRESH; float voltage = 3.4*k/256; int roundDist; // If the voltage is larger than .5 V this runs it through a simplifed equation to return the approximate distance // WARNING: This equation is not completely accurate so results may vary until it is improved if (voltage > .5) { float dist = 24/(voltage - 0.1); roundDist = (int)(dist + 0.5); } // If the voltage is too small then the object is assumed to be too far away so we send back 0xFF else roundDist = 0xFF; // Reads the current channel from the count of the adcbuffer[0] // Puts the current distance of the respective sensor in the adcbuffer then changes to the next channel int channel = (int)adcbuffer[0] % 3; if (channel == 0) { adcbuffer[3] = roundDist; SetChanADC(ADC_CH1); } else if (channel == 1) { adcbuffer[1] = roundDist; SetChanADC(ADC_CH2); } else { adcbuffer[2] = roundDist; SetChanADC(ADC_CH3); } }
void measureTemperature() { int i; for(i=0;i<5;i++){ // perform measurement on AN5 note that AN3 is the +Vref signal and is 7 volts //OpenADC(ADC_FOSC_4 & ADC_RIGHT_JUST & ADC_8ANA_0REF , ADC_CH5 & ADC_INT_OFF); SetChanADC(ADC_CH5); Delay10KTCYx(5); ConvertADC(); while(BusyADC()); temp[i] = ReadADC(); } }
/***************************************************************** * Function: readIRSensor * Input Variables: none * Output Return: 1 if there is IR * 0 if there is no IR * Overview: Reads the valus for the IR and determs if there is IR ******************************************************************/ int readIRSensor() { int ra0 = 0; SetChanADC(ADC_CH0); ConvertADC(); while(BusyADC()); ra0 = ReadADC(); if(ra0 >= 500){ return 0; }else{ return 1; } }
unsigned int GetCO() { unsigned int CORaw=0; SetChanADC(ADC_CH0); ConvertADC(); while(BusyADC()); CORaw = ReadADC(); //CloseADC(); return CORaw; }
/* getArrayCurrent -- Major Function * Gather and convert the current provided * by the solar array, in mA */ int getArrayCurrent(void){ int i; int average = 0; SetChanADC(PWR_I_AN_CH); for (i = 0; i < POWER_FILT; ++i){ ConvertADC(); while(BusyADC()); average += ReadADC(); } average /= POWER_FILT; average =(int)(average * POWER_BIT_MA); return average; }
/* getArrayVoltage -- Major Function * gathers and scales the voltage from * the output of the solar array, in mV */ int getArrayVoltage(void){ int i; int average = 0; SetChanADC(PWR_V_AN_CH); for (i = 0; i < POWER_FILT; ++i){ ConvertADC(); while(BusyADC()); average += ReadADC(); } average /= POWER_FILT; average *= POWER_BIT_MV; return average; }
void measureSalinity() { // send power on to measure circuit measureOn = 1; //Perform Measurement and convert to correct format on AN0 // OpenADC(ADC_FOSC_4 & ADC_RIGHT_JUST & ADC_8ANA_0REF , ADC_CH0 & ADC_INT_OFF); SetChanADC(ADC_CH0); Delay10KTCYx(5); ConvertADC(); while(BusyADC()); salinity = ReadADC(); //take value read and divide by 204.8 to get voltage read // power off measureing circuit measureOn = 0; }
void Button_init(button_callback_func_ptr_t pfnCallback) { unsigned char i = 0; for (i = 0; i < 16; i++) { m_astcButtonCtrl[i].currState = StateLow; m_astcButtonCtrl[i].saveState = 0; m_astcButtonCtrl[i].light = 1; } m_astcButtonCtrl[4].light = 0; m_astcButtonCtrl[5].light = 0; m_astcButtonCtrl[6].light = 0; m_astcButtonCtrl[7].light = 0; Init74hc595(); SetChanADC(ADC_CH0); m_pfnCallback = pfnCallback; }
int GetVOC() { unsigned int VOC_Raw=0; SetChanADC(ADC_CH1); ConvertADC(); while(BusyADC()); VOC_Raw = ReadADC(); //CloseADC(); return VOC_Raw; }
/* ********************************************************************** * Function: readTempx2(void) * * Include: ADC.h * * Description: Reads the temperature from the Temp sensor * * Arguments: None * * Returns: temp x 2 (in deg celsius) as an unsigned char *************************************************************************/ unsigned char readTempx2(void) { int ad_result; unsigned char tempx2; //Sets the ADC channel to read the temperature SetChanADC(ADC_TEMP_READ); //Performs the conversion ConvertADC(); while(BusyADC()); ad_result = ReadADC(); //10mV per deg C, which 0V at 0deg, with the ADC res ~5mV tempx2 = ad_result; lastTempx2 = tempx2; return tempx2 + calibration_offset; }
unsigned int MPX6115_uiGetPression(void) { int iResult; unsigned long ulPression; OpenADC(ADC_FOSC_32 & ADC_RIGHT_JUST & ADC_12_TAD, ADC_CH0 & ADC_INT_OFF, 0); //open adc port for reading ADCON1 =0x00; //set VREF+ to VDD and VREF- to GND (VSS) SetChanADC(ADC_CH5); //Set ADC to Pin 5 Delay1KTCYx(5); ConvertADC(); while( BusyADC() ); iResult = ReadADC(); CloseADC(); ulPression=((unsigned long)iResult*5000/1024 + 475)*10 /45; #ifdef DEBUG printf("Pression %ld %x\n\r",ulPression,iResult); #endif ADCON1=0b00001111; // Digital Channel Allocation return (unsigned int)ulPression; }
uint16_t analog_get(AnalogInIndex ain) { if ( ain > kAnalogSplit ) { /* get oi data */ /* we may not want to trust "ain" */ return rxdata.oi_analog[ ain - kAnalogSplit ]; } /* kNumAnalogInputs should be checked somewhere else... preferably at * compile time. */ else if ( ain < kNumAnalogInputs && NUM_ANALOG_VALID(kNumAnalogInputs) ) { /* read ADC */ SetChanADC(ain); Delay10TCYx( 5 ); /* Wait for capacitor to charge */ ConvertADC(); while( BusyADC() ); return ReadADC(); } else { return 0xFFFF; } }
void InitApp(void){ /* TODO Initialize User Ports/Peripherals/Project here */ TRISA = 0x00000001; //RA0 Input TRISB = 0b00000001; //RB0 Input TRISC = 0x00; TRISD = 0x00; TRISE = 0x00; /* Setup analog functionality and port direction */ ADCON1 = 0x0F; //For Digital CMCON = 0x07; /* Initialize peripherals */ PORTA = 0X00; PORTB = 0X00; //RB0 Input PORTC = 0X00; PORTD = 0X00; PORTE = 0X00; /* Configure the IPEN bit (1=on) in RCON to turn on/off int priorities */ INTCON2bits.INTEDG0 = 0; INTCON2bits.RBIP = 1; /* Enable interrupts */ INTCONbits.INT0IF = 0; INTCONbits.INT0IE = 1; RCONbits.IPEN = 1; INTCONbits.GIEH = 1; INTCONbits.GIEL = 0; /* ADC Config */ OpenADC(ADC_FOSC_16 & ADC_RIGHT_JUST & ADC_2_TAD, ADC_CH0 & ADC_INT_OFF & ADC_VREFPLUS_VDD & ADC_VREFMINUS_VSS, ADC_1ANA); SetChanADC(ADC_CH0); __delay_ms(1); //Com PORT -> 19200bps 8Bit 1Stop / fosc = 48Mhz / BRGH = 155 TRISCbits.RC6 = 0; TRISCbits.RC7 = 1; OpenUSART(USART_TX_INT_OFF & USART_RX_INT_OFF & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_BRGH_HIGH, 155); }
void isr(void) { // === Eine PPM-Flanke vom Fernbedienungsempfänger wurde erkannt === if(PIR1bits.CCP1IF) { current_edge_time = CCPR1; if ( current_edge_time < last_edge_time ) // Timer übergelaufen last_edge_time -= 0x00ffff; pulse_width = current_edge_time - last_edge_time; last_edge_time = current_edge_time; if (pulse_width > 6250) // 6250 Timertakte * 0,8µs Timertaktlänge = 5 ms { current_rc_channel = 1; current_rc_frame_ok = true; } else { if (pulse_width >= 1250 && pulse_width <= 2500) // zwischen 1 und 2 ms raw_rc_data[current_rc_channel] = pulse_width - 1250; else current_rc_frame_ok = false; if (current_rc_channel == sizeof(raw_rc_data)/sizeof(raw_rc_data[0]) - 1) // Letzter Kanal { if (current_rc_frame_ok) { new_rc_values_available = true; last_valid_rc_frame = ms_clock; signal = true; } } current_rc_channel++; } CCP1CONbits.CCP1M0 ^= 1; // Als nächstes auf die umgekehrte Flanke warten PIR1bits.CCP1IF = false; } // === Der ADC hat ne Wandlung fertig === if (PIR1bits.ADIF) { if (*curr_chan == ADC_CH0) adc_values.batt = ReadADC(); if (*curr_chan == ADC_CH1) adc_values.roll = ReadADC(); if (*curr_chan == ADC_CH2) adc_values.pitch = ReadADC(); if (*curr_chan == ADC_CH5) adc_values.yaw = ReadADC(); curr_chan++; if (curr_chan == (channel_sequence + chan_count)) { curr_chan = &channel_sequence[0]; SetChanADC(*curr_chan); new_gyro_values_available = true; } else { SetChanADC(*curr_chan); ConvertADC(); } PIR1bits.ADIF = false; } // === Interrupt Timer 1 === if (INTCONbits.T0IF) { i16u temp; // Timer vorwärtsschieben, somit dauerts bis zum nächsten Überlauf nur 625 Timertakte * 1,6µs Timertaktlänge = 1ms temp.b0 = TMR0L; temp.b1 = TMR0H; temp.u16 += (65536 - 625); TMR0H = temp.b1; TMR0L = temp.b0; if (out_messages.waiting_for_ack_timer) out_messages.waiting_for_ack_timer--; PIE1bits.ADIE = true; // Das kann hier weg, oder? ms_clock++; if (signal && ms_clock - last_valid_rc_frame > 200) signal = false; if (!(ms_clock % 5)) ConvertADC(); // if (!(ms_clock % 5)) // erstmal einfach so, hab mir nichts dabei gedacht // motors_need_updating = true; // if (!(ms_clock % 5000)) // motor_debug_needs_processing = true; if (lifesaver_timeout) lifesaver_timeout--; INTCONbits.T0IF = false; } // === Ein Byte ist per SPI eingegangen === if (PIR1bits.SSPIF) { // Da wir nur beim ersten Byte frisch in diesen Block kommen und danach hier bleiben, wissen wir, daß dies das // erste Byte einer neuen Nachricht ist -> Puffer leeren spi_rec_buffer.read_cursor = 0; spi_rec_buffer.write_cursor = 0; while (!PORTAbits.NOT_SS && spi_rec_buffer.write_cursor < spi_rec_buffer.size) // den Ausgangspuffer brauchen wir nicht zu prüfen, von dem wird nur gelesen { spi_rec_buffer.data[spi_rec_buffer.write_cursor] = SSPBUF; SSPBUF = spi_out_msg_buffer.data[spi_out_msg_buffer.read_cursor]; PIR1bits.SSPIF = 0; if (LATAbits.LATA4) { if (spi_out_msg_buffer.read_cursor == spi_out_msg_buffer.write_cursor) { spi_sending_state = SPI_SENDING_IDLE; LATAbits.LATA4 = 0; // IRQ-Leitung dauerhaft low, dann wird der Secondary das /CS gleich abschalten und das // Byte im Puffer nicht mehr abholen if (spi_out_msg_buffer.data[0] != 0 || spi_out_msg_buffer.data[1] != 0 || spi_out_msg_buffer.data[2] != 1) { // Wenns keine ACK-Nachricht war, war es wohl eine normale, wir warten also auf ein ACK // Und zwar 0.68 Sekunden lang, laut Data ist das "für einen Androiden fast eine Ewigkeit": out_messages.waiting_for_ack_timer = 664; } } else { // Ansonsten nur ein kurzer Low-Puls, damit er weiß, daß er weitere Bytes abholen kann LATAbits.LATA4 = 0; LATAbits.LATA4 = 0; LATAbits.LATA4 = 0; LATAbits.LATA4 = 0; // Um das zu erkennen, braucht er mindestens vier Zyklen LATAbits.LATA4 = 0; LATAbits.LATA4 = 1; spi_out_msg_buffer.read_cursor++; } } else { // Durch kurzes Wechseln der IRQ-Leitung teilen wir dem Secondary mit, daß er jetzt weitere Bytes schicken kann LATAbits.LATA4 = 1; LATAbits.LATA4 = 1; LATAbits.LATA4 = 1; LATAbits.LATA4 = 1; // Um das zu erkennen, braucht er mindestens vier Zyklen LATAbits.LATA4 = 1; LATAbits.LATA4 = 0; } spi_rec_buffer.write_cursor++; while (!PORTAbits.NOT_SS && !PIR1bits.SSPIF); // Wir warten, daß ein weiteres Byte kommt oder die Nachricht zu Ende ist } spi_message_received = true; } }
void ADC_read(void) // update all voltage/current readings and set load current in 'currentload' variable { // ADC is opened and config'd in main static uint16_t i, z, change = 0; // used for fast and slow sample loops >256 static int32_t a10_x_t, a10_y_t, a10_z_t; ClrWdt(); // reset the WDT timer ADC_zero(); SetChanADC(ADC_CH0); // A0 system Delay10TCYx(ADC_CHAN_DELAY); Vin = 0; for (i = 0; i < ADC_SAMP_F; i++) { ConvertADC(); while (BusyADC()); Vin += (uint16_t) ReadADC(); } Vin /= ADC_SAMP_F; vbatol_t = Vin * (ADC0_MV - ADC_NULL + adc_cal[0]); // voltage correction factor vbatol_t = vbatol_t / 100; ADC_zero(); SetChanADC(ADC_CH1); // A1 motor Delay10TCYx(ADC_CHAN_DELAY); Vin = 0; for (i = 0; i < ADC_SAMP_F; i++) { ConvertADC(); while (BusyADC()); Vin += (uint16_t) ReadADC(); } Vin /= ADC_SAMP_F; solar_t = Vin * (ADC1_MV - ADC_NULL + adc_cal[1]); solar_t = solar_t / 100; ADC_zero(); SetChanADC(ADC_CH2); // A2 current_x Delay10TCYx(ADC_CHAN_DELAY); Vin = 0; for (i = 0; i < ADC_SAMP_S; i++) { ConvertADC(); while (BusyADC()); Vin += (uint16_t) ReadADC(); } Vin /= ADC_SAMP_S; a10_x = Vin; // raw ADC value Vin = Vin - (AMP10_ZERO - ADC_NULL + adc_cal[11]); // set zero NULL0 point a10_x_t = (long) Vin * (long) (ADC2_MV - ADC_NULL + adc_cal[2]); if (ABSL(a10_x_t) < AMPZ) a10_x_t = 0; // zero bit noise a10_x_t = (long) ((float) a10_x_t / (float) AMP10_SEN_H); a10_x_t = (long) lp_filter((float) a10_x_t, LP_CURRENT_X, FALSE); // use digital filter if ((a10_x == NULL0) || (a10_x_t < 0.0)) a10_x_t = 0; // if sensor disconnected read zero ADC_zero(); SetChanADC(ADC_CH11); // A11 current_y, switch from 3 so we can use external VREF Delay10TCYx(ADC_CHAN_DELAY); Vin = 0; for (i = 0; i < ADC_SAMP_S; i++) { ConvertADC(); while (BusyADC()); Vin += (uint16_t) ReadADC(); } Vin /= ADC_SAMP_S; // a10_y = Vin; // raw ADC value Vin = Vin - (AMP10_ZERO - ADC_NULL + adc_cal[12]); a10_y_t = (long) Vin * (long) (ADC3_MV - ADC_NULL + adc_cal[3]); if (ABSL(a10_y_t) < AMPZ) a10_y_t = 0; // zero bit noise a10_y_t = (long) ((float) a10_y_t) / ((float) AMP10_SEN_L); a10_y_t = (long) lp_filter((float) a10_y_t, LP_CURRENT_Y, FALSE); // use digital filter if ((a10_y == NULL0) || (a10_y_t < 0.0)) a10_y_t = 0; // if sensor disconnected (zero) read zero current ADC_zero(); SetChanADC(ADC_CH4); // A5 current_z Delay10TCYx(ADC_CHAN_DELAY); Vin = 0; for (i = 0; i < ADC_SAMP_S; i++) { ConvertADC(); while (BusyADC()); Vin += (uint16_t) ReadADC(); } Vin /= ADC_SAMP_S; a10_z = Vin; Vin = Vin - (AMP10_ZERO - ADC_NULL + adc_cal[13]); // set zero NULL0 point a10_z_t = (long) Vin * (long) (ADC4_MV - ADC_NULL + adc_cal[4]); if (ABSL(a10_z_t) < AMPZ) a10_z_t = 0; // zero bit noise a10_z_t = (long) ((float) a10_z_t / (float) AMP10_SEN_L); a10_z_t = (long) lp_filter((float) a10_z_t, LP_CURRENT_Z, FALSE); if ((a10_z == NULL0) || (a10_z_t < 0.0)) a10_z_t = 0; // if sensor disconnected read zero ADC_zero(); SetChanADC(ADC_CH5); // F0 pot x Delay10TCYx(ADC_CHAN_DELAY); Vin = 0; for (i = 0; i < ADC_SAMP_F; i++) { ConvertADC(); while (BusyADC()); Vin += (uint16_t) ReadADC(); } Vin /= ADC_SAMP_F; rawp[0] = Vin; ADC_zero(); SetChanADC(ADC_CH6); // F1 pot y Delay10TCYx(ADC_CHAN_DELAY); Vin = 0; for (i = 0; i < ADC_SAMP_F; i++) { ConvertADC(); while (BusyADC()); Vin += (uint16_t) ReadADC(); } Vin /= ADC_SAMP_F; rawp[1] = Vin; ADC_zero(); SetChanADC(ADC_CH7); // F2 pot z Delay10TCYx(ADC_CHAN_DELAY); Vin = 0; for (i = 0; i < ADC_SAMP_F; i++) { ConvertADC(); while (BusyADC()); Vin += (uint16_t) ReadADC(); } Vin /= ADC_SAMP_F; rawp[2] = Vin; ADC_zero(); SetChanADC(ADC_CH8); // F0 pot max Delay10TCYx(ADC_CHAN_DELAY); Vin = 0; for (i = 0; i < ADC_SAMP_F; i++) { ConvertADC(); while (BusyADC()); Vin += (uint16_t) ReadADC(); } Vin /= ADC_SAMP_F; rawa[0] = Vin; ADC_zero(); SetChanADC(ADC_CH9); // F1 pot max Delay10TCYx(ADC_CHAN_DELAY); Vin = 0; for (i = 0; i < ADC_SAMP_F; i++) { ConvertADC(); while (BusyADC()); Vin += (uint16_t) ReadADC(); } Vin /= ADC_SAMP_F; rawa[1] = Vin; ADC_zero(); SetChanADC(ADC_CH10); // F2 pot max Delay10TCYx(ADC_CHAN_DELAY); Vin = 0; for (i = 0; i < ADC_SAMP_F; i++) { ConvertADC(); while (BusyADC()); Vin += (uint16_t) ReadADC(); } Vin /= ADC_SAMP_F; rawa[2] = Vin; R.motorvoltage = solar_t; R.systemvoltage = vbatol_t; if (SYSTEM_STABLE) { s_crit(HL); R.current_z = a10_z_t; R.current_y = a10_y_t; R.current_x = a10_x_t; R.pos_x = rawp[XAXIS]; R.pos_y = rawp[YAXIS]; R.pos_z = rawp[ZAXIS]; R.max_x = rawa[XAXIS]; R.max_y = rawa[YAXIS]; R.max_z = rawa[ZAXIS]; e_crit(); for (z = 0; z < MAX_POT; z++) { motordata[z].pot.pos_actual = rawp[z]; if (ABSI(motordata[z].pot.pos_actual - motordata[z].pot.pos_actual_prev) > motordata[z].pot.pos_change) { motordata[z].pot.pos_change = ABSI(motordata[z].pot.pos_actual - motordata[z].pot.pos_actual_prev); } if (motordata[z].active && (motordata[z].pot.pos_change > motordata[z].pot.limit_change)) { if (mode.change) { term_time(); sprintf(bootstr2, " Pot %i Change too high %i\r\n", z, motordata[z].pot.pos_change); puts2USART(bootstr2); motordata[z].pot.pos_change = motordata[z].pot.limit_change; // after one message stop and set it to the limit. } else { motordata[z].pot.pos_actual = rawp[z]; // set to current pot reading motordata[z].pot.pos_actual_prev = rawp[z]; motordata[z].pot.pos_change = 0; // pot position change mag } } // Check for POT Dead-Spot readings if ((motordata[z].pot.pos_change >= POT_MAX_CHANGE) && !mode.qei) motordata[z].pot.cal_failed = TRUE; if (!motordata[z].active) motordata[z].pot.cal_failed = FALSE; // don't fail inactive motors motordata[z].pot.pos_actual_prev = motordata[z].pot.pos_actual; if (motordata[z].pot.pos_actual > motordata[z].pot.high) motordata[z].pot.high = motordata[z].pot.pos_actual; // set adc limits of values X,Y,Z if (motordata[z].pot.pos_actual < motordata[z].pot.low) motordata[z].pot.low = motordata[z].pot.pos_actual; if (mode.operate == VIISION_MS) { // use the preset o-100 resistance limits for scaling motordata[z].pot.high = VIISION_MS_RES_HIGH; motordata[z].pot.low = VIISION_MS_RES_LOW; } motordata[z].pot.offset = motordata[z].pot.low; motordata[z].pot.span = motordata[z].pot.high - motordata[z].pot.low; if (motordata[z].pot.span < 0) motordata[z].pot.span = 0; motordata[z].pot.scale_out = SCALED_FLOAT / motordata[z].pot.span; motordata[z].pot.scale_in = motordata[z].pot.span / SCALED_FLOAT; motordata[z].pot.scaled_actual = (int) ((float) (motordata[z].pot.pos_actual - motordata[z].pot.offset) * motordata[z].pot.scale_out); if (motordata[z].pot.scaled_actual > SCALED) motordata[z].pot.scaled_actual = SCALED; motordata[z].pot.pos_set = (int) (((float) motordata[z].pot.scaled_set * motordata[z].pot.scale_in) + motordata[z].pot.offset); } if (mode.emo) { term_time(); sprintf(bootstr2, " EMO flag tripped, possible short circuit in the assy wiring.\r\n"); puts2USART(bootstr2); term_time(); sprintf(bootstr2, " EMO DUMP Current %li, %li, %li : Position %li, %li, %li\r\n", emodump.emo[0], emodump.emo[1], emodump.emo[2], emodump.emo[3], emodump.emo[4], emodump.emo[5]); puts2USART(bootstr2); voice2_ticks(40); while (TRUE) { emo_display(); buzzer_ticks(200); ClrWdt(); // reset the WDT timer } } } ADC_zero(); // ground ADC input ClrWdt(); // reset the WDT timer }
//reads and returns the current long checkcurrent() { /*//code for original current sensor int currentCH0 = 0, currentCH1 = 0, current = 0; unsigned char interruptstatus; /////////CURRENT/////////// //get the channel 0 current //ensure that interrupts are disabled while doing the conversion interruptstatus = GLOBALINTERRUPTS; GLOBALINTERRUPTS = INTERRUPTDISABLE; SetChanADC(ADC_CH0); //From dale's code for the shunt current sensor currentCH0 = ((float) (read15bitOversample() - 7.3284) * 0.001515656734 )* 100; // Calculated new gains on 1/4/2012 SetChanADC(ADC_CH1); currentCH1 = ((float) (read15bitOversample() - 7.3284) * 0.001515656734 )* 100; // Calculated new gains on 1/4/2012 //enable interrupts until next conversion GLOBALINTERRUPTS = interruptstatus; //determine which value to use currentCH0 = currentCH0 - channelZeroInitial; currentCH1 = currentCH1 - channelOneInitial; //I am considering channel 1 to be the negative current direction if(currentCH0 >= 0 && currentCH1 >= 0) { //if both are positive we will just use the higher value (for now) if(currentCH0 > currentCH1) current = currentCH0; else current = -currentCH1; } else if(currentCH0 <= 0 && currentCH1 <= 0) current = 0; else if(currentCH0 <= 0 && currentCH1 >= 0) current = -currentCH1; //go with the positive value else if(currentCH0 >= 0 && currentCH1 <= 0) current = currentCH0; else current = 0;//just a default case return current;//*/ ///////////////////////////////////////////////////////////////////////////////////// //*//The following code works for the HAIS 50 P hall effect current sensor. //On current sensor: yellow wire is voltage reference of 2.5, and white wire is Vout // Code written on the 2012 race by Jimmy Frilling // Inserted into this master BPS code on 29-Apr-2013 //Edited by Daniel Cambron on 1-May-2013 //int currentCH0 = 0, currentCH1 = 0; unsigned char interruptstatus; int k = 0; long result = 0; //return the final answer signed long int adcval = 0; //need a long to store the value (long is 32 bits) signed long int ref = 0; long average = 0; //Calibration 1-May-2013 Daniel Cambron //tests show that Vout-Vref = 0.00001253*current in mA //current in mA = (4.5/1024)*(average adc value)/.00001253 + 470 // or approximately 348.477*(average adc value) + 470 // instead of dividing to get the average adc value, we just run the loop 1024 times and find the sum, // and then multiply the number down to 348.48. 348.48 = 1024 * 0.3403095, //so run the loop 1024 times and multiply by 0.3403095 at the end interruptstatus = GLOBALINTERRUPTS; GLOBALINTERRUPTS = INTERRUPTDISABLE; for(k=0;k<1024;++k){ SetChanADC(ADC_CH1); //channel has the voltage reference for the current sensor ConvertADC(); //tell the ADC to run once while(BusyADC()); //wait until the conversion is finished ref = ReadADC(); //store the value that was converted into result SetChanADC(ADC_CH0); //channel has the current sensor value ConvertADC(); //tell the ADC to run once while(BusyADC()); //wait until the conversion is finished adcval = ReadADC(); //store the value that was converted into result average += adcval - ref; } GLOBALINTERRUPTS = interruptstatus; result = average; //a calibration offset of 470 mA, and a factor of 0.3403095197 result = ( (float)result * 0.3403) + 470; if(result > CUTOFF_CURRENT_HIGH || result < CUTOFF_CURRENT_LOW){ failure(CURRENTERR, 0xFF, result, 0x00); } return result; }
void main(void) { char c; signed char length; unsigned char msgtype; unsigned char last_reg_recvd; uart_comm uc; i2c_comm ic; unsigned char msgbuffer[MSGLEN + 1]; unsigned char i; uart_thread_struct uthread_data; // info for uart_lthread timer1_thread_struct t1thread_data; // info for timer1_lthread timer0_thread_struct t0thread_data; // info for timer0_lthread #ifdef __USE18F2680 OSCCON = 0xFC; // see datasheet // We have enough room below the Max Freq to enable the PLL for this chip OSCTUNEbits.PLLEN = 1; // 4x the clock speed in the previous line #else #ifdef __USE18F45J10 OSCCON = 0x82; // see datasheeet OSCTUNEbits.PLLEN = 1; // Makes the clock exceed the PIC's rated speed if the PLL is on #else #ifdef __USE18F26J50 OSCCON = 0xE0; // see datasheeet OSCTUNEbits.PLLEN = 1; #else #ifdef __USE18F46J50 OSCCON = 0xE0; //see datasheet OSCTUNEbits.PLLEN = 1; #else Something is messed up. The PIC selected is not supported or the preprocessor directives are wrong. #endif #endif #endif #endif // initialize my uart recv handling code init_uart_recv(&uc); // initialize the i2c code init_i2c(&ic); // init the timer1 lthread init_timer1_lthread(&t1thread_data); // initialize message queues before enabling any interrupts init_queues(); #ifndef __USE18F26J50 // set direction for PORTB to output LATB = 0x0; TRISB = 0x07; PORTA = 0x0; LATA = 0x0; TRISA = 0x0F; // // PORTE = 0x0; // LATE = 0x0; // TRISE = 0x0F; // // PSPMODE = 0x0; #endif // how to set up PORTA for input (for the V4 board with the PIC2680) /* PORTA = 0x0; // clear the port LATA = 0x0; // clear the output latch ADCON1 = 0x0F; // turn off the A2D function on these pins // Only for 40-pin version of this chip CMCON = 0x07; // turn the comparator off TRISA = 0x0F; // set RA3-RA0 to inputs */ // initialize Timers OpenTimer0(TIMER_INT_ON & T0_8BIT & T0_SOURCE_INT & T0_PS_1_64); #ifdef __USE18F26J50 // MTJ added second argument for OpenTimer1() OpenTimer1(TIMER_INT_ON & T1_SOURCE_FOSC_4 & T1_PS_1_8 & T1_16BIT_RW & T1_OSC1EN_OFF & T1_SYNC_EXT_OFF,0x0); #else #ifdef __USE18F46J50 OpenTimer1(TIMER_INT_ON & T1_SOURCE_FOSC_4 & T1_PS_1_8 & T1_16BIT_RW & T1_OSC1EN_OFF & T1_SYNC_EXT_OFF,0x0); #else OpenTimer1(TIMER_INT_ON & T1_8BIT_RW & T1_PS_1_1 & T1_SOURCE_INT & T1_OSC1EN_OFF & T1_SYNC_EXT_OFF); #endif #endif // Decide on the priority of the enabled peripheral interrupts // 0 is low, 1 is high // ADC interrupt IPR1bits.ADIP = 0; PIE1bits.ADIE = 1; // Timer1 interrupt IPR1bits.TMR1IP = 0; // USART RX interrupt IPR1bits.RCIP = 0; // I2C interrupt IPR1bits.SSPIP = 1; // configure the hardware i2c device as a slave (0x9E -> 0x4F) or (0x9A -> 0x4D) #if 1 // Note that the temperature sensor Address bits (A0, A1, A2) are also the // least significant bits of LATB -- take care when changing them // They *are* changed in the timer interrupt handlers if those timers are // enabled. They are just there to make the lights blink and can be // disabled. i2c_configure_slave(0x9E); #else // If I want to test the temperature sensor from the ARM, I just make // sure this PIC does not have the same address and configure the // temperature sensor address bits and then just stay in an infinite loop i2c_configure_slave(0x9A); #ifdef __USE18F2680 LATBbits.LATB1 = 1; LATBbits.LATB0 = 1; LATBbits.LATB2 = 1; #endif for (;;); #endif // must specifically enable the I2C interrupts PIE1bits.SSPIE = 1; // configure the hardware USART device #ifdef __USE18F26J50 Open1USART(USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_LOW, 0x19); #else #ifdef __USE18F46J50 Open1USART(USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_LOW, 0x19); #else/* OpenUSART(USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_LOW, 0x19); TRISCbits.RC6 = 1; //TX pin set as output TRISCbits.RC7 = 1; //RX pin set as input WriteUSART(0x00); WriteUSART(0x01); WriteUSART(0x02); WriteUSART(0x03);*/ #endif #endif OpenUSART(USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_LOW, 38); TRISCbits.RC6 = 0; //TX pin set as output TRISCbits.RC7 = 1; //RX pin set as input //char data = 0x05; //WriteUSART(data); //while(BusyUSART()); //WriteUSART(data); //WriteUSART(0x05); //WriteUSART(0x05); //putsUSART(0x00); // while(BusyUSART()); // putsUSART(0x05); // while(BusyUSART()); // putsUSART(0x05); // while(BusyUSART()); // putsUSART(0x05); // Peripheral interrupts can have their priority set to high or low // enable high-priority interrupts and low-priority interrupts enable_interrupts(); /* Junk to force an I2C interrupt in the simulator (if you wanted to) PIR1bits.SSPIF = 1; _asm goto 0x08 _endasm; */ // printf() is available, but is not advisable. It goes to the UART pin // on the PIC and then you must hook something up to that to view it. // It is also slow and is blocking, so it will perturb your code's operation // Here is how it looks: printf("Hello\r\n"); OpenADC(ADC_FOSC_16 & ADC_LEFT_JUST & ADC_2_TAD, ADC_CH0 & ADC_INT_OFF & ADC_VREFPLUS_VDD & ADC_VREFMINUS_VSS, 0b1011); SetChanADC(ADC_CH0); // ADC_CALIB(); // loop forever // This loop is responsible for "handing off" messages to the subroutines // that should get them. Although the subroutines are not threads, but // they can be equated with the tasks in your task diagram if you // structure them properly. while (1) { // Call a routine that blocks until either on the incoming // messages queues has a message (this may put the processor into // an idle mode) block_on_To_msgqueues(); // At this point, one or both of the queues has a message. It // makes sense to check the high-priority messages first -- in fact, // you may only want to check the low-priority messages when there // is not a high priority message. That is a design decision and // I haven't done it here. length = ToMainHigh_recvmsg(MSGLEN, &msgtype, (void *) msgbuffer); if (length < 0) { // no message, check the error code to see if it is concern if (length != MSGQUEUE_EMPTY) { // This case be handled by your code. } } else { switch (msgtype) { case MSGT_TIMER0: { timer0_lthread(&t0thread_data, msgtype, length, msgbuffer); break; }; case MSGT_I2C_DATA: case MSGT_I2C_DBG: { // Here is where you could handle debugging, if you wanted // keep track of the first byte received for later use (if desired) last_reg_recvd = msgbuffer[0]; break; }; case MSGT_I2C_RQST: { // Generally, this is *NOT* how I recommend you handle an I2C slave request // I recommend that you handle it completely inside the i2c interrupt handler // by reading the data from a queue (i.e., you would not send a message, as is done // now, from the i2c interrupt handler to main to ask for data). // // The last byte received is the "register" that is trying to be read // The response is dependent on the register. switch (last_reg_recvd) { case 0xaa: { length = 2; ConvertADC(); while( BusyADC()) { //LATBbits.LATB0 = 1; } msgbuffer[0] = ADRESH; msgbuffer[1] = 0xAA; break; } case 0xa8: { length = 1; msgbuffer[0] = 0x3A; break; } case 0xa9: { length = 1; msgbuffer[0] = 0xA3; break; } }; start_i2c_slave_reply(length, msgbuffer); break; }; default: { break; }; }; } // Check the low priority queue length = ToMainLow_recvmsg(MSGLEN, &msgtype, (void *) msgbuffer); if (length < 0) { // no message, check the error code to see if it is concern if (length != MSGQUEUE_EMPTY) { // Your code should handle this situation } } else { switch (msgtype) { case MSGT_TIMER1: { timer1_lthread(&t1thread_data, msgtype, length, msgbuffer); break; }; case MSGT_OVERRUN: case MSGT_UART_DATA: { uart_lthread(&uthread_data, msgtype, length, msgbuffer); break; }; default: { // Your code should handle this error break; }; }; } } }
void main (void) { /* Define Variables --------------------------------------------------------------------- */ // I2C/MSG Q variables char c; // Is this used? signed char length; unsigned char msgtype; unsigned char last_reg_recvd; i2c_comm ic; //unsigned char msgbuffer[MSGLEN+1]; unsigned char msgbuffer[12]; unsigned char i; int I2C_buffer[]; int index = 0; int ITR = 0; int I2C_RX_MSG_COUNT = 0; int I2C_RX_MSG_PRECOUNT = 0; int I2C_TX_MSG_COUNT = 1; // Timer variables timer1_thread_struct t1thread_data; // info for timer1_lthread timer0_thread_struct t0thread_data; // info for timer0_lthread int timer_on = 1; int timer2Count0 = 0, timer2Count1 = 0; // UART variables uart_comm uc; //uart_thread_struct uthread_data; // info for uart_lthread // ADC variables int ADCVALUE = 0; int adc_counter = 0; int adc_chan_num = 0; int adcValue = 0; int count = 0; // MIDI variable char notePlayed; /* Initialization ------------------------------------------------------------------------ */ // Clock initialization OSCCON = 0x7C; // 16 MHz // Use for internal oscillator OSCTUNEbits.PLLEN = 1; // 4x the clock speed in the previous line // UART initialization init_uart_recv(&uc); // initialize my uart recv handling code // configure the hardware USART device Open2USART( USART_TX_INT_OFF & USART_RX_INT_OFF & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_LOW, 31); Open1USART( USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_LOW, 51); //RCSTA1bits.CREN = 1; //RCSTA1bits.SPEN = 1; //TXSTA1bits.SYNC = 0; //PIE1bits.RC1IE = 1; IPR1bits.RC1IP = 0; // I2C/MSG Q initialization init_i2c(&ic); // initialize the i2c code init_queues(); // initialize message queues before enabling any interrupts i2c_configure_slave(0x9E); // configure the hardware i2c device as a slave // Timer initialization init_timer1_lthread(&t1thread_data); // init the timer1 lthread OpenTimer0( TIMER_INT_ON & T0_16BIT & T0_SOURCE_INT & T0_PS_1_8); OpenTimer2( TIMER_INT_ON & T2_PS_1_16 /*& T2_8BIT_RW & T2_SOURCE_INT & T2_OSC1EN_OFF & T2_SYNC_EXT_OFF*/); // Turn Off // ADC initialization // set up PORTA for input PORTA = 0x0; // clear the port LATA = 0x0; // clear the output latch TRISA = 0xFF; // set RA3-RA0 to inputs ANSELA = 0xFF; initADC(); // Interrupt initialization // Peripheral interrupts can have their priority set to high or low // enable high-priority interrupts and low-priority interrupts enable_interrupts(); // Decide on the priority of the enabled peripheral interrupts, 0 is low 1 is high IPR1bits.TMR1IP = 0; // Timer1 interrupt //IPR1bits.RCIP = 0; // USART RX interrupt IPR1bits.SSP1IP = 1; // I2C interrupt PIE1bits.SSP1IE = 1; // must specifically enable the I2C interrupts IPR1bits.ADIP = 1; // ADC interrupt WE ADDED THIS // set direction for PORTB to output TRISB = 0x0; TRISD = 0xFF; LATB = 0x0; ANSELC = 0x00; /* Hand off messages to subroutines ----------------------------------------------------------- */ // This loop is responsible for "handing off" messages to the subroutines // that should get them. Although the subroutines are not threads, but // they can be equated with the tasks in your task diagram if you // structure them properly. while (1) { // Call a routine that blocks until either on the incoming // messages queues has a message (this may put the processor into // an idle mode block_on_To_msgqueues(); /* High Priority MSGQ ---------------------------------------------------------------------- */ // At this point, one or both of the queues has a message. It // makes sense to check the high-priority messages first -- in fact, // you may only want to check the low-priority messages when there // is not a high priority message. That is a design decision and // I haven't done it here. length = ToMainHigh_recvmsg(MSGLEN,&msgtype,(void *) msgbuffer); if (length < 0) { // no message, check the error code to see if it is concern if (length != MSGQUEUE_EMPTY) { //printf("Error: Bad high priority receive, code = %x\r\n", length); } } else { switch (msgtype) { case MSGT_ADC: { // Format I2C msg msgbuffer[6] = (timer2Count0 & 0x00FF); msgbuffer[5] = (timer2Count0 & 0xFF00) >> 8; msgbuffer[4] = (timer2Count1 & 0x00FF); msgbuffer[3] = (timer2Count1 & 0xFF00) >> 8; msgbuffer[8] = 0x00; msgbuffer[10] = adc_chan_num; msgbuffer[11] = 0xaa; // ADC MSG opcode // Send I2C msg FromMainHigh_sendmsg(12, msgtype, msgbuffer); // Send ADC msg to FromMainHigh MQ, which I2C // int hdlr later Reads // Increment I2C message count from 1 to 100 if(I2C_TX_MSG_COUNT < 100) { I2C_TX_MSG_COUNT = I2C_TX_MSG_COUNT + 1; } else { I2C_TX_MSG_COUNT = 1; } // Increment the channel number if(adc_chan_num <= 4) adc_chan_num++; else adc_chan_num = 0; // Set ADC channel based off of channel number if(adc_chan_num == 0) SetChanADC(ADC_CH0); else if(adc_chan_num == 1) SetChanADC(ADC_CH1); else if(adc_chan_num == 2) SetChanADC(ADC_CH2); else if(adc_chan_num == 3) SetChanADC(ADC_CH3); else if(adc_chan_num == 4) SetChanADC(ADC_CH4); else SetChanADC(ADC_CH5); }; case MSGT_TIMER0: { timer0_lthread(&t0thread_data,msgtype,length,msgbuffer); break; }; case MSGT_TIMER2: { timer2Count0++; if(timer2Count0 >= 0xFFFF) { timer2Count1++; timer2Count0 = 0; } break; } case MSGT_I2C_DATA: { //this data still needs to be put in a buffer ; if(msgbuffer[0] == 0xaf) { //FromMainLow_sendmsg(5, msgtype, msgbuffer); // The code below checks message 'counts' to see if any I2C messages were dropped //I2C_RX_MSG_COUNT = msgbuffer[4]; FromMainLow_sendmsg(9, msgtype, msgbuffer); TXSTA2bits.TXEN = 1; /* // Send note data to the MIDI device //while(Busy2USART()); putc2USART(msgbuffer[1]); //while(Busy2USART()); Delay1KTCYx(8); putc2USART(msgbuffer[2]); //while(Busy2USART()); Delay1KTCYx(8); putc2USART(msgbuffer[3]); */ if(I2C_RX_MSG_COUNT - I2C_RX_MSG_PRECOUNT == 1) { if(I2C_RX_MSG_PRECOUNT < 99) { I2C_RX_MSG_PRECOUNT++; } else { I2C_RX_MSG_PRECOUNT = 0; } } else { I2C_RX_MSG_PRECOUNT = I2C_RX_MSG_COUNT; } } }; ` case MSGT_I2C_DBG: { //printf("I2C Interrupt received %x: ",msgtype); for (i=0;i<length;i++) { //printf(" %x",msgbuffer[i]); } //printf("\r\n"); // keep track of the first byte received for later use last_reg_recvd = msgbuffer[0]; break; }; case MSGT_I2C_RQST: { //printf("I2C Slave Req\r\n"); // The last byte received is the "register" that is trying to be read // The response is dependent on the register. switch (last_reg_recvd) { case 0xaa: { break; } /* case 0xa8: { length = 1; msgbuffer[0] = 0x3A; break; } case 0xa9: { length = 1; msgbuffer[0] = 0xA3; break; }*/ }; //start_i2c_slave_reply(length,msgbuffer); break; }; default: { //printf("Error: Unexpected msg in queue, type = %x\r\n", msgtype); break; }; }; } /* Low Priority MSGQ ----------------------------------------------------------------------- */ length = ToMainLow_recvmsg(MSGLEN,&msgtype,(void *) msgbuffer); if (length < 0) { // no message, check the error code to see if it is concern if (length != MSGQUEUE_EMPTY) { } } else { switch (msgtype) { case MSGT_TIMER1: { timer1_lthread(&t1thread_data,msgtype,length,msgbuffer); break; }; case MSGT_OVERRUN: case MSGT_UART_DATA: { LATB = 0xFF; msgbuffer[11] = 0xBB; FromMainHigh_sendmsg(12, msgtype, msgbuffer); break; }; default: { break; }; }; } }
void adc_int_handler(unsigned char *adcbuffer){ // adcbuffer[0] stores the count if(adcbuffer[0] < 30) // increment counter adcbuffer[0] = adcbuffer[0] + 1; else adcbuffer[0] = 0; // ADRESL less significant, but is more accurate than our resolution int voltage = (int)ADRESH; // float voltage = 3.4*k/256; // int roundDist; // if (voltage > .7) { // float dist = 24/(voltage - 0.1); // roundDist = (int)(dist + 0.5); // } // else // roundDist = 0xFF; /* if (adcbuffer[0] == 1){ adcbuffer[3] = roundDist; SetChanADC(ADC_CH1); } else if (adcbuffer[0] == 2){ adcbuffer[1] = roundDist; SetChanADC(ADC_CH2); } else if (adcbuffer[0] == 3){ adcbuffer[2] = roundDist; SetChanADC(ADC_CH3); } */ ////////Low/////////// // > 48 too close for front // 00 is an error code // 1 is too close < 28 cm > 4C for channel 2 > 4C for channel 3 // 3 is too far, ignore for front > 32 cm < 45 for channel 2 < 46 for channel 3 // 2 is correct //////////High//////// // > 5C too close for front // 00 is an error code // 1 is too close < 28 cm > 5D for channel 2 > 5F for channel 3 // 3 is too far, ignore for front > 32 cm < 58 for channel 2 < 59 for channel 3 // 2 is correct // Greater than 4.2 volts for on the ground /////////////////////////////////////////////////////////////////////////// int channel = (int)adcbuffer[0]; int line = (int)adcbuffer[0] % 3; unsigned char output; if (channel == 0) { LATBbits.LATB3 = 0x01; if (voltage < 0x4F) { adcbuffer[4] = 0x01; } else adcbuffer[4] = 0x00; SetChanADC(ADC_CH0); } else if (channel == 1) { if (ADRESH > 0x68) //if (ADRESH > 0x55) output = 0x01; else output = 0x02; if (output != adcbuffer[1]) { if (output == adcbuffer[8]) { adcbuffer[1] = output; adcbuffer[8] = 0xFF; } else adcbuffer[8] = output; } else { adcbuffer[8] = 0xFF; adcbuffer[1] = output; } SetChanADC(ADC_CH10); } else if (channel == 10) { LATBbits.LATB3 = 0x01; if (voltage < 0x4F) { adcbuffer[4] = 0x01; } else adcbuffer[4] = 0x00; SetChanADC(ADC_CH1); } else if (channel == 11) { if (ADRESH - 4 > adcbuffer[2] || ADRESH + 4 < adcbuffer[2]) { if (ADRESH - 2 < adcbuffer[9] && ADRESH + 2 > adcbuffer[9]) { adcbuffer[2] = ADRESH; adcbuffer[9] = 0xFF; } else adcbuffer[9] = ADRESH; } else { adcbuffer[9] = 0xFF; adcbuffer[2] = ADRESH; } SetChanADC(ADC_CH12); } else if (channel == 20) { LATBbits.LATB3 = 0x01; if (voltage < 0x4F) { adcbuffer[4] = 0x01; } else adcbuffer[4] = 0x00; SetChanADC(ADC_CH2); } else if (channel == 21) { if (ADRESH - 4 > adcbuffer[3] || ADRESH + 4 < adcbuffer[3]) { if (ADRESH - 2 < adcbuffer[10] && ADRESH + 2 > adcbuffer[10]) { adcbuffer[3] = ADRESH; adcbuffer[10] = 0xFF; } else adcbuffer[10] = ADRESH; } else { adcbuffer[10] = 0xFF; adcbuffer[3] = ADRESH; } SetChanADC(ADC_CH8); } else { TXREG = voltage; if (line == 0) { LATBbits.LATB3 = 0x01; if (voltage < 0x4F) { adcbuffer[4] = 0x01; } else adcbuffer[4] = 0x00; SetChanADC(ADC_CH8); } else if (line == 1) { LATBbits.LATB4 = 0x01; if (voltage < 0x4F) { adcbuffer[5] = 0x01; } else adcbuffer[5] = 0x00; SetChanADC(ADC_CH10); } else{ LATBbits.LATB5 = 0x01; if (voltage < 0x4F) { adcbuffer[6] = 0x01; } else adcbuffer[6] = 0x00; SetChanADC(ADC_CH12); } } if((adcbuffer[4] == 0x01) && (adcbuffer[5] == 0x01) && (adcbuffer[6] == 0x01)) { adcbuffer[7] = 0x01; } LATBbits.LATB3 = 0x00; LATBbits.LATB4 = 0x00; LATBbits.LATB5 = 0x00; /////////////////////////////////////////////////////////////////////////// /* if (channel == 0) { if (voltage < 3) adcbuffer[4] = 0x01; else adcbuffer[4] = 0x00; SetChanADC(ADC_CH1); } else if (channel == 1) { if (((int)roundDist - 4 > (int)adcbuffer[1]) || ((int)roundDist + 4 < (int)adcbuffer[1])) { if (((int)roundDist - 4 > (int)adcbuffer[8]) || ((int)roundDist + 4 < (int)adcbuffer[8])) { adcbuffer[1] = roundDist; adcbuffer[8] = 0xFF; } else adcbuffer[8] = 0xFF; } else { adcbuffer[8] = 0xFF; adcbuffer[1] = roundDist; } //adcbuffer[1] = roundDist; TXREG = adcbuffer[1]; SetChanADC(ADC_CH6); } else if (channel == 10) { if (voltage < 3) adcbuffer[4] = 0x01; else adcbuffer[4] = 0x00; SetChanADC(ADC_CH2); } else if (channel == 11) { if (((int)roundDist - 4 > (int)adcbuffer[2]) || ((int)roundDist + 4 < (int)adcbuffer[2])) { if (((int)roundDist - 4 > (int)adcbuffer[9]) || ((int)roundDist + 4 < (int)adcbuffer[9])) { adcbuffer[2] = roundDist; adcbuffer[9] = 0xFF; } else adcbuffer[9] = 0xFF; } else { adcbuffer[9] = 0xFF; adcbuffer[2] = roundDist; } //adcbuffer[2] = roundDist; SetChanADC(ADC_CH7); } else if (channel == 20) { if (voltage < 3) adcbuffer[4] = 0x01; else adcbuffer[4] = 0x00; SetChanADC(ADC_CH3); } else if (channel == 21) { if (((int)roundDist - 4 > (int)adcbuffer[1]) || ((int)roundDist + 4 < (int)adcbuffer[1])) { if (((int)roundDist - 4 > (int)adcbuffer[8]) || ((int)roundDist + 4 (int)adcbuffer[8])) { adcbuffer[3] = roundDist; adcbuffer[10] = 0xFF; } else adcbuffer[10] = 0xFF; } else { adcbuffer[10] = 0xFF; adcbuffer[3] = roundDist; } //adcbuffer[3] = roundDist; SetChanADC(ADC_CH5); } else { if (line == 0) { if (voltage < 3) adcbuffer[4] = 0x01; else adcbuffer[4] = 0x00; SetChanADC(ADC_CH5); } else if (line == 1) { if (voltage < 3) adcbuffer[5] = 0x01; else adcbuffer[5] = 0x00; SetChanADC(ADC_CH6); } else{ if (voltage < 3) adcbuffer[6] = 0x01; else adcbuffer[6] = 0x00; SetChanADC(ADC_CH7); } }*/ }