Show Posts
Pages: [1] 2 3 ... 163
1  International / Deutsch / Re: Einfache Verbindungskable on: April 17, 2014, 04:13:44 pm
Irgendwie bin ich nicht in der Lage passende Kabel mit Stecker bei Reichelt zu finden (am besten auch 6 Pol, aber 7 oder 8 gingen zur Not auch). Könntet ihr mir da mit einem Link aushelfen?

Auf Stiftleisten kannst Du üblicherweise Buchsenleisten draufstecken:
http://www.reichelt.de/Buchsenleisten/BL-1X10G8-2-54/3/index.html?&ACTION=3&LA=2&ARTICLE=51826&GROUPID=3221&artnr=BL+1X10G8+2%2C54

Eine 10-polige Buchsenleiste kannst Du ggf. mit der Kneifzange einkürzen.
Falls Du 8-polig brauchst, mit Kneifzange oder Seitenschneider auf der 9. Buchse durchschneiden.
Falls Du 7-polig brauchst, mit Kneifzange oder Seitenschneider auf der 8. Buchse durchschneiden.
Wird am durchgeknipsten Ende nicht besonders schön, aber funktioniert problemlos.
2  International / Deutsch / Re: String (objekt) vs. char array on: April 17, 2014, 10:54:59 am
...aber es kann ja nur besser werden smiley-wink

Habe Dir mal was aufgeschrieben, nur mit char-Array und char-Pointern.
Dabei bin ich mal davon ausgegangen, dass am Zeilenende ein ASCII-13 ("CR") gesendet wird:
Code:
void setup() {
  Serial.begin(115200);
}

char* SerialStringRead()
{
  static char text[81];
  static byte charcount=0;
  if (!Serial.available()) return NULL;
  if (charcount==0) memset(text,0,sizeof(text));
  char c=Serial.read();
  if (c>=32 && charcount<sizeof(text)-1)
  {
    text[charcount]=c;
    charcount++;
  }
  else if (c==13)
  {
    charcount=0;
    return text;
  }
  return NULL;
}

void Auswertung(char* text)
{
//  char text[]="$ACCAL,1120,895,0,D2,4220*14";
  int CRC_empfangen, CRC_berechnet=0;
  char* searchPtr=strchr(text,'*');
  if (searchPtr!=NULL)
  {
    CRC_empfangen=strtol(searchPtr+1, NULL, 16);
    for (int i=1;i<searchPtr-text;i++) CRC_berechnet^= (int)text[i];
  }
  else CRC_empfangen=-1; // no crc in string
  if (CRC_empfangen==CRC_berechnet) // fehlerfrei empfangen
  {
    Serial.println(F("CRC OK"));
    searchPtr=strtok(text,",*");
    while (searchPtr!=NULL)
    {
      Serial.println(searchPtr);
      searchPtr=strtok(NULL,",*");
    }
  }
  else
  {
    Serial.print(F("CRC falsch: "));
    Serial.println(text);
  }
}

int freeRam () {
  extern int __heap_start, *__brkval;
  int v;
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}


void loop()
{
  char* strPtr=SerialStringRead();
  if (strPtr!=NULL)
  {
    Auswertung(strPtr);
    Serial.print(F("RAM frei: "));
    Serial.println(freeRam());
  }
}

Die freeRam-Funktion gibt am Ende noch den freien Speicher aus.
Du kannst ja mal spaßeshalber in Deinen Code auch noch die freeRam-Funktion einbauen und vergleichen.
3  International / Deutsch / Re: String (objekt) vs. char array on: April 17, 2014, 08:30:16 am
Ich habe selber gemerkt, dass ich mit einem normalen Array mehr machen kann, als mit den Strings.

Aha. Deshalb wohl der merkwürdige Zwitter in Deinem Programm, wo vor dem Umwandeln des HEX-Wertes in der CRC-Summe ein Substring in ein char-Array umkopiert wird, um dann doch mit einem char-Array zu arbeiten.

String-Objekte sind eben extrem stark eingeschränkt, was man damit machen kann, das sind nicht besonders viele Funktionen.

