Hi ihr,
ich will mit dem Arudino Board einen Atiny programieren... kleinere
Programme funktionieren auch anur mein richtiges mag er nicht...
und zwar sollen die Pins 0-5 als Analoge ins bzw outs funktionieren und
dann 3 kleine Touchfelder abfragen und analog auslesen...
mit dem arduino board klappt das auch alles einwandfrei...
nur mit dem Attiny mag das nicht oO
Weder Töne noch sonst was gibt er mit im Loop aus... scheint so als
würde er sich vorrher aufhängen....
hier mal der Quellcode... Hat jemand eine Ide??? =( =(
/***********************************************************************
***********
* Allgemeine Deklaration
************************************************************************
**********/
#define NOTE1 40
#define NOTE2 30
#define NOTE3 20
// Lautsprecherausgang
const int Ton = 10;
// Analog-Pins 0, 1, 2, 3,
const int TP1A = A0;
const int TP1B = A1;
const int TP2A = A2;
const int TP2B = A3;
const int TP3A = A4;
const int TP3B = A5;
// 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);
}
wie geasgt mit Ardunio klappt ales einwadnfrei... nur mit dem Tiny noch... was muss ich wie anderst deklarieren?? :'( danke schonmal!!!
also 4kbit speicher hat er sram kp oO meinste das reicht nich? oO shit..
Im Datenblatt steht wieviel sram er hat. Die Größe der Datentypen hier: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Ganzzahlige_Datentypen_.28Integer.29
hättest du eine idee was ich kürzen könnte? muss doch iwi gehn oder?^^
Notfalls Assembler nehmen, das spart sehr viel Platz. Oder einfach auf den ATtiny84A umsteigen, der hat doppelt so viel Speicherplatz.
hm... kk mal schaun--- kann ich mit Aruino Assempler programieren? wenn ja wie?^^
Attiny84 reicht auch nicht, solange der so speicherfressend programmiert wird. Nicht der µC ist falsch, sondern das Konzept. Welche Variablen belegen am meisten sram? Bei über 1,5KB hast du Glück gehabt das dein Arduino Board noch gereicht hat.
wo kann ich das sehen? bin da leider noch recht neu in dem Gebiet... -.- sry^^
so is besser....
es kommt immrehin schon was aber es knallt nur... normal sollte der ton
gehalten werden der in "ton" erzeugt wird...
/***********************************************************************
***********
* Allgemeine Deklaration
************************************************************************
**********/
#define NOTE1 40
#define NOTE2 30
#define NOTE3 20
// Lautsprecherausgang
const byte Ton = 10;
// Analog-Pins 0, 1, 2, 3,
const byte TP1A = 0;
const byte TP1B = 1;
const byte TP2A = 2;
const byte TP2B = 3;
// Sensorwert
// unten für die Abfrage des Sensorwerts nötig
int sensorValue1 = 0;
int sensorValue2 = 0;
int sensorValue3 = 0;
int counter = 0;
// Kalibration
// die ersten 256 Messwerte werden summiert und mit Hilfe der letzten 50
Werte wird der Mittelwert bestimmt
int Kalibration1 = 0;
int Kalibration2 = 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);
// Alles entladen
digitalWrite(TP1A, LOW);
digitalWrite(TP1B, LOW);
digitalWrite(TP2A, LOW);
digitalWrite(TP2B, LOW);
delayMicroseconds(5);
for(int i=0; i <= 250; i++){
Kapazitaet();
}
Kalibration1 = analogRead(TP1A);
Kalibration2 = analogRead(TP2A);
}
void loop(){
// Laed und entlaed die Kondensatoren stetig
// und erzeugt eine konstante Spannung
// deren Aenderung kann anschliessend gemessen werden
Kapazitaet();
// erkennt Spannungsaenderungen
// leitet entsprechende Aktionen ein
Sensorlogik();
}
/***********************************************************************
***********
* 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);
delayMicroseconds(5);
// C wird aufgeladen
pinMode(TP1A,OUTPUT);
digitalWrite(TP1A, HIGH);
pinMode(TP2A,OUTPUT);
digitalWrite(TP2A, HIGH);
delayMicroseconds(5);
pinMode(TP1A,INPUT);
digitalWrite(TP1A, LOW);
pinMode(TP2A,INPUT);
digitalWrite(TP2A, LOW);
// Ladung aus C abfuehren auf GND
pinMode(TP1B,OUTPUT);
digitalWrite(TP1B, LOW);
pinMode(TP2B,OUTPUT);
digitalWrite(TP2B, LOW);
}
/***********************************************************************
***********
* Sensor Logik
************************************************************************
**********/
void Sensorlogik (){
// Ermitteln und zuweißen des Werts am Analogen-Eingang A1 und A2
sensorValue1 = analogRead(TP1A);
sensorValue2 = analogRead(TP2A);
if( sensorValue1 > Kalibration1 + 10 && sensorValue2 < Kalibration2
+ 11){
Tone(40);
}
if(sensorValue2 > Kalibration2 + 10 && sensorValue1 < Kalibration1 +
11){
Tone(30);
}
if(sensorValue1 > Kalibration1 + 10 && sensorValue2 > Kalibration2 +
10){
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);
}
so......
es töner aber noch nicht richtig... aberimmerhin kommt schon was raus...
was kann ich noch vereinfachen finde nichts ehr =(
/***********************************************************************
***********
* Allgemeine Deklaration
************************************************************************
**********/
// Lautsprecherausgang
const byte Ton = 10;
// Analog-Pins 0, 1, 2, 3,
const byte TP1A = 0;
const byte TP1B = 1;
const byte TP2A = 2;
const byte TP2B = 3;
int sensorValue1 = 0;
int sensorValue2 = 0;
int sensorValue3 = 0;
int Kalibration1 = 0;
int Kalibration2 = 0;
/***********************************************************************
***********
* Hauptprogramm
************************************************************************
**********/
void setup(void){
pinMode(Ton,OUTPUT);
// Zuweisung der Pins für Sensorik
pinMode(TP1A,OUTPUT);
pinMode(TP1B,OUTPUT);
pinMode(TP2A,OUTPUT);
pinMode(TP2B,OUTPUT);
// Alles entladen
digitalWrite(TP1A, LOW);
digitalWrite(TP1B, LOW);
digitalWrite(TP2A, LOW);
digitalWrite(TP2B, LOW);
delayMicroseconds(5);
for(byte i=0; i <= 150; i++){
Kapazitaet();
}
Kalibration1 = analogRead(TP1A);
Kalibration2 = analogRead(TP2A);
}
void loop(){
Kapazitaet();
Sensorlogik();
}
/***********************************************************************
***********
* Kapazitive Schaltung
************************************************************************
**********/
void Kapazitaet(){
pinMode(TP1A,INPUT);
pinMode(TP1B,INPUT);
digitalWrite(TP1A, LOW);
digitalWrite(TP1B, LOW);
pinMode(TP2A,INPUT);
pinMode(TP2B,INPUT);
digitalWrite(TP2A, LOW);
digitalWrite(TP2B, LOW);
delayMicroseconds(5);
pinMode(TP1A,OUTPUT);
digitalWrite(TP1A, HIGH);
pinMode(TP2A,OUTPUT);
digitalWrite(TP2A, HIGH);
delayMicroseconds(5);
pinMode(TP1A,INPUT);
digitalWrite(TP1A, LOW);
pinMode(TP2A,INPUT);
digitalWrite(TP2A, LOW);
pinMode(TP1B,OUTPUT);
digitalWrite(TP1B, LOW);
pinMode(TP2B,OUTPUT);
digitalWrite(TP2B, LOW);
}
/***********************************************************************
***********
* Sensor Logik
************************************************************************
**********/
void Sensorlogik (){
// Ermitteln und zuweißen des Werts am Analogen-Eingang A1 und A2
sensorValue1 = analogRead(TP1A);
sensorValue2 = analogRead(TP2A);
if( sensorValue1 > Kalibration1 + 10 && sensorValue2 < Kalibration2
+ 11){
Tone(40);
}
if(sensorValue2 > Kalibration2 + 10 && sensorValue1 < Kalibration1 +
11){
Tone(30);
}
if(sensorValue1 > Kalibration1 + 10 && sensorValue2 > Kalibration2 +
10){
Tone(40);
delay(100);
Tone(30);
delay(100);
Tone(20);
delay(100);
}
}
void Tone (int Laenge){
for(byte i=0; i <= 250; i++){
digitalWrite(Ton,HIGH);
delayMicroseconds(Laenge);
digitalWrite(Ton,LOW);
delayMicroseconds(Laenge);
}
}
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.