struct slidepos_t getSlidePosition(uint8_t number)//returns the slider position
{
struct slidepos_t r;
if(number==1)//if number is 1 we read the first slider
{
r.x=ADC_read(L_SLIDER);
}
else//we read the second one
{
r.x=ADC_read(R_SLIDER);
}
return r;
}
void AMV_getProxSensors(uint16_t* left, uint16_t* middle, uint16_t* right){
//Set external multiplexer and read ADC
AMV_setExtMux(FRONT,LEFT);
*left = ADC_read(ID_ADC_DISTANCE);
//Set external multiplexer and read ADC
AMV_setExtMux(REAR,LEFT);
*middle = ADC_read(ID_ADC_DISTANCE);
//Set external multiplexer and read ADC
AMV_setExtMux(FRONT,RIGHT);
*right = ADC_read(ID_ADC_DISTANCE);
}
slider_position JOY_getSliderPosition(void) {
slider_position position;
uint8_t l, r;
//Read left slider from channel 2
l = ADC_read(2);
//Read right slider from channel 3
r = ADC_read(3);
//Calculate position percentage
position.left = 100 * l / 0xFF;
position.right = 100 * r / 0xFF;
return position;
}
void Main()
{
double accele_x_bias = 0.0, accele_y_bias = 0.0;
double jyro_x_bias = 0.0, jyro_y_bias = 0.0;
double accele_x = 0.0, accele_y = 0.0, accele_z = 0.0;
double jyro_x = 0.0, jyro_y = 0.0;
double theta_x = 0.0, theta_y = 0.0;
double roll = 0.0, pitch = 0.0;
int i = 0;
SetUp();
for(i = 0; i < 100; i ++){
accele_x_bias += ADC_Read(ANAROG_PIN_ACCELE_X);
accele_y_bias += ADC_Read(ANAROG_PIN_ACCELE_Y);
jyro_x_bias += ADC_Read(ANAROG_PIN_JYRO_X);
jyro_y_bias += ADC_Read(ANAROG_PIN_JYRO_Y);
}
accele_x_bias /= 100.0;
accele_y_bias /= 100.0;
jyro_x_bias /= 100.0;
jyro_y_bias /= 100.0;
while(1){
TMR0 = 0;
accele_x = (ADC_read(ANAROG_PIN_ACCELE_X) - accele_x_bias) * ACCELE_COEFFICIENT;
accele_y = (ADC_read(ANAROG_PIN_ACCELE_Y) - accele_y_bias) * ACCELE_COEFFICIENT;
accele_z = (ADC_read(ANAROG_PIN_ACCELE_Z) - ACCELE_Z_BIAS) * ACCELE_COEFFICIENT;
jyro_x = (ADC_read(ANAROG_PIN_JYRO_X) - jyro_x_bias) * JYRO_COEFFICIENT;
jyro_y = (ADC_read(ANAROG_PIN_JYRO_Y) - jyro_y_bias) * JYRO_COEFFICIENT;
theta_x = atan(accele_x / sqrt(accele_y * accele_y + accele_z * accele_z)) * (180.0 / PI);
theta_y = atan(accele_y / sqrt(accele_x * accele_x + accele_z * accele_z)) * (180.0 / PI);
roll += (jyro_x * DT) - (W * roll * DT) + (W * theta_x * DT); //相補フィルタ
pitch += (jyro_y * DT) - (W * pitch * DT) + (W * theta_y * DT);
if(-0.15 < roll && roll < 0.15)
roll = 0.0;
if(-0.15 < pitch && pitch < 0.15)
pitch = 0.0;
#if DEBUG_MODE
#if ACCELE_CHECK_MODE
accele_x = ADC_read(ANAROG_PIN_ACCELE_X);
accele_y = ADC_read(ANAROG_PIN_ACCELE_Y);
accele_z = ADC_read(ANAROG_PIN_ACCELE_Z);
AcceleCheck(accele_x, accele_y, accele_z);
#else
Debug(roll, pitch);
#endif
#else
OutPut(pitch - roll, pitch + roll); //right, left
#endif
}
}
static void append_watchpoint_event(unsigned index)
{
if (watchpoint_events_count[watchpoint_events_buf_idx] <
param_num_watchpoint_events_buffered) {
watchpoint_event_t *watchpoint_event =
&watchpoint_events_buf[watchpoint_events_count[watchpoint_events_buf_idx]++];
watchpoint_event->timestamp = SYSTICK_CURRENT_TIME;
watchpoint_event->index = index;
if (watchpoints_vcap_snapshot & (1 << index))
watchpoint_event->vcap = ADC_read(ADC_CHAN_INDEX_VCAP);
else // TODO: don't stream vcap at all if snapshot is not enabled
watchpoint_event->vcap = 0;
}
if (watchpoint_events_count[watchpoint_events_buf_idx] ==
param_num_watchpoint_events_buffered) {// buffer full
if (!(main_loop_flags & FLAG_WATCHPOINT_READY)) { // the other buffer is free
swap_buffers();
// clear error indicator
GPIO(PORT_LED, OUT) &= ~BIT(PIN_LED_RED);
} else { // both buffers are full
// indicate error on LED
GPIO(PORT_LED, OUT) |= BIT(PIN_LED_RED);
// drop the watchpoints on the floor
}
} else {
// clear error indicator
GPIO(PORT_LED, OUT) &= ~BIT(PIN_LED_RED);
}
}
void zero_amploc(void) // set zero current setpoint from ADC reading from a10_x a10_z a10_y, write to EEPROM
{
static uint8_t z;
adc_cal[11] = adc_cal[12] = adc_cal[13] = adc_cal[14] = ADC_NULL; // reset offsets to zero (ADC_NULL)
// read adc data for zero setpoint
ADC_read(); // a10_x=adc_[11], a10_z=adc_cal[12], a10_y=adc_cal[13]
adc_cal[11] = (uint8_t) (ADC_NULL + (int) ((int) a10_x - (int) AMP10_ZERO));
adc_cal[12] = (uint8_t) (ADC_NULL + (int) ((int) a10_z - (int) AMP10_ZERO));
adc_cal[13] = (uint8_t) (ADC_NULL + (int) ((int) a10_y - (int) AMP10_ZERO));
if (checktime_eep(EEP_UPDATE, FALSE)) {
term_time();
putrs2USART(zero0);
sprintf(bootstr2, "\n\r Zero offset %i, X current %i, AMP10_ZERO %i", (int) adc_cal[11], a10_x, AMP10_ZERO);
puts2USART(bootstr2);
sprintf(bootstr2, "\n\r Zero offset %i, Y current %i, AMP10_ZERO %i", (int) adc_cal[12], a10_z, AMP10_ZERO);
puts2USART(bootstr2);
sprintf(bootstr2, "\n\r Zero offset %i, Z current %i, AMP10_ZERO %i", (int) adc_cal[13], a10_y, AMP10_ZERO);
puts2USART(bootstr2);
write_data_eeprom(adc_cal[z], ADC_SLOTS, z, 8);
checktime_eep(EEP_UPDATE, TRUE);
putrs2USART(zero1);
}
}
static int ADC_input_lua(lua_State *L)
{
int const ADC_masks[32] =
{0,0,0,0,AD0_6, AD0_7, AD1_0, 0, AD1_1, 0, AD1_2, 0, AD1_3, AD1_4, 0, AD1_5, 0,
0,0,0,0,AD1_6, AD1_7, 0, 0,AD0_4, 0,0,AD0_1, AD0_2, AD0_3,0};
int port=lua_tonumber(L,1);
int pin =lua_tonumber(L,2);
int adc_mask=0;
double fval;
if ((port==0) && (pin>=0) && (pin<=31)) adc_mask = ADC_masks[pin];
if (ADC_check_port_pin(L,port,pin,adc_mask))
{
ADC_init(adc_mask);
fval = ADC_read(adc_mask);
fval = fval / 1023.0f;
}
else
{
fval = -1;
}
lua_pushnumber(L,fval);
return 1;
}
int main(void){
uint16_t v0,v1,v2;
double t0,t1,t2;
char t_chr[7];
memset(t_chr, '\0', sizeof(t_chr));
USART_init(MYUBRR);
/* Remove garbage from serial terminal */
USART_transmit('\r');
ADC_init();
PWM_init();
while(1){
v0 = ADC_read(0); /* read from ADC0 */
v1 = ADC_read(1); /* read from ADC0 */
v2 = ADC_read(2); /* read from ADC0 */
t0 = v0 / 4;
t1 = v1 / 4;
t2 = v2 / 4;
dtostrf(t0, 5, 1, t_chr);
USART_write("0: ");
USART_write(t_chr);
USART_write("\r\n");
dtostrf(t1, 5, 1, t_chr);
USART_write("1: ");
USART_write(t_chr);
USART_write("\r\n");
dtostrf(t2, 5, 1, t_chr);
USART_write("2: ");
USART_write(t_chr);
USART_write("\r\n");
OCR0A = t0;
OCR0B = t1;
OCR2A = t2;
_delay_ms(500);
}
return 1;
}
void main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop WDT
P1DIR|=0x41; // Declare P1.0 as output
P1REN |= BIT3;
P1OUT |= BIT3;
Uart_init();
while(1)
{
if(k%2==1)
{
ADC_init();
a=ADC_read();
ADC_send(a);
}
if(P1IN & 0x08)
{
P1OUT&=~0x01; //Turn-off LED on P1.0
flag=0;
}
else
{
if(flag==0)
{
flag=1;
P1OUT|=0x41;//Turn-on LED on P1.0
k++;
if(k%2==1)
{
ADC_init();
a=ADC_read();
}
if(k%2==0)
{
P1OUT&=~0x40;
}
}
}
}
}
uint32 SENSOR_read(uint8 a_chNum)
{
uint32 temp;
temp= ADC_read(a_chNum); /* Read channel zero where the temp sensor is connect */
temp = (temp*150*5)/(1023*1.5);
return temp;
}
unsigned int USB_check(void){
unsigned int vadc,vret;
vadc=ADC_read(ADC_USB);
if(vadc>=MIN_USB){vret=1;}
else{vret=0;}
return vret;
}
unsigned int LED_check(void){
unsigned int vadc,vret;
vadc=ADC_read(ADC_LED);
if(vadc>=MIN_LED){vret=1;}
else{vret=0;}
return vret;
}
unsigned int PV_check(void){
unsigned int vadc,vret;
vadc=ADC_read(ADC_PV);
if(vadc>=MIN_PV){vret=1;}
else{vret=0;}
return vret;
}
void accel_init(uint8_t pin_x, uint8_t pin_y, uint8_t pin_z,
uint16_t * avg_x, uint16_t * avg_y, uint16_t * avg_z) {
uint8_t i;
uint16_t temp;
for (i = 0; i < 50; i++) {
temp = ADC_read(pin_x);
*avg_x = (*avg_x * (i) + temp) / (i + 1);
temp = ADC_read(pin_y);
*avg_y = (*avg_y * (i) + temp) / (i + 1);
temp = ADC_read(pin_z);
*avg_z = (*avg_z * (i) + temp) / (i + 1);
_delay_ms(50);
}
}
int main(void) {
uint16_t reading = 0;
ADC_init();
while(1) {
_delay_us(1);
reading = ADC_read(ADC0D);
}
}
int main(void) {
int s1, s2, s3, s4;
uart_init();
stdout = &uart_stream;
stdin = &uart_stream;
while (1) {
_delay_ms(2000);
ADC_init(4); s1 = ADC_read();
ADC_init(5); s2 = ADC_read();
ADC_init(6); s3 = ADC_read();
ADC_init(7); s4 = ADC_read();
printf("Read: %3d %3d %3d %3d\r\n", s1, s2, s3, s4);
}
}
void setDelay()
{
unsigned int num;
while (1)
{
num = ADC_read(0, 10, true);
delay = num >> 5;
x_yield();
}
}
void setBiasVoltage(){
float temperature;
uint16_t biasVoltage_5mV; // bias voltage in 5mV steps
uint16_t DACcounts;
// get the temperature and calculate the voltage
temperature = getTemperature( ADC_read() );
biasVoltage_5mV = calcAdjustedBiasVoltage(temperature);
// calculate dac counts
DACcounts = (uint16_t) ( (biasVoltage_5mV*5. - DACOffA)/DACGainA );
// apply changes to PWM register
OCR1A = DACcounts;
return;
}
void ADC_init()
{
int dummy = 0;
ADMUX = 1;
// set ADC prescaler to , 1MHz / 8 = 125kHz
ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0);
// Take a dummy reading , which basically allows the ADC
// to hack up any hairballs before we take any real readings
dummy = ADC_read();
}
unsigned int BATT_check(void){
unsigned int vadc,vret;
vadc=ADC_read(ADC_BATT);
if(vadc<=BATT_1){vret=1;}
else if((vadc>BATT_1) && (vadc<=BATT_2)){vret=2;}
else if((vadc>BATT_2) && (vadc<=BATT_3)){vret=3;}
else if((vadc>BATT_3) && (vadc<=BATT_4)){vret=4;}
else if((vadc>BATT_4) && (vadc<=BATT_5)){vret=5;}
else if(vadc>BATT_5){vret=6;}
return vret;
}
uint8 main (void){
uint16 result=0, temp=0;
LCD_init();
ADC_init();
LCD_Display_String_Row_Col(0,3,"Temp=");
while (1){
result = ADC_read(3);
temp = (150*result*5)/(1.5*1023);
LCD_go_To_ROW_Col(0 ,8);
LCD_intger_TO_String(temp );
}
return (0);
}
void mcu_main()
{
int value;
while(1)
{
value = ADC_read();
len = mcu_snprintf(buf, 32,"%d\n",value);
host_send((unsigned char*)buf, len);
//This will prevent the atom from freezing
mcu_sleep(1);
}
}
//***********************************************************
unsigned int RtcVoltRd(void)
{
unsigned int i, Voltage_Value;
ADCON1=0x17;
ADCON2=0x90;
Delay_ml(5);
for(i=0;i<5;i++)
{
Voltage_Value=ADC_read(4);
Delay_ml(7);
}
ADCON0=0x0;
ADCON1=0x0F;
return (Voltage_Value/40);
}//RtcVoltRd
void convert(void)
{
result=ADC_read();//(5);
if(result > compare) // Compare the converted result with 0.5 V
{
TTL_PORT|=_BV(TTL_UL);//TTL on
// LED_PORT|=_BV(LED_BR);//LED on
}
else
{
TTL_PORT&=~_BV(TTL_UL);//TTL off
// LED_PORT&=~_BV(LED_BR);//LED off
}
}//convert
// main function; program starts here
void main(void)
{
unsigned char data = 0;
unsigned int battery_voltage = 0; // ADC reading of battery voltage
ports_initialize(); // set up ports
ADC_initialize(); // configure ADC
SPI_initialize(); // set up SPI module
sleep_initialize(); // set up sleep mode
ISR_initialize(); // set up ISR
while(1)
{
SLEEP(); // sleep PIC until WDT expires
time++; // increment time (+16s)
battery_voltage = ADC_read(0x09); // read battery voltage
if ( time >= 1 ) // 1*16s=16s
{
time = 0; // reset time
if(battery_voltage >= 690) //690 = 11v
{
LATCbits.LATC4 = 1; // turn relay on
SPI_enable(); // turn on SPI module
while( data != 0xDA ) // wait for shutdown command to be received
{
while(!SSP1STATbits.BF) // wait till data is in the buffer
{
CLRWDT();
}
data = SSP1BUF; // read data outside
}
data = 0x00;
SPI_disable(); // turn off SPI module
__delay_ms(10000); // wait for R Pi to shutdown
LATCbits.LATC4 = 0; // turn relay off
}
}
}
}
//***********************************************************
int TempRd(void)
{
unsigned int i, Temp_Value;
ADCON1=0x17;
ADCON2=0x90;
CMCON=0x07;
Delay_ml(5);
for(i=0;i<5;i++)
{
Temp_Value=ADC_read(7);
Delay_ml(7);
}
ADCON0=0x0;
ADCON1=0x0F;
return (((Temp_Value-41)/4)-50);
}//TempRd
uint8_t handle_fire(){
static uint16_t timer = 0; // for holdoff
static uint16_t counter = 0; // for power
uint16_t a;
a=ADC_read();
if (a > config.fire_cheating){
cheat();
}
if (a > config.fire_threshold && a < config.fire_cheating)
{
while(!my_random_number){
my_random_number = TMR0;
}
if(timer < config.fire_holdoff)
{
timer ++;
}
else
{
if(!config.power || counter <= config.power)
{
if(!counter)
{
green_led_on();
play_song((uint16_t*)fire_song,sizeof(fire_song)/sizeof(uint16_t),3000,!(config.power));
}
Send_Byte(config.id);
counter++;
}
else
{
led_off();
}
}
}
else
{
led_off();
if(!config.power && counter) stop_song();
timer = 0;
counter = 0;
return 0;
}
return 1;
}
void adc_conv_test(int64_t delay){
char buf[50];
uint16_t adcvalue=ADC_read(3);
double Rb=100.0;
double Rt=1000.0;
double Uref=1.1972;
double Bits=65535;
float convert=((Rb+Rt)*Uref)/(Rb*Bits);
float voltage;
voltage=convert*adcvalue;
global_adc_voltage=voltage;
//sprintf(buf,"ADC: %f",1.234);
//mcu_tracer_msg(buf);
uint16_t grid_adc=ADC1_read(7);
convert=(4000*Uref)/(5.5*Bits);
global_adc_grid=(grid_adc-32768)*convert;
Rb=2.2;
Rt=2000;
convert=((Rb+Rt)*Uref)/(Rb*Bits);
float dclink=convert*ADC1_read(4);
global_adc_dclink=dclink;
//if(CMP1_SCR & CMP_SCR_COUT_MASK){
if(CMP0->SCR & CMP_SCR_COUT_MASK){
global_overcurrent=1;
}else{
global_overcurrent=0;
}
if(global_clear_error){
FTM_clear_error();
global_clear_error=0;
}
//SI8900_manual_req(0);
global_Si8900_var=SI8900_get_ch(2);
_taskcall_task_register_time(&task_adc_conv_test,(120000000/29));
}
int main(void)
{
float value;
float temp;
DDRB=0xFF;
ADC_init(); // Initialization of ADC
while(1)
{
value=ADC_read(0);
temp=(value/1023)*5*100;
if(temp>30 && temp<33)
{PORTB=0x00;
}
else
{PORTB=0x01;
}
}
}
// ------------------------------------------------
int main(void)
{
uint16_t value;
DDRB=0xFF;
ADC_init(); // Initialization of ADC
while(1)
{
value=ADC_read(0);
PORTB|=1<<motor;
if(value<1)
value=0;
for (int i=0;i<value;i++)
_delay_us(1);
PORTB&=~(1<<motor);
for(int i=0;i<1023-value;i++)
_delay_us(1);
}
}