Meine einzige Hoffnung war, dass ich RAM einspare.

Teste mal diesen Sketch, in dem ich zweimal drei Zeilen auskommentiert habe:
Code:
void setup() {
  Serial.begin(9600);
  unsigned long time=micros();
  /*
  char text[31]= "123456890";
  char text1[]="12345568901234556890";
  strncat(text,text1,sizeof(text));
  */
  /*
  String text= "123456890";
  String text1="12345568901234556890";
  text= text+text1;
  */
  time=micros()-time;
  Serial.println(text);
  Serial.print("Dauer: ");Serial.println(time);
  Serial.print("Ram frei: ");Serial.println(freeRam());
}

 int freeRam () {
  extern int __heap_start, *__brkval;
  int v;
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}

void loop() {}

Entferne mal die Kommentierung für die einen oder für die anderen drei Zeilen. Es werden jeweils ein 10 Zeichen langer String und ein 20 Zeichen langer String zu einem 30 Zeichen langen String zusammenkopiert und dabei wird gemessen
- der Zeitbedarf
- der freie RAM-Speicher am Ende nach dem Zusammenkopieren

Das Arbeiten mit String-Objekten führt im Programm nicht nur zu einem höheren RAM-Speicherverbrauch, sondern im übrigen auch zu einem deutlich höheren Rechenzeitbedarf für die Stringoperationen.

4  International / Deutsch / Re: Kurze MIDI -Sequenzen direkt im Sketch ohne SD-Karte abspeichern on: April 17, 2014, 05:42:46 am
Kann mir jmd. sagen, was es mit der Zeile 0x00, 0xff, nach der Tracklängenzeile auf sich hat?

Wenn ich mir die Dateiformatbeschreibung auf http://faydoc.tripod.com/formats/mid.htm#Header_Chunk ansehe, dann steht das für:
0x00 ==> Delta-Time 0
0xFF ==> Meta-Command folgt
0x03 ==> Meta-Command ist "Sequence or Track name"
0x14 ==> Länge des Textes (0x14 =20 Bytes)
0x4c, 0x69, 0x76, 0x69, ..., ..., ..., 0x6d, 0x65, 0x6c, 0x6f, ==> 20 Bytes Text
0x00 ==> Delta-Time 0
0xff ==> Meta-Command folgt
0x51 0x03==> Meta-Command ist "Set tempo"
0x06, 0xc7, 0x25 ==>  0x06c725 = Dauer einer Viertelnote 444197 µs = 0,4442s
0x00, ==> Delta Time 0
0xff ==> Meta-Command folgt
0x58  0x04 ==> Time Signature
0x04 ==> nn numerator of time sig.
0x02 ==> dd denominator of time sig.
0x18,  number of ticks in metronome click
0x08, number of 32nd notes to the quarter note
0x00, ==> Delta Time 0
0xff, ==> Meta-Command folgt
0x59, ==> Key signature

und so weiter und so fort...

Weißt Du damit überhaupt etwas anzufangen?
Warum möchtest Du mit absolut null Ahnung anfangen, Midi-Dateien in die einzelnen Bytes zu zerlegen?

Was von diesem ganzen Sermon möchtest Du eigentlich wie weiterverarbeiten?

Wenn Du die gesamte Datei nur aus Deinem Programm irgendwohin senden möchtest, dann brauchst Du doch gar nicht wissen, was das im Einzelnen ist, dann sendest Du die Datei und gut?

Und wenn Du gar nicht alles aus der Datei brauchst, sondern Du zum Beispiel nur die Noten in der Datei suchst, dann würde man ja wohl nicht die gesamte Datei in den Sketch packen, sondern nur das, was man braucht. Zum Beispiel die Noten, die man sich vorher mit einem geeigneten Tool aus der Datei gezogen hat.
5  International / Deutsch / Re: Der HMC5883L- was treibt er? on: April 16, 2014, 03:06:35 pm
Hm- auf die vollen 360 Grad komme ich nur, wenn ich das Modul so neige, dass die y-Achse ca. 45 Grad nach _unten_ zeigt...?
Umgedreht muss ich, um auf die 180 zu kommen, wiederum das Teil um 180Grad um die Z-Achse und um 90 Grad um X neigen.

Bin ich einfach zu doof oder ist da nen Fehler drin?

Den geposteten Code prüfe ich gleich nochmal, allerdings arbeitet der Code ohne "Kalibrierung" des Sensors und ohne Ausgleich der magnetischen Kompass-Mißweisung.

Die fehlende Kompensation der Kompaß-Mißweisung bewirkt in Deutschland ca. eine Fehlweisung von 2°.

Die fehlende Sensor-Kalibrierung macht vielleicht 8% Achsenwert aus, was zu einem Fehler von 8% auf 90° führen kann, also ca. 7°.

Macht zusammen vielleicht bis hoch zu 10° Richtungsfehler (bei manchen Richtungen). Wenn Du die Kompaßrichtung (Vollkreis= 360°) beim Drehen um die z-Achse (Hochachse) bei flach aufliegendem Sensor nicht auf +/-10° genau angezeigt bekommst, ist da irgendwas anderes faul. Ich tippe auf folgendes in Sensornähe:
- stromdurchflossene Leiter mit Strömen > 10 mA
- Magnetfelder (PC-Monitore, Lautsprecher etc.)
- eisenhaltige Metallteile

Hast Du Deinen HMC5883L vielleicht auf ein Breadboard gesteckt?
Ein Breadboard besteht im Innern nur aus Blech-Kontakten (Eisen!), was jeden Kompass ablenkt!

Prüfe also bitte nochmal genau nach:
- Wie weit sind stromdurchflossene Leiter entfernt, durch die mehr als 10mA Strom fließen?
- Wie weit sind Magnetfelder aus PC-Monitoren und Lautsprechern entfernt?
- Wie weit sind eisenhaltige Teile vom Sensor entfernt?
Dabei auch "unsichtbares Eisen" berücksichtigen, wie die Blechkontakte im Breadboard!

Für diese drei Dinge gilt: Je weiter weg, desto genauer die Anzeige!
Außerdem muss der Sensor flach aufliegen, die z-Achse genau nach oben, x und y horizontal.

Bekommst Du dann beim Drehen keine Anzeige, die beim Drehen fortlaufend von 0° (Nord) über 90° (Ost), 180° (Süd), 270° (West) bis zu 360°/0° (Nord)  hochläuft, also bei einen Richtungswechsel um 90° auch 90° Anzeigewertänderung mit meinem Sketch?

Edit/Nachtrag: Den von mir geposteten Code habe ich gerade nochmal getestet und konnte keine Fehler entdecken, der Code funktioniert bei mir einwandfrei. Um sicherzugehen, dass sich die Spannung am I2C-Bus ausreichend stabilisiert hat, nachdem die Wire-Library aktiviert wurde, kannst Du zur Sicherheit aber nochmal ein kleines delay von einigen Millisekunden nach wire.begin einfügen:
Code:
  Wire.begin();
  delay(10);

Hast Du auf Deiner Platine auch mal überprüft, ob Du wirklich den "L" Sensor hast? Der müßte dann auf der Gehäuseoberseite mit "883L" oder "L883" beschriftet sein, mit einer guten Lupe kann man die Chip-Markierung lesen.
6  International / Deutsch / Re: Arduino Helligkeit und Dunkelheit erkennen lassen on: April 16, 2014, 10:20:20 am
ich soll für die Schule ein Projekt mit Arduino machen. Dafür soll bei Nacht eine Pumpe laufen und bei Tag soll ein Elektromotor einen Verschluss öffnen. Die Schaltung und Programmierung dafür, denke ich, kriege ich hin, aber wie kann ein Arduino kennen, das Tag und das Nacht ist?
 
Eine Idee wäre,  einen Stromkreis über einen LDR laufen zu basteln und den Arduino messen lassen, wie groß die Spannung ist, die ankommt. (Je heller, desto geringer der Widerstand --> große Spannung). Die Frage ist daher, ist so etwas möglich, und wie progammiert man so etwas?

Bei Deinem Anwendungsfall kommt es nicht darauf an, dass die Messung schnell sein muss, daher reicht im Prinzip eine einzelne trickreich angesteuerte LED, um die Helligkeit zu messen. Siehe Playground:
http://playground.arduino.cc/Learning/LEDSensor

Ich habe das mal etwas umgeschrieben, so dass die Helligkeitsmessung als Funktion verfügbar wird:
Code:
/* Arduino-Lichtmessung mit LED von 'jurs' für das Deutsche Arduino Forum
   Benötigte Hardware: Eine LED beliebiger Farbe (vorzugsweise weiß)
   Die LED wird bei diesem Versuch NICHT leuchten, sondern in Sperrrichtung betrieben.
   Sie wird wie ein "Kondensator" aufgeladen, der sich je nach Lichtstärke schneller
   oder langsamer entlädt.
*/
#define LED_ANODE 6    // Anode = LED lAnger Draht
#define LED_KATHODE 7  // Kathode = LED Kurzer Draht
#define MAXCOUNTER 100000 // je größer diese Zahl, desto "dunklere" Messwerte sind möglich

void setup()
{
  Serial.begin(9600);
}

long helligkeit()
{
  // Funktion zur Helligkeitsmessung mit LED
  // große Zahlen = kleine Helligkeit
  // kleine Zahlen = große Helligkeit
  // die tatsächlichen Zahlen sind von der verwendeten LED (und der Helligkeit) abhängig
  long counter;
  // LED in Sperrrichtung "aufladen"
  pinMode(LED_ANODE,OUTPUT);
  digitalWrite(LED_ANODE,LOW); // Die LED Anode LOW setzen
  pinMode(LED_KATHODE,OUTPUT);
  digitalWrite(LED_KATHODE,HIGH); // Die LED Kathode ganz kurz auf HIGH setzen zum "Aufladen"
  pinMode(LED_KATHODE,INPUT); // Kathode hochohmig von der Stromversorgung abtrennen
  digitalWrite(LED_KATHODE,LOW);  // den internen PullUp-Widerstand abschalten
  // nun in einer Zählschleife "entladen", bis an der Kathode ein LOW gemessen wird
  for ( counter=0; counter<100000L; counter++) {
    if ( digitalRead(LED_KATHODE)==LOW) break; // Bei erfüllter break-Bedingung ist die LED entladen
  }
  return counter;
}

void loop()
{
  long messwert=helligkeit();
  Serial.print("Helligkeit: ");
  Serial.println(messwert);
  delay(500);
}

Beim Erstellen Deiner Hell/Dunkel-Anwendung mußt Du aufpassen, dass Du nicht einfach nur eine Schaltschwelle bei einem festen Wert vorsiehst, das ist eine FALSCHE Schaltlogik:
Code:
if (licht>grenzwert)
  schaltedies();
else
  schaltejenes();

Das Problem dabei ist, dass reale Messwerte immer etwas streuen, und genau beim Grenzwert würdest du ein ständiges Hin- und Herschalten bekommen, wenn der Messwert mal über und mal unter dem Grenzwert liegt. D.h. bei Anbruch des Tages bzw. der Nacht könnte es passieren, dass dabei hunderte Male ganz schnell hin und her geschaltet wird.

Deshalb mußt Du eine Schaltlogik mit einer "Hysterese" machen. Das bedeutet, es gibt einen kleinen Bereich Messwerte, bei dem immer der letzte Schaltzustand beibehalten und nicht geschaltet wird. Richtige Schaltlogik:
Code:
if (licht>grenzwert+hysterese)
  schaltedies();
else if (licht<grenzwert-hysterese)
  schaltejenes();

In dem Fall würde immer dann, wenn der Messwert zwischen (grenzwert+hysterese) und (grenzwert-hysterese) schwankt, NICHT geschaltet werden, sondern es bleibt innerhalb dieses Bereiches der letzte Schaltzustand weiter bestehen. Erst bei Über- oder Unterschreiten der Grenzen erfolgt tatsächlich ein Umschalten. Wie groß die Hysterese sinnvollerweise gewählt werden sollte, richtet sich danach, wie stark die Messwerte streuen und wie reaktionsfreudig die Schaltung sein soll.

Natürlich kannst Du auch "richtige" Lichtsensoren zur Lichtmessung verwenden. Aber LEDs hat man ja meistens in der Bastelkiste, so dass man gar nichts extra kaufen muß, um Helligkeit/Dunkelheit zu messen. Außer der Langsamkeit dieser Messungen gibt es ggf. einen weiteren Nachteil, den der Richtungsabhängigkeit: Genau so wie eine LED Licht hauptsächlich "nach oben" abstrahlt, wird bei der Messung per LED hauptsächlich "Licht von oben" gemessen. Aber das ist bei Deinem Anwendungsfall ja vielleicht auch gar nicht so verkehrt.

Viel Spaß beim Lichtmessen und Schalten!

Edit/Nachtrag: Das mit dem Realtime Clock Modul (DS1307 oder für seltenes Nachstellen DS3231) ist natürlich auch eine interessante Option. Man könnte sich z.B. dann je nach Datum die Sonnenaufgangs- und -untergangszeiten (oder Dämmerungszeiten) ausrechnen und Tag und Nacht anhand des Sonnenstands ermitteln. Viele Möglichkeiten.
7  International / Deutsch / Re: Hilfe bei IR-Codes senden… on: April 16, 2014, 08:08:19 am
Und wenn ich über IRsendDemo sende: irsend.sendRC6(0x8048260C, 36);

Seit wann kann eine 32-Bit Konstante 36 Bits enthalten?

Wenn Du 36 Bits senden möchtest, würde ich annehmen, dass Du dann auch 36 Bits an die Sendefunktion übergeben müßtest.
8  International / Deutsch / Re: Daten in den Flash-Speicher übertragen und auslesen on: April 16, 2014, 03:29:02 am
Meine Frage ist nun, kann ich PROGMEN grundsätzlich immer einsetzen, auch im laufendem Programm oder bin ich vollständig auf dem Holzweg? Hat jemand Erfahrungen damit und fühlt sich bereit dazu mir eventuell ein paar blöde Fragen zu beantworten?

PROGMEM ist ein Schlüsselwort bei der Deklaration von KONSTANTEN im Flash-Speicher.

Wenn Du das Schlüsselwort PROGMEM verwendest, werden die entsprechend deklarierten Konstanten im Flash-Speicher statt im RAM-Speicher abgelegt. Von dort können die Konstanten bei Bedarf mit Hilfe spezieller Lesebefehle gelesen werden, also auch z.B. vom Flash-Speicher ins RAM kopiert und dort weiter verarbeitet werden.

Die maximale Größe von PROGMEM deklarierten Konstanten ist auf ein Segment von 64 KB insgesamt beschränkt. Falls Du auf einem Controller mit mehr Flash-Speicher (z.B. MEGA mit 256 KB Flash) mehr als 64 KB Konstanten im Flash halten möchtest, wird es noch ein klein wenig komplizierter mit der Arduino-Software.

Leider hat sich das Arduino-Team noch immer nicht aufraffen können, den GCC-Compiler mit Libraries mal auf eine aktuelle Version zu hieven, bei der dieser ganze PROGMEM-Sermon für Flash-Konstanten nicht mehr notwendig ist. Denn vom AVR-GCC gibt es schon mindestens seit zwei Jahren eine Version, bei der dieses PROGMEM-Gehampel überhaupt nicht mehr notwendig ist. Aus mir unerfindlichen Gründen ist ein Compiler-Update aber wohl auch für die kommende 1.5.x/2.0.x Version der Arduino-Software leider nicht zu erwarten.

Es gibt aber im Netz wohl Bastelanleitungen, um die Arduino-Software selbst nachträglich auf AVR-GCC v 4.7.2 zu bringen. In neueren Compiler-Versionen würde das dann mit der Deklaration von Flash-Konstanten so funktionieren:
Code:
const _flash int values[] = { 42, 31 };
Und die Verwendung würde exakt genau erfolgen, ohne zusätzliche PROGMEM-Lesebefehle, wie man sonst auf "normale" Variablen und Konstanten zugreift. Falls Du Lust zum Basteln an Installationen der Arduino-Software hast, bringe Deine Software auf den Compilerstand 4.7.2 und arbeite mit dem "_flash" Keyword!

Und wenn Du mit einer originalen Arduino-Version Konstanten im Flash bis zu einer Größe von 64 KB benötigst, nutze das (inzwischen veraltete, aber bei Arduino immer noch notwendige) PROGMEM mit den lustigen, unterhaltsamen und lehrreichen "Program space utilities":
http://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html
9  International / Deutsch / Re: BMP085 - Pin Belegung? | Verzweiflung on: April 15, 2014, 02:04:44 pm
Kann mir bitte jemand von euch helfen und mir sagen wo man die Pinverteilung ändert?

Deja-vu: http://forum.arduino.cc/index.php?topic=233533.0

Zwei Tage später, dasselbe Thema zum Zweiten.
Und das vom selben Themen-Starter.
 smiley-cry
10  International / Deutsch / Re: Lcd-Problem on: April 15, 2014, 11:03:43 am
Hier ein Foto vom kompl. Aufbau:

Sieht das auf dem Foto nur so aus oder führen die beiden Außenanschlüsse des Kontrast-Potis beide zu GND?
11  International / Deutsch / Re: Lcd-Problem on: April 15, 2014, 10:38:50 am
Ich habe mir mal testweise einen ATMEGA328 mit einem LCD (HD44780 Controller) zusammengesteckt.
Das funktioniert im Prinzip, ABÈR:
Das Display produziert "verwaschene" Schrift.
Weiß jemand Rat?

Fehlerhafte Schaltung.
Irgendwie sieht Dein Foto aus als wenn Du vergessen hast, die Hintergrundbeleuchtung anzuschließen - die ist aus.

Alle LCDs mit weißen Pixeln brauchen zur einwandfreien Funktion zwingend eine Hintergrundbeleuchtung.

Dagegen ist bei Displays mit schwarzen Pixeln die Hintergrundbeleuchtung optional: Funktioniert ohne wie auch mit.

Des weiteren frage ich mich: Wo ist denn bei Deinem Display das Potentiometer für die Kontrastregelung?
12  International / Deutsch / Re: Blinker für RC-Auto on: April 15, 2014, 07:19:17 am
Später, wenn alles funktioniert, soll das ganze in dem RC-Fahrzeug über einen Multiswitch gesteuert werden. Dieser gibt wie ein Taster nur bei betätigung des entsprechenden Schalters auf der Fernbedienung ein Signal für den jeweilien Kanal aus.
Wenn der Blinker aus ist und gedrückt wird soll er angehen bis wieder gedrückt wird, dann geht er wieder aus.

OK, es kann jetzt sein, dass ich da etwas verwechselt habe, was für ein Signal Du später auswerten möchtest. Ich war davon ausgegangen, Du wolltest mit dem Arduino direkt am RC-Empfänger die Impulse auswerten und danach schalten. Offenbar möchtest Du aber tatsächlich zwischen RC-Empfänger und Arduino noch einen Multiswitch-Decoder dazwischenstecken, der Dir ein bereits decodiertes Signal liefert.

Ich finde es immer schön, wenn ein Programm nach dem EVA-Prinzip strukturiert wird:
- Eingabe
- Verarbeitung
- Ausgabe

Da bei diesem Programm nicht viel zu tun ist, habe ich den Schritt "Verarbeitung" hier mal der "Eingabe" mit zugeschlagen.

Beispiel-Code (ungetestet) anbei.
Code:
// Blinker Demo by 'jurs' for German Arduino Forum
#define INPUT_TYPE INPUT_PULLUP  // INPUT oder INPUT_PULLUP
#define BLINKTAKT 500   // in Millisekunden
#define ENTPRELLZEIT 5  // in Millisekunden
byte tasteLinks=2;  // Pins für zwei Taster
byte tasteRechts=3;
byte blinkerLinks=12; // Pins für zwei Blink-LEDs
byte blinkerRechts=13;

