Computer Science Canada Can anyone confirm this language? |
| Author: | cubera [ Sun Apr 29, 2012 11:47 pm ] |
| Post subject: | Can anyone confirm this language? |
I'm new to programming but i have experience with java and turing and im planning to learn either C, C++, C# next. However i have question regarding a source code i found from a project from inscrutables about a led coffee table, i just cant tell what language it is. To me it looks like C#, maybe C? im not sure so i need some help from an expert or perhaps someone who has experience with these programming languages to verify the language this person has used. Also im sorry if this is the wrong section. Heres the code: /*** PIN ASSIGNMENTS ON ATMEGA48 PC6 (PCINT14/RESET) PC5 (ADC5/SCL/PCINT13) // I2C Clock input PC4 (ADC4/SDA/PCINT12) // I2C Data input PC3 (ADC3/PCINT11) //Sensor 4 IR Receiver PC2 (ADC2/PCINT10) //Sensor 3 IR Receiver PC1 (ADC1/PCINT9) //Sensor 2 IR Receiver PC0 (ADC0/PCINT8) //Sensor 1 IR Receiver PB7 (PCINT7/XTAL2/TOSC2) //IR 4 Trigger PB6 (PCINT6/XTAL1/TOSC1) //IR 3 Trigger PB5 (SCK/PCINT5) //IR 2 Trigger PB4 (MISO/PCINT4) //IR 1 Trigger PB3 (MOSI/OC2A/PCINT3) //PWM 3 PB2 (SS/OC1B/PCINT2) PB1 (OC1A/PCINT1) PB0 (PCINT0/CLKO/ICP1) PD0 (PCINT16/RXD) PD1 (PCINT17/TXD) PD2 (PCINT18/INT0) PD3 (PCINT19/OC2B/INT1) //PWM 4 PD4 (PCINT20/XCK/T0) PD5 (PCINT21/OC0B/T1) //PWM 2 PD6 (PCINT22/OC0A/AIN0) //PWM 1 PD7 (PCINT23/AIN1) ***/ #define IR_1_ON PORTB |= (1<<4) #define IR_2_ON PORTB |= (1<<5) #define IR_3_ON PORTB |= (1<<6) #define IR_4_ON PORTB |= (1<<7) #define IR_1_OFF PORTB &= ~(1<<4) #define IR_2_OFF PORTB &= ~(1<<5) #define IR_3_OFF PORTB &= ~(1<<6) #define IR_4_OFF PORTB &= ~(1<<7) #define PWM1 6 //PORTD PWM pin assignments #define PWM2 5 //PORTD #define PWM3 3 //PORTB #define PWM4 3 //PORTD #define F_CPU 8000000UL #include #include #include //#include /****Function Declarations****/ int ADC_read(void); void A2D_Channel_Select(unsigned char channel); void Init_ADC(void); void Init_Timer0(void); void Init_Timer1(void); void Init_Timer2(void); void Delay(void); void Calibrate_Sensors(void); //void Init_I2C_Slave_Rx(void); All, but one, of these variables is declared volatile because basically all of the work is done in interrupt service routines /****Global Variable Declarations****/ volatile char Sensor_Values_Updated = 0; volatile char Timer1_Overflow = 0; volatile unsigned char channel = 0; volatile int Amb_Sensor_1 = 0, Amb_Sensor_2 = 0, Amb_Sensor_3 = 0, Amb_Sensor_4 = 0; volatile int Sensor_1 = 0, Sensor_2 = 0, Sensor_3 = 0, Sensor_4 = 0; volatile int Initial_1 = 0, Initial_2 = 0, Initial_3 = 0, Initial_4 = 0; volatile int New_PWM1 = 0, New_PWM2 = 0, New_PWM3 = 0, New_PWM4 = 0; volatile int Old_PWM1 = 0, Old_PWM2 = 0, Old_PWM3 = 0, Old_PWM4 = 0; unsigned char buffer = 8; int main(void) { DDRB = 0xff; //make sure IR emitters are turned off, and PWM 3 PORTB &= ~((1 << 7)|(1 << 6)|(1 << 5)|(1 << 4)|(1 << 3)); DDRC = 0x00; //make PORT C inputs DDRD = 0xff; PORTD = 0x00; //set all of PORT D low. ensures Init_ADC(); sei(); Calibrate_Sensors(); PORTD |= (1 << PWM1); //blink to indicate end of Calibration _delay_ms(600); PORTD &= ~(1 << PWM1); Init_Timer0(); Init_Timer2(); //Init_I2C_Slave_Rx(); while(1) { //do something? //. . . } } With the clock running at roughly 8MHz, and Timer 1 counting up to 65535. The timer will overflow roughly 122 times a second. This ISR will fire and the timer overflow variable will increment, and then the SWITCH/CASE function will choose the next pixel to test ISR(TIMER1_OVF_vect) { Timer1_Overflow++; //increment timer overflow variable switch(Timer1_Overflow) { case 1: A2D_Channel_Select(0); //select ADC channel 0 Amb_Sensor_1 = ADC_read(); //take ambient IR sensor reading IR_1_ON; //turn on IR 1 LED, PORTB |= (1<<4) Delay(); //delay for the IR receiver to settle Sensor_1 = ADC_read(); //take active ADC reading of IR receiver IR_1_OFF; //turn off IR 1 LED New_PWM1 = (Sensor_1 - Amb_Sensor_1) - Initial_1; //condition readings if(New_PWM1 <= 0) { New_PWM1 = 0; } //prevent negative numbers simple low-pass filter, (87.5% * Old) + (12.5% * New). It just takes the old value and weights it more than the older value. Has the same effect of slowing down change, which is crucial in providing fluid changes in brightness New_PWM1 = ((7*Old_PWM1)>>3) + (New_PWM1>>3); if(OCR0A >= 1) {DDRD |= (1 << PWM1);} else { DDRD &= ~(1 << PWM1); } //turn off LEDs completely //artificially increase the value of sensor reading, not entirely necessary, but makes the sensor seem more sensitive by being brighter sooner New_PWM1 <<= 2; if(New_PWM1 > 255) { New_PWM1 = 255; } OCR0A = New_PWM1; New_PWM1 >>= 2; The below code that is entirely commented out is a different brightness algorithm. It is a triggering algorithm that will fade the LEDs on when something comes within a threshold. And the LEDs will fade out slowly when the object is out of the threshold distance. This is useful because the operation could be more reliable and the fade out time can be adjusted to be very long or however long you want it. I haven't tested this code so I am not sure if it will work 100% /***** //Trigger sequence if(New_PWM1 > Initial_1) { DDRD |= (1 << PWM1); if(OCR0A < 255) { OCR0A += (255 - OCR0A)>>2 ; //OCR0A++; } if (New_PWM1 < (Initial_1 + 8)) { Initial_1 = ((7*Initial_1)>>3) + (New_PWM1>>3); } } else if(New_PWM1 < Initial_1) { if(OCR0A > 0) { OCR0A -= (OCR0A >> 4)+1; //OCR0A--; } else if(OCR0A <= 0) { DDRD &= ~(1 << PWM1); } } *****/ Old_PWM1 = New_PWM1; break; case 2: A2D_Channel_Select(1); //select ADC channel 1 Amb_Sensor_2 = ADC_read(); IR_2_ON; //turn on IR 2 LED, PORTB |= (1<<5) Delay(); //delay for the IR receiver to settle Sensor_2 = ADC_read(); //take ADC reading IR_2_OFF; //turn off IR 2 LED New_PWM2 = (Sensor_2 - Amb_Sensor_2) - Initial_2; if(New_PWM2 < 0) { New_PWM2 = 0; } New_PWM2 = ((7*Old_PWM2)>>3) + (New_PWM2>>3); if(OCR0B >= 1) {DDRD |= (1 << PWM2);} else { DDRD &= ~(1 << PWM2); } New_PWM2 <<= 2; if(New_PWM2 > 255) { New_PWM2 = 255; } OCR0B = New_PWM2; New_PWM2 >>= 2; /* if(New_PWM2 > Initial_2) { DDRD |= (1 << PWM2); if(OCR0B < 255) { OCR0B += (255 - OCR0B)>>2 ; //OCR0B++; } if (New_PWM2 < (Initial_2 + 8)) { Initial_2 = ((7*Initial_2)>>3) + (New_PWM2>>3); } } else if(New_PWM2 < Initial_2) { if(OCR0B > 0) { OCR0B -= (OCR0B >> 4)+1; //OCR0B--; } else if(OCR0B <= 0) { DDRD &= ~(1 << PWM2); } } */ Old_PWM2 = New_PWM2; break; case 3: A2D_Channel_Select(2); //select ADC channel 2 Amb_Sensor_3 = ADC_read(); IR_3_ON; //turn on IR 3 LED, PORTB |= (1<<6) Delay(); //delay for the IR receiver to settle Sensor_3 = ADC_read(); //take ADC reading IR_3_OFF; //turn off IR 3 LED New_PWM3 = (Sensor_3 - Amb_Sensor_3) - Initial_3; if(New_PWM3 < 0) { New_PWM3 = 0; } New_PWM3 = ((7*Old_PWM3)>>3) + (New_PWM3>>3); if(OCR2A >= 1) {DDRB |= (1 << PWM3);} else { DDRB &= ~(1 << PWM3); } New_PWM3 <<= 2; if(New_PWM3 > 255) { New_PWM3 = 255; } OCR2A = New_PWM3; New_PWM3 >>= 2; /* if(New_PWM3 > Initial_3) { DDRB |= (1 << PWM3); if(OCR2A < 255) { OCR2A += (255 - OCR2A)>>2 ; //OCR2A++; } if (New_PWM3 < (Initial_3 + 8)) { Initial_3 = ((7*Initial_3)>>3) + (New_PWM3>>3); } } else if(New_PWM3 < Initial_3) { if(OCR2A > 0) { OCR2A -= (OCR2A >> 4)+1; //OCR2A--; } else if(OCR2A <= 0) { DDRB &= ~(1 << PWM3); } } */ Old_PWM3 = New_PWM3; break; case 4: A2D_Channel_Select(3); //select ADC channel 3 Amb_Sensor_4 = ADC_read(); IR_4_ON; //turn on IR 4 LED, PORTB |= (1<<7) Delay(); //delay for the IR receiver to settle Sensor_4 = ADC_read(); //take ADC reading IR_4_OFF; //turn off IR 4 LED New_PWM4 = (Sensor_4 - Amb_Sensor_4) - Initial_4; if(New_PWM4 < 0) { New_PWM4 = 0; } New_PWM4 = ((7*Old_PWM4)>>3) + (New_PWM4>>3); if(OCR2B >= 1) {DDRD |= (1 << PWM4);} else { DDRD &= ~(1 << PWM4); } New_PWM4 <<= 2; if(New_PWM4 > 255) { New_PWM4 = 255; } OCR2B = New_PWM4; New_PWM4 >>= 2; /* if(New_PWM4 > Initial_4) { DDRD |= (1 << PWM4); if(OCR2B < 255) { OCR2B += (255 - OCR2B)>>2 ; //OCR2B++; } if (New_PWM4 < (Initial_4 + 8)) { Initial_4 = ((7*Initial_4)>>3) + (New_PWM4>>3); } } else if(New_PWM1 < Initial_4) { if(OCR2B > 0) { OCR2B -= (OCR2B >> 4)+1; //OCR2B--; } else if(OCR2B <= 0) { DDRD &= ~(1 << PWM4); } } */ Old_PWM4 = New_PWM4; Timer1_Overflow = 0; //reset Sensor_Values_Updated = 1; //new values ready break; }//end switch }//end ISR This is something I am going to try and figure out later. It is untested elementary code which could allow me to use the Two Wire Interface (I2C) so several controllers and communicate with each other or have one master and a bunch of slaves. /**** ISR(TWI_vect) //to include later when I get this figured out { switch(TWSR) { case TW_SR_SLA_ACK: //0x60 //Own address Rx Byte_Number == 1; break; case TW_SR_DATA_ACK: // 0x80 , data in TWDR switch(Byte_Number) { case 1: Reg_Addr = TWDR; Byte_Number++; break; case 2: Reg_Val = TWDR; Byte_Number = 0; //reset, unless more bytes are coming break; case Max_Bytes_Expected: Reg_Val = TWDR; Byte_Number = 0; //reset, unless more bytes are coming break; } break; case TW_SR_GCALL_DATA_ACK: // 0x90 if(Byte_Number == 1) { Reg_Addr = TWDR; Byte_Number++; } else if(Byte_Number == 2) { Reg_Val = TWDR; Byte_Number = 0; //reset, unless more bytes are coming } break; }//end switch }//end ISR void Init_I2C_Slave_Rx(void) { //Set Device Address in TWAR TWAR = 10; //maybe make this as an argument to this function TWCR |= ((1 << TWEA)|(1 << TWEN)); TWCR &= ~((1 << TWSTA)|(1 << TWSTO)); } ****/ void Calibrate_Sensors(void) //establish initial ambient sensor values { char q = 0; Init_Timer1(); for(q=0; q<32; q++) //should take one second-ish { //wait for Sensor cycle to be done, then gather sensors values while(Sensor_Values_Updated == 0) {} Initial_1 += (Sensor_1 - Amb_Sensor_1); //initial difference Initial_2 += (Sensor_2 - Amb_Sensor_2); Initial_3 += (Sensor_3 - Amb_Sensor_3); Initial_4 += (Sensor_4 - Amb_Sensor_4); Sensor_Values_Updated = 0; //reset }//end for //condition Initial Ambient Sensor values, plus a buffer Initial_1 = (Initial_1 >> 5) + buffer; Initial_2 = (Initial_2 >> 5) + buffer; Initial_3 = (Initial_3 >> 5) + buffer; Initial_4 = (Initial_4 >> 5) + buffer; } void Init_ADC(void) { ADMUX |= 1 << REFS0; //AVCC with external capacitor at AREF pin ADMUX |= (1< } void Init_Timer0(void) //PWM for sensors 1 & 2 { //Fast PWM, non-inverting, WGM02-WGM00 == 011, no overflow interrupt TCCR0A |= ((1 << COM0A1)|(1 << COM0B1)|(1 << WGM01)|(1 << WGM00)); TCCR0B |= (1 << CS00); //start clock, no prescale } void Init_Timer1(void) { //no PWM, enable overflow interrupt, //TOP == 0xFFFF == 65536 cycles == roughly 122 overflow interrupts/sec TCCR1B |= (1 << CS10); TIMSK1 |= (1 << TOIE1); } void Init_Timer2(void) //PWM for sensors 3 & 4 { //Fast PWM, non-inverting, WGM22-WGM20 == 011, no overflow interrupt TCCR2A |= ((1 << COM2A1)|(1 << COM2B1)|(1 << WGM21)|(1 << WGM20)); TCCR2B |= (1 << CS20); //start clock, no prescale } int ADC_read(void) /***select ADC channel prior to calling this function***/ { int ADC_value = 0; int ADCsample; char i; ADCSRA |= (1< ADCSRA |= (1< while ((ADCSRA & ADSC)); //Wait for conversion to complete, and forget about it //this is done no more than 64 times, any longer and ADC1_value will need to be larger than an unsigned int!!!!!! for (i=0; i<64; i++) { ADCSRA |= (1< while ((ADCSRA & ADSC)); //wait for conversion to finish //change back to ADCL for 10 bit precision, and remove left-shift bit setting ADCsample = ADCH; //ADCsample += (ADCH<<8); //Left shift the top two bits 8 places ADC_value += ADCsample; //add ADCsample to ADC_sensor } //average sample by right shifting 6 places, same as dividing by 64 ADC_value = (ADC_value >> 6); return ADC_value; ADCSRA &= ~(1< void A2D_Channel_Select(unsigned char channel) { switch (channel) { case 0: //select A2D channel 0 ADMUX &= ~((1 << 3)|(1 << 2)|(1 << 1)|(1 << 0)); break; case 1: //select A2D channel 1 ADMUX &= ~((1 << 3)|(1 << 2)|(1 << 1)); ADMUX |= (1 << 0); break; case 2: //select A2D channel 2 ADMUX &= ~((1 << 3)|(1 << 2)|(1 << 0)); ADMUX |= (1 << 1); break; case 3: //select A2D channel 3 ADMUX &= ~((1 << 3)|(1 << 2)); ADMUX |= ((1 << 1)|(1 << 0)); break; /* I am not using these for this project case 4: //select A2D channel 4 ADMUX &= ~((1 << 3)|(1 << 1)|(1 << 0)); ADMUX |= (1 << 2); break; case 5: //select A2D channel 5 ADMUX &= ~((1 << 3)|(1 << 1)); ADMUX |= ((1 << 2)|(1 << 0)); break; */ }//end switch } void Delay(void) { _delay_us(100); } |
|
| Author: | 2goto1 [ Mon Apr 30, 2012 8:20 am ] |
| Post subject: | RE:Can anyone confirm this language? |
looks like c |
|
| Author: | cubera [ Mon Apr 30, 2012 11:03 am ] |
| Post subject: | Re: RE:Can anyone confirm this language? |
2goto1 @ Mon Apr 30, 2012 8:20 am wrote: looks like c
as in regular C? or C#? |
|
| Author: | 2goto1 [ Mon Apr 30, 2012 11:04 am ] |
| Post subject: | RE:Can anyone confirm this language? |
regular c |
|
| Author: | md [ Mon Apr 30, 2012 4:57 pm ] |
| Post subject: | RE:Can anyone confirm this language? |
Regular C with a bunch of ATMEGA library stuff. Looks like the source is incomplete too as those includes aren't valid. |
|