Hi ihr, ich habe eine Frage.. und zwar ob ich diesen Arduino Code so richtig in C umgeschrieben habe und wie ich in der untersten Funktion Ton() die Ausgangspins setzen kann weil PORTB = 0b00000001 also Pin B0 = 1 nimmt er nich.... vermute mal dass es was mit der Sichtbarkeit zu tun hat also ob Globale Variable oder Lokale... Ich muss dazu sagen ich bin totaler Anfänger in diesem Thema und naja boxe mich mit meinem Java Wissen etwas durch und einigen tutorials... aber alles kann man sich da halt nicht rauslesen...^^ Hatte zuerst versucht mit einem Arduino einen ATTINY 84 und einen ATMEGA8 zu flashen aber iwi gab das nur probleme deshalb bin ich jetzt kurzfristig auf das AVR-ISP-MK2 umgestiegen was ich aber erst am Montag bekomme. Wollte aber mal vorrab von euch wissen ob man das so machen kann. Danke schonmal vielmals!!! Hier der Arduino Code und weiter unten der Übersetzte C-Code für das AVR-Studio: ######################################################## ######################################################## ################### Arduino-Code ####################### ######################################################## ######################################################## /*********************************************************************** *********** * Allgemeine Deklaration ************************************************************************ **********/ #define NOTE1 40 #define NOTE2 30 #define NOTE3 20 // Lautsprecherausgang const byte Ton = 10; // Analog-Pins 0, 1, 2, 3, const int TP1A = 0; const int TP1B = 1; const int TP2A = 2; const int TP2B = 3; const int TP3A = 4; const int TP3B = 5; // Sensorwert // unten für die Abfrage des Sensorwerts nötig int sensorValue1 = 0; int sensorValue2 = 0; int sensorValue3 = 0; // Counter für die Lautstärkeregelung int counter1 = 0; int counter2 = 0; //Caryflags für Sensorlogik byte next = 0; byte wait = 0; byte play = 0; byte reset = 0; byte hupe1 = 0; byte hupe2 = 0; // Kalibration // die ersten 256 Messwerte werden summiert und mit Hilfe der letzten 50 Werte wird der Mittelwert bestimmt int Kalibrationarray1[256]; int Kalibration1 = 0; int Kalibrationarray2[256]; int Kalibration2 = 0; int Kalibrationarray3[256]; int Kalibration3 = 0; /*********************************************************************** *********** * Hauptprogramm ************************************************************************ **********/ // Führt die Deklaration der Pins durch sowie die Kalibrierung der Sensorik void setup(void){ pinMode(Ton,OUTPUT); // Zuweisung der Pins für Sensorik pinMode(TP1A,OUTPUT); pinMode(TP1B,OUTPUT); pinMode(TP2A,OUTPUT); pinMode(TP2B,OUTPUT); pinMode(TP3A,OUTPUT); pinMode(TP3B,OUTPUT); // Alles entladen digitalWrite(TP1A, LOW); digitalWrite(TP1B, LOW); digitalWrite(TP2A, LOW); digitalWrite(TP2B, LOW); digitalWrite(TP3A, LOW); digitalWrite(TP3B, LOW); delayMicroseconds(5); Kalibrierung(); } void loop(){ digitalWrite(Ton,HIGH); delayMicroseconds(30); digitalWrite(Ton,LOW); delayMicroseconds(30); // Laed und entlaed die Kondensatoren stetig // und erzeugt eine konstante Spannung // deren Aenderung kann anschliessend gemessen werden Kapazitaet(); Kapazitaet(); // erkennt Spannungsaenderungen // leitet entsprechende Aktionen ein Sensorlogik(); } /*********************************************************************** *********** * Kalibrierung ************************************************************************ **********/ void Kalibrierung(){ // 256 Messwerte werden summiert und anschließend die letzten 50 zur Bildung eines Mittelwerts benutzt for (int i=0; i<255; i++){ Kapazitaet(); Kapazitaet(); Kalibrationarray1[i] = analogRead(TP1A); Kalibrationarray2[i] = analogRead(TP2A); Kalibrationarray3[i] = analogRead(TP3A); delay(4); } for(int i=215; i<255; i++){ Kalibration1 = Kalibration1 + Kalibrationarray1[i]; Kalibration2 = Kalibration2 + Kalibrationarray2[i]; Kalibration3 = Kalibration3 + Kalibrationarray3[i]; } Kalibration1 = Kalibration1 / 40; Kalibration2 = Kalibration2 / 40; Kalibration3 = Kalibration3 / 40; } /*********************************************************************** *********** * Kapazitive Schaltung ************************************************************************ **********/ void Kapazitaet(){ // damit keine Ladung abfliessen kann werden beide Als Input geschaltet pinMode(TP1A,INPUT); pinMode(TP1B,INPUT); digitalWrite(TP1A, LOW); digitalWrite(TP1B, LOW); pinMode(TP2A,INPUT); pinMode(TP2B,INPUT); digitalWrite(TP2A, LOW); digitalWrite(TP2B, LOW); pinMode(TP3A,INPUT); pinMode(TP3B,INPUT); digitalWrite(TP3A, LOW); digitalWrite(TP3B, LOW); delayMicroseconds(5); // C wird aufgeladen pinMode(TP1A,OUTPUT); digitalWrite(TP1A, HIGH); pinMode(TP2A,OUTPUT); digitalWrite(TP2A, HIGH); pinMode(TP3A,OUTPUT); digitalWrite(TP3A, HIGH); delayMicroseconds(5); pinMode(TP1A,INPUT); digitalWrite(TP1A, LOW); pinMode(TP2A,INPUT); digitalWrite(TP2A, LOW); pinMode(TP3A,INPUT); digitalWrite(TP3A, LOW); // Ladung aus C abfuehren auf GND pinMode(TP1B,OUTPUT); digitalWrite(TP1B, LOW); pinMode(TP2B,OUTPUT); digitalWrite(TP2B, LOW); pinMode(TP3B,OUTPUT); digitalWrite(TP3B, LOW); } /*********************************************************************** *********** * Sensor Logik ************************************************************************ **********/ void Sensorlogik (){ // Ermitteln und zuweißen des Werts am Analogen-Eingang A1 und A2 sensorValue1 = analogRead(TP1A); sensorValue2 = analogRead(TP2A); sensorValue3 = analogRead(TP3A); if(sensorValue1 > Kalibration1 + 10 && sensorValue2 < Kalibration2 + 11 && sensorValue3 < Kalibration3 + 11){ Tone(40); } if(sensorValue2 > Kalibration2 + 10 && sensorValue2 < Kalibration1 + 11 && sensorValue3 < Kalibration3 + 11){ Tone(30); } if(sensorValue3 > Kalibration3 + 10 && sensorValue1 < Kalibration1 + 11 && sensorValue2 < Kalibration2 + 11){ Tone(20); } if(sensorValue1 > Kalibration1 + 10 && sensorValue2 > Kalibration2 + 11){ Tone(40); delay(100); Tone(30); delay(100); Tone(20); delay(100); } } void Tone (int Laenge){ digitalWrite(Ton,HIGH); delayMicroseconds(Laenge); digitalWrite(Ton,LOW); delayMicroseconds(Laenge); } ######################################################## ######################################################## ####################### C-Code ######################### ######################################################## ######################################################## #include <avr/io.h> #include <util/delay.h> #define NOTE1 1047 #define NOTE2 2048 #define NOTE3 3056 // Sensorwert // unten für die Abfrage des Sensorwerts nötig uint16_t sensorValue1 = 0; uint16_t sensorValue2 = 0; uint16_t sensorValue3 = 0; // Counter für die Lautstärkeregelung uint16_t counter1 = 0; uint16_t counter2 = 0; // Caryflags für Sensorlogik unsigned next:1 = 0; unsigned wait:1 = 0; unsigned play:1 = 0; unsigned reset:1 = 0; unsigned hupe1:1 = 0; unsigned hupe2:1 = 0; // Kalibration // die ersten 256 Messwerte werden summiert und mit Hilfe der letzten 50 Werte wird der Mittelwert bestimmt uint16_t Kalibrationarray1[256]; uint16_t Kalibration1 = 0; uint16_t Kalibrationarray2[256]; uint16_t Kalibration2 = 0; uint16_t Kalibrationarray3[256]; uint16_t Kalibration3 = 0; int main(void) { // 0 = Output und 1 = Input DDRB = 0b00000001; // Alles entladen DDRA = 0b00111111; PORTA = 0b00000000; _delay_us(5); Kalibration(); while(1) { // Laed und entlaed die Kondensatoren stetig // und erzeugt eine konstante Spannung // deren Aenderung kann anschliessend gemessen werden Kapazitaet(); Kapazitaet(); // erkennt Spannungsaenderungen // leitet entsprechende Aktionen ein Sensorlogik(); } } void Kalibrierung(){ uint8_t j=0; // 256 Messwerte werden summiert und anschließend die letzten 50 zur Bildung eines Mittelwerts benutzt for (uint i=0; i<255; i++){ Kapazitaet(); Kapazitaet(); Kalibrationarray1[i] = readADC(0); Kalibrationarray2[i] = readADC(2); Kalibrationarray3[i] = readADC(4); _delay_ms(4); if(i>214){ Kalibration1 = Kalibration1 + Kalibrationarray1[i]; Kalibration2 = Kalibration2 + Kalibrationarray2[i]; Kalibration3 = Kalibration3 + Kalibrationarray3[i]; j++; } } Kalibration1 = Kalibration1 / j; Kalibration2 = Kalibration2 / j; Kalibration3 = Kalibration3 / j; } void Kapazitaet(){ // damit keine Ladung abfliessen kann werden beide Als Input geschaltet // 0 = Output und 1 = Input DDRA = 0b11111111; PORTA = 0b00000000; _delay_us(5); // C wird aufgeladen // Pin 0,2,4 werden zu OUTPUTS // Pin 0,2,4 werden High geschalten DDRA = 0b11101010; PORTA = 0b00010101; _delay_us(5); DDRA = 0b11111111; PORTA = 0b00000000; // Ladung aus C abfuehren auf GND // Pin 1,3,5 werden OUTPUT und LOW DDRA = 0b11010101; PORTA = 0b00000000; } uint16_t readADC(uint8_t channel) { uint8_t i; uint16_t result = 0; // ADEN wird 1 gesetzt = ADC aktivieren // ADPS2 = 1 und ADPS1 = 1 beduetet: // Teilungsfaktor ist = 64 // Quelle: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Analoge_Ein-_und_Ausgabe#Messen_eines_Widerstandes ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1); // ADMUX wählt den zu messenden Kanal // "channel" des Multiplexers waehlen // REFS1 = 1 und REGS0 = 1 Interne Referenzspannung verwenden (also 2,56 V) // REFS1 = 0 und REGS0 = 0 Externe Regerenzspannung verwenden () ADMUX = channel | (1<<REFS1) | (1<<REFS0); // ADCSRA initialisiert den ADC und definiert dessen Funktion // Den ADC initialisieren und einen sog. Dummyreadout machen // ADSC bleibt solange 1 bist die Konvertierung abgeschlossen ist ADCSRA |= (1<<ADSC); while(ADCSRA & (1<<ADSC)); // Jetzt 3x die analoge Spannung and Kanal channel auslesen // und dann Durchschnittswert ausrechnen. for(i=0; i<3; i++) { // Eine Wandlung ADCSRA |= (1<<ADSC); // Auf Ergebnis warten... while(ADCSRA & (1<<ADSC)); result += ADCW; } // ADC wieder deaktivieren ADCSRA &= ~(1<<ADEN); result /= 3; return result; } void Sensorlogik (){ // Ermitteln und zuweißen des Werts am Analogen-Eingang A1 und A2 sensorValue1 = readADC(0); sensorValue2 = readADC(2); sensorValue3 = readADC(4); if(sensorValue1 > Kalibration1 + 10 && sensorValue2 < Kalibration2 + 11 && sensorValue3 < Kalibration3 + 11){ Tone(40); } if(sensorValue2 > Kalibration2 + 10 && sensorValue2 < Kalibration1 + 11 && sensorValue3 < Kalibration3 + 11){ Tone(30); } if(sensorValue3 > Kalibration3 + 10 && sensorValue1 < Kalibration1 + 11 && sensorValue2 < Kalibration2 + 11){ Tone(20); } if(sensorValue1 > Kalibration1 + 10 && sensorValue2 > Kalibration2 + 11){ Tone(40); _delay_ms(100); Tone(30); _delay_ms(100); Tone(20); _delay_ms(100); } } void Tone (uint8_t Laenge){ PIN0 = 0b00000001; _delay_us(Laenge); digitalWrite(Ton,LOW); _delay_us(Lange); }
Basstler schrieb: > void Tone (uint8_t Laenge){ > PIN0 = 0b00000001; > _delay_us(Laenge); > digitalWrite(Ton,LOW); > _delay_us(Lange); > } Laenge != Lange _delay_us funktioniert nur mit Konstanten werten, also keine Variabelen. Die Wartezeiten stimmen sonst nicht.
Schön daß eine Maus ein Scrollrad hat. Wie wäre es trotzdem damit, die Codes als Datei anzuhängen? mfg.
kann man den Post löschen dann mach ich nen neuen wo die Codes angehängt sind als Datei ;)
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.