boolean linksBlinken=false; // Blinker links gesetzt
boolean rechtsBlinken=false; // Blinker rechts gesetzt

void blinkEingabe()
{
  static unsigned long lastMillis=0;
  static boolean altTasteL=false;
  static boolean altTasteR=false;
  if (millis()-lastMillis<ENTPRELLZEIT) return;
  lastMillis=millis();
  boolean neuTasteL=digitalRead(tasteLinks);
  boolean neuTasteR=digitalRead(tasteRechts);
  if (INPUT_TYPE==INPUT_PULLUP) // vertauschte Tastenlogik bei PullUp
  {
    neuTasteL=!neuTasteL;
    neuTasteR=!neuTasteR;
  }
  if (neuTasteL==HIGH && altTasteL==LOW) linksBlinken=!linksBlinken;
  if (neuTasteR==HIGH && altTasteR==LOW) rechtsBlinken=!rechtsBlinken;
  altTasteL=neuTasteL;
  altTasteR=neuTasteR;
}

void blinkAusgabe()
{
  static unsigned long lastMillis=0;
  static boolean onTakt=false;
  static unsigned long diffMillis=0;
  unsigned long nowMillis=millis();
  diffMillis+=nowMillis-lastMillis;
  if (diffMillis>=BLINKTAKT)
  {
   diffMillis=0;
   onTakt=!onTakt;
   if (onTakt && linksBlinken) digitalWrite(blinkerLinks,HIGH);
   else digitalWrite(blinkerLinks,LOW);
   if (onTakt && rechtsBlinken) digitalWrite(blinkerRechts,HIGH);
   else digitalWrite(blinkerRechts,LOW);

   Serial.print(digitalRead(blinkerRechts));
   Serial.print(digitalRead(blinkerLinks));
   Serial.println();
  }
  lastMillis=nowMillis;
}


void setup() {
  Serial.begin(9600);
  pinMode(tasteLinks,INPUT_TYPE);
  pinMode(tasteRechts,INPUT_TYPE);
  pinMode(blinkerLinks,OUTPUT);
  pinMode(blinkerRechts,OUTPUT);
}

void loop()
{
  blinkEingabe();
  blinkAusgabe();
}

Je nachdem, ob Du Deine Taster mit PullDown-Widerständen angeschlossen hast oder die internen PullUps des Atmega an den Tastern verwenden möchtest, kannst Du den INPUT_TYPE als entweder "INPUT" oder "INPUT_PULLUP" definieren, abhängig von Deiner Schaltung.

Beide Blinker werden übrigens unabhängig voneinander geschaltet, so dass sich Warnblinken schalten läßt, indem man sowohl den linken als auch den rechten Blinker einschaltet. Also diese Schaltlogik entspricht nicht der Straßenverkehrszulassungsordnung.

Die "Serial" Befehle habe ich übrigens nur zum Debuggen für die Programmentwicklung drin, um mir hier keine Taster und LEDs tatsächlich aufbauen zu müssen, die "Serial" Befehle kannst und solltest Du natürlich für das engültige Programm rauslöschen.
13  International / Deutsch / Re: Blinker für RC-Auto on: April 15, 2014, 04:03:27 am
Beim betätigen von pin 3 (Schalter Rechts) beginnt LED 6 (Blinker Rechts) zu blinken. Beenden lässt sich dies über ein erneutes betätigen des pin 3 nicht.

Als erstes mal müßtest Du Dir über die genaue Schaltlogik im Klaren werden.
Oben schreibst Du einerseits von RC-Kanälen, über die Steuerinformationen gesendet werden
Dann schreibst Du von Tastern, die beim Betätigen mal ein- und mal ausschalten sollen

Meine Kenntnisse über RC-Fernsteuerungen sagen mir: Eine Funktion wird geschaltet, so lange ein Steuersignal gesendet wird, das besagt, die Funktion soll geschaltet sein. Wenn Du dieses RC-Verhalten mit einer Taster-Logik nachbilden wolltest, wäre die Logik (bei einer RC-Fernsteuerung wie ich sie kenne):
- RC-Funktion geschaltet / Taster ist runtergedrückt ==> zugehöriger Blinker blinkt
- RC-Funktion nicht geschaltet /Taster ist losgelassen ==> Blinker ist aus
Für diese Art Steuerung wird ein RC-Kanal für jede Steuerfunktion benötigt.
Bzw. ein RC-Kanal für insgesamt zwei Steuerfunktionen, von denen aber nur eine zur Zeit gesetzt sein kann (links-rechts-aus).

Daneben gibt es noch "Multiswitch" Schaltlogik, bei der ein Kanal in verschiedene Schaltfunktionen aufgeteilt wird und im Endeffekt ist es so, dass es für jede Schaltfunktion einen verschiedenen Schalter zum Ein- und Ausschalten gibt:
- RC-Funktion für  EIN geschaltet / Taster EIN wurde gedrückt ==> zugehöriger Blinker blinkt
- RC-Funktion für AUS geschaltet / Taster AUS wurde gedrückt ==> Blinker ist aus
Mit einem Multischwitch, können dann z.B. fünf verschiedene Funktionen pro RC-Kanal ein/aus geschaltet werden, das entspricht fünf Einschaltern und fünf Ausschaltern, wenn man es mit Schaltern nachbilden möchte: Je ein Einschalter und ein Ausschalter pro Funktion.

Und Du möchtest stattdessen diese Logik haben, die nicht so wirklich RC-kompatibel ist:
- RC-Funktion wird einmal geschaltet / Taster wird einmal runtergedrückt ==> zugehöriger Blinker blinkt
- RC-Funktion nicht geschaltet / Taster ist losgelassen ==> bereitmachen für nächstes Kommando
- RC-Funktion wird nochmal geschaltet / Taster wird nochmal runtergedrückt ==> Blinker ist aus
???
14  International / Deutsch / Re: Ghosting´s auf Adafruit 2.8" TFT V2 on: April 15, 2014, 02:53:52 am
Ist es möglich, das sich da nach ca. 3 Wochen Ghosting´s auf/in dem Display
bilden? Früher nannte man das "einbrennen"- will ich aber beim TFT nicht
so recht glauben.

http://de.wikipedia.org/wiki/LCD-Memory-Effekt

Der Memory-Effekt verschwindet, wenn Du den Monitor entweder sehr lange Zeit ausschaltest, oder wenn Du genau so lange ein weißes Bild zeigst wie es vorher gedauert hat, durch Zeigen desselben Bildes den Memory-Effekt hervorzurufen.
15  International / Deutsch / Re: Editieren / anschauen von .h und .c dateien in der library on: April 14, 2014, 09:33:51 am
Dass das mit einem externen Editor geht ist schon klar - hatte ich ja auch geschrieben.
Aber was macht denn eine IDE (heisst ja schliesslich Integrated Development Environment...)
für einen Sinn, die neben dem eingebauten noch einen externen Editor benötigt
um Dateien zu bearbeiten die innerhalb eines Projektes benutzt werden wie
cpp und header-files) ???

Die "Arduino-Software" ist eben hauptsächlich für Leute gemacht, die nur "Sketche" editieren und Libraries nur wie fertige Lego-Bausteine "benutzen" möchten, aber keine Libraries "selber schreiben" wollen. Die aufgeräumten und eingeschränkten Funktionen in der IDE verhindern jedenfalls, dass Leute ohne die geringste Ahnung sich ihre Libraries kaputt bearbeiten.

Wenn Du eine umfangreichere IDE suchst, schaue Dir mal die "Codeblocks Arduino Edition" an:
http://arduinodev.com/codeblocks/

Das ist eine "alternative IDE" mit mehr Möglichkeiten - auch beim Editor. Selbst ein Hex-Editor gehört mit dazu, so dass Du nicht nur CPP und H Datein öffnen und editieren kannst, sondern über die Funktion "Open with Hex Editor" kannst Du meinetwegen auch Binärdateien öffnen und direkt editieren. Denn richtige Programmierer wie Du brauchen wahrscheinlich gar keinen Compiler, die editieren sich eine HEX-Datei direkt selbst.
 smiley-wink


Pages: [1] 2 3 ... 163