Show Posts
Pages: [1] 2 3 ... 7
1  International / Deutsch / Re: Code Lässt sich für Attiny nicht Kompilieren on: October 16, 2013, 11:47:04 am
Oh, Danke für die Antwort/Erklärung.

Ich habe das Problem ja nun schon umschifft in dem ich mir meine Debugmeldungen mit einer LED ausgegeben habe. und der rest ging mit schätzen und rechnen smiley-wink

Daher hoffe ich mal das ich jetzt nich so schnell wieder damit kämpfen muss bzw. weis dann Das es der Bug is.

Danke nochmal
Gruß derRobert

Kann als Gelöst Angesehen werden....
2  International / Deutsch / Re: Code Lässt sich für Attiny nicht Kompilieren on: October 15, 2013, 03:49:24 pm
Der Flash langt dicke. habe es jetzt den code teilweise ohne mySerial.print hingeschustert. dabei konnte ich immer wieder feststellen das an bestimmten stellen im code das serial.print der fehler war. war es auskommentiert kam die Fehlermeldung  nicht.
Dies ist die Datei die ich in Hardware einfügen musste um den Tiny zu nutzen

Code:
attiny45.name=ATtiny45 (internal 1 MHz clock)
attiny45.bootloader.low_fuses=0x62
attiny45.bootloader.high_fuses=0xdf
attiny45.bootloader.extended_fuses=0xff
attiny45.upload.maximum_size=4096
attiny45.build.mcu=attiny45
attiny45.build.f_cpu=1000000L
attiny45.build.core=arduino:arduino
attiny45.build.variant=tiny8

attiny45-8.name=ATtiny45 (internal 8 MHz clock)
attiny45-8.bootloader.low_fuses=0xe2
attiny45-8.bootloader.high_fuses=0xdf
attiny45-8.bootloader.extended_fuses=0xff
attiny45-8.upload.maximum_size=4096
attiny45-8.build.mcu=attiny45
attiny45-8.build.f_cpu=8000000L
attiny45-8.build.core=arduino:arduino
attiny45-8.build.variant=tiny8

attiny45-20.name=ATtiny45 (external 20 MHz clock)
attiny45-20.bootloader.low_fuses=0xfe
attiny45-20.bootloader.high_fuses=0xdf
attiny45-20.bootloader.extended_fuses=0xff
attiny45-20.upload.maximum_size=4096
attiny45-20.build.mcu=attiny45
attiny45-20.build.f_cpu=20000000L
attiny45-20.build.core=arduino:arduino
attiny45-20.build.variant=tiny8

attiny85.name=ATtiny85 (internal 1 MHz clock)
attiny85.bootloader.low_fuses=0x62
attiny85.bootloader.high_fuses=0xdf
attiny85.bootloader.extended_fuses=0xff
attiny85.upload.maximum_size=8192
attiny85.build.mcu=attiny85
attiny85.build.f_cpu=1000000L
attiny85.build.core=arduino:arduino
attiny85.build.variant=tiny8

attiny85-8.name=ATtiny85 (internal 8 MHz clock)
attiny85-8.bootloader.low_fuses=0xe2
attiny85-8.bootloader.high_fuses=0xdf
attiny85-8.bootloader.extended_fuses=0xff
attiny85-8.upload.maximum_size=8192
attiny85-8.build.mcu=attiny85
attiny85-8.build.f_cpu=8000000L
attiny85-8.build.core=arduino:arduino
attiny85-8.build.variant=tiny8

attiny85-20.name=ATtiny85 (external 20 MHz clock)
attiny85-20.bootloader.low_fuses=0xfe
attiny85-20.bootloader.high_fuses=0xdf
attiny85-20.bootloader.extended_fuses=0xff
attiny85-20.upload.maximum_size=8192
attiny85-20.build.mcu=attiny85
attiny85-20.build.f_cpu=20000000L
attiny85-20.build.core=arduino:arduino
attiny85-20.build.variant=tiny8

attiny44.name=ATtiny44 (internal 1 MHz clock)
attiny44.bootloader.low_fuses=0x62
attiny44.bootloader.high_fuses=0xdf
attiny44.bootloader.extended_fuses=0xff
attiny44.upload.maximum_size=4096
attiny44.build.mcu=attiny44
attiny44.build.f_cpu=1000000L
attiny44.build.core=arduino:arduino
attiny44.build.variant=tiny14

attiny44-8.name=ATtiny44 (internal 8 MHz clock)
attiny44-8.bootloader.low_fuses=0xe2
attiny44-8.bootloader.high_fuses=0xdf
attiny44-8.bootloader.extended_fuses=0xff
attiny44-8.upload.maximum_size=4096
attiny44-8.build.mcu=attiny44
attiny44-8.build.f_cpu=8000000L
attiny44-8.build.core=arduino:arduino
attiny44-8.build.variant=tiny14

attiny44-20.name=ATtiny44 (external 20 MHz clock)
attiny44-20.bootloader.low_fuses=0xfe
attiny44-20.bootloader.high_fuses=0xdf
attiny44-20.bootloader.extended_fuses=0xff
attiny44-20.upload.maximum_size=4096
attiny44-20.build.mcu=attiny44
attiny44-20.build.f_cpu=20000000L
attiny44-20.build.core=arduino:arduino
attiny44-20.build.variant=tiny14

attiny84.name=ATtiny84 (internal 1 MHz clock)
attiny84.bootloader.low_fuses=0x62
attiny84.bootloader.high_fuses=0xdf
attiny84.bootloader.extended_fuses=0xff
attiny84.upload.maximum_size=8192
attiny84.build.mcu=attiny84
attiny84.build.f_cpu=1000000L
attiny84.build.core=arduino:arduino
attiny84.build.variant=tiny14

attiny84-8.name=ATtiny84 (internal 8 MHz clock)
attiny84-8.bootloader.low_fuses=0xe2
attiny84-8.bootloader.high_fuses=0xdf
attiny84-8.bootloader.extended_fuses=0xff
attiny84-8.upload.maximum_size=8192
attiny84-8.build.mcu=attiny84
attiny84-8.build.f_cpu=8000000L
attiny84-8.build.core=arduino:arduino
attiny84-8.build.variant=tiny14

attiny84-20.name=ATtiny84 (external 20 MHz clock)
attiny84-20.bootloader.low_fuses=0xfe
attiny84-20.bootloader.high_fuses=0xdf
attiny84-20.bootloader.extended_fuses=0xff
attiny84-20.upload.maximum_size=8192
attiny84-20.build.mcu=attiny84
attiny84-20.build.f_cpu=20000000L
attiny84-20.build.core=arduino:arduino
attiny84-20.build.variant=tiny14
Code:
/*
  pins_arduino.c - pin definitions for the Arduino board
  Part of Arduino / Wiring Lite

  Copyright (c) 2005 David A. Mellis

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General
  Public License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  Boston, MA  02111-1307  USA

  $Id: pins_arduino.c 565 2009-03-25 10:50:00Z dmellis $

  Modified 28-08-2009 for attiny84 R.Wiersma
  Modified 09-10-2009 for attiny45 A.Saporetti
*/

#ifndef Pins_Arduino_h
#define Pins_Arduino_h

#include <avr/pgmspace.h>

// ATMEL ATTINY45 / ARDUINO
//
//                  +-\/-+
// Ain0 (D 5) PB5  1|    |8  Vcc
// Ain3 (D 3) PB3  2|    |7  PB2 (D 2)  Ain1
// Ain2 (D 4) PB4  3|    |6  PB1 (D 1) pwm1
//            GND  4|    |5  PB0 (D 0) pwm0
//                  +----+

static const uint8_t A0 = 6;
static const uint8_t A1 = 7;
static const uint8_t A2 = 8;
static const uint8_t A3 = 9;

#define digitalPinToPCICR(p)    ( ((p) >= 0 && (p) <= 4) ? (&GIMSK) : ((uint8_t *)0) )
#define digitalPinToPCICRbit(p) ( PCIE )
#define digitalPinToPCMSK(p)    ( ((p) <= 4) ? (&PCMSK) : ((uint8_t *)0) )
#define digitalPinToPCMSKbit(p) ( (p) )

#define analogPinToChannel(p)   ( (p) < 6 ? (p) : (p) - 6 )

#ifdef ARDUINO_MAIN

// these arrays map port names (e.g. port B) to the
// appropriate addresses for various functions (e.g. reading
// and writing) tiny45 only port B
const uint16_t PROGMEM port_to_mode_PGM[] = {
NOT_A_PORT,
NOT_A_PORT,
(uint16_t) &DDRB,
};

const uint16_t PROGMEM port_to_output_PGM[] = {
NOT_A_PORT,
NOT_A_PORT,
(uint16_t) &PORTB,
};

const uint16_t PROGMEM port_to_input_PGM[] = {
NOT_A_PIN,
NOT_A_PIN,
(uint16_t) &PINB,
};

const uint8_t PROGMEM digital_pin_to_port_PGM[] = {
PB, /* 0 */
PB,
PB,
PB,
PB,
PB, // 5
PB, // A0
PB,
PB,
PB, // A4

};

const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[] = {
_BV(0), /* 0, port B */
_BV(1),
_BV(2),
_BV(3), /* 3 port B */
_BV(4),
_BV(5),
_BV(5),
_BV(2),
_BV(4),
_BV(3),
};

const uint8_t PROGMEM digital_pin_to_timer_PGM[] = {
TIMER0A, /* OC0A */
TIMER0B,
NOT_ON_TIMER,
NOT_ON_TIMER,
NOT_ON_TIMER,
NOT_ON_TIMER,
NOT_ON_TIMER,
NOT_ON_TIMER,
NOT_ON_TIMER,
NOT_ON_TIMER,
};

#endif

#endif


Keine Ahnung ob ich die irgendwo von der Arduino Seite habe oder aus einer anderen Quelle.

3  International / Deutsch / Re: Drehstrom mit variabler Frequenz erzeugen on: October 15, 2013, 12:10:30 pm
Wenn ein normaler Drehstrommotor betrieben werden soll würde ich eher zu einem fertigen Frequenzumrichter Raten. Dieser lässt sich in der Regel über einen Eingang in der Frequenz regeln. Vorteil wäre hier der Sicherheitsaspekt und das man sich nicht mit der Frequenzerzeugung herumschlagen muss.

wenn der Motor nicht zu Stark (0,5 bis 0,75 kW) ist kann man sogar einen Einphasen Umrichter nehmen und den Drehstrommoter dann sogar am ganz normalen "Lichtstrom" nutzen

Dazu müsste man den Arduino als Digitales Poti nutzen. evtl mit PWM -> RC Glied zur Glättung und einen OPV Dahinter.
Damit sollte man die nötigen 10V zur Ansteuerung irgendwie hinbekommen.

4  International / Deutsch / geklärt/Code Lässt sich für Attiny nicht Kompilieren on: October 15, 2013, 11:46:48 am
Hallo @all,

Ich Ich habe hier ein kleinens Temperaturschalterprojekt mit Tiny85, LM35, BC517 usw.

zum Programmieren wolte ich mir auf dem Tiny die Werte per SoftwareSerial ausgeben lassen.
Im Programm is es daher nötig Float to String zu Convertieren.

Wenn ich nun meinen Code für den Tiny Kompilieren will bekomme ich eine Fehlermeldung
Code:
/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25/crttn85.o: In function `__vector_default':
(.vectors+0xa): relocation truncated to fit: R_AVR_13_PCREL against symbol `__vector_5' defined in .text.__vector_5 section in core.a(wiring.c.o)
/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25/crttn85.o:(.init9+0x2): relocation truncated to fit: R_AVR_13_PCREL against symbol `exit' defined in .fini9 section in /Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/avr25/libgcc.a(_exit.o)
SoftwareSerial/SoftwareSerial.cpp.o: In function `SoftwareSerial::begin(long)':
/Applications/Arduino.app/Contents/Resources/Java/libraries/SoftwareSerial/SoftwareSerial.cpp:385: relocation truncated to fit: R_AVR_13_PCREL against symbol `__mulhi3' defined in .text.libgcc section in /Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/avr25/libgcc.a(_mulhi3.o)
/Applications/Arduino.app/Contents/Resources/Java/libraries/SoftwareSerial/SoftwareSerial.cpp:388: relocation truncated to fit: R_AVR_13_PCREL against symbol `__mulhi3' defined in .text.libgcc section in /Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/avr25/libgcc.a(_mulhi3.o)
Heizungsluefter.cpp.o: In function `loop':
/Applications/Heizungsluefter.ino:28: relocation truncated to fit: R_AVR_13_PCREL against symbol `__floatsisf' defined in .text.fplib section in /Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25/libm.a(floatsisf.o)
/Applications/Heizungsluefter.ino:28: relocation truncated to fit: R_AVR_13_PCREL against symbol `__mulsf3' defined in .text.fplib section in /Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25/libm.a(mulsf3.o)
/Applications/Heizungsluefter.ino:28: relocation truncated to fit: R_AVR_13_PCREL against symbol `__mulsf3' defined in .text.fplib section in /Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25/libm.a(mulsf3.o)
/Applications/Heizungsluefter.ino:28: relocation truncated to fit: R_AVR_13_PCREL against symbol `__mulsf3' defined in .text.fplib section in /Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25/libm.a(mulsf3.o)
core.a(realloc.c.o): In function `realloc':
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/avr-libc/realloc.c:146: relocation truncated to fit: R_AVR_13_PCREL against symbol `memcpy' defined in .text section in /Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25/libc.a(memcpy.o)

Wenn ich den Code Allerdings für den Duemilanove Kompiliere Funktioniert alles...

Habt ihr ne Idee wie ich das anders machen kann?

Hier mal der Sketch
Code:
#include <SoftwareSerial.h>

SoftwareSerial mySerial(2, 1); // RX, TX
int i=0;
float temp=0;
float aIn;
String tempstr;
char buf[10];


void setup() 
{

  digitalWrite(4,HIGH);
  digitalWrite(5,HIGH);
  mySerial.begin(2400);

}

void loop()
{

  int pot=analogRead(3);
  // mySerial.println(pot);

  if (i<=49){
     aIn = (5.0 * analogRead(2) * 100.0) / 1024;
    temp=temp+aIn;
    i++;
  }

  if(i=49){
     temp=temp/49;
    i=0;


    tempstr=dtostrf(temp,4,2,buf);
    mySerial.println(tempstr);
    temp=0;
  }




  // delay(50);
}


Hoffe jemand von euch weis weiter.
Danke schon mal fürs Lesen,

Gruß derRobert
5  International / Deutsch / Re: IR Fernbedienungscode auslesen??? on: May 30, 2013, 02:51:02 pm
Ich hatte für meine Funksteckdosen nen Logic analyzer( saleae Logic) und habe einfach die Fernbedienung aufgeschraubt und am Sendeteil aufgezeichnet. Messung starten und dann Knopf drücken. Dann hast du die aufgezeichnete signalfolge....
Diese kannst du dann in ner Funktion zusammen fassen

void.eineAktion;
  digital.write High
Delay...
Digital.write low
Delay...
...


Logicanalyzer gibt es auch für arduino im Netz zu finden....


6  International / Deutsch / Re: Überdurchschnittlicher Moterausschlag Robe roxy BL control - wie beheben? on: May 30, 2013, 02:20:52 pm
Das piepen der Regler ist normal. Sie zeigen dir damit an das sie Verbindung mit dem Empfänger aufgenommen haben und das das System läuft. Die brushless Regler kann man man auch in gewissen Maßen einstellen. Und das läuft über eine programmierkarte oder ebend über die Fernsteuerung und die piepstöne. Diese Töne kommen aber nicht wirklich vom Regler, sondern vom angeschlossenem Motor.

Zum kippen...
Ist dein schwehrpunkt wirklich mittig???  Bzw gibt es eine Möglichkeit das Modell zu trimmen? Denn wenn das Modell reproduzierbar in ein und die selbe Richtung kippen würde ist es nur ne einstellungssache. Aber da wird dir in einem wii-quadro Forum sicher eher geholfen als hier. Denn da geht's nicht um den arduino sondern um eine auf arduino entwickelte Software...
Gruß derRobert
7  International / Deutsch / Re: Home Automation mittels Arduino & Raspberry Pi on: January 11, 2013, 04:38:40 am
Der Punkt geht an dich :-)
Eine Rückmeldung fehlt, das ist wahr. Da stellt sich nun die Frage was du nun wirklich alles steuern willst?

Bei mir handelt es sich nur um einen Raum und da sehe ich ob alles aus ist.
Außerdem versende ich das Signal 5 mal hintereinander und erreiche damit eine 99% schaltsicherheit.

Ein Relais kann man nicht einfach so über die Ausgänge des Adriano oder des Raspberry schalten. Da braucht es mindestens nen vorwiederstand und Transistor davor und noch ne Diode für das Relais und eine entsprechende Spannungsversorgung brauchste auch noch. Das Relais verbraucht zu viel Strom beim schalten um direkt von den Ausgängen geschaltet zu werden. Oder du nimmst halt so ne fertige Relaiskarte die dafür gemacht ist von nem microcontroller geschaltet zu werden. Aber dann brauchste wieder einen Controller mit 16 Ausgängen. Und die Relaiskarte ist mit 120€ auch nicht grad günstig.

und der Kabelsalat... Neeee Hilfe da hätte i Keen Bock drauf. Außer natürlich du bist gerade Inn ner Renovierung (oder neubau) und verlegst die Kabel unter Putz. Dann würde ich auch zu der Relaiskarte greifen und sie im Sicherungskasten oder im Keller etc irgendwo unterbringen

Gruß
DerRobert

8  International / Deutsch / Re: Home Automation mittels Arduino & Raspberry Pi on: January 10, 2013, 04:33:04 pm
Ne Hand voll funksteckdosen und ein 433Mhz sendemodul für den Raspberry machen alles was du brauchst. Wenn man mit relaisekarten herum spielt gibt es viel zu beachten. Meißt schalten die Relais nicht so wie man sich das wünscht. Das liegt dann daran das man im Layout der Schaltung nicht auf die elektromagnetische Strahlung geachtet hat oder irgendwelche spannungsspitzen auftauchen oder oder oder.  Nicht zuletzt wäre zu betrachten das du dann direkt mit 220V herumspielst...

Bei de Funksteckdosen ersparte dir auch ne Menge kabelzieherei. Funksteckdosen sind auch sehr günstig und die Steuerbefehle findet man im Web oder man kann sie auch recht einfach selbst ermitteln.

Ich wollte auch erst Relais nehmen. Aber mit den Funksteckdosen bin ich nun voll zufrieden. Billiger als selbstbau und komfortabler sowieso...  Außerdem kommst du dann so einfach mit deinem Raspberry aus. Der hat ja ein paar wenige digitalausgänge und der 433Mhz Sender braucht nur einen. Desweiteren brauchste dann auch kein geweese wegen der Spannungsversorgung machen. Der Sender Brauch nich die Welt.

Gruß derRobert
9  International / Deutsch / Re: Arduino Esplora kaufen on: January 10, 2013, 05:13:33 am
http://arduino.cc/en/Main/BuyEsplora >>>


At the moment the Arduino Esplora is available only at your local RadioShack shops.



http://www.radioshack.com/product/index.jsp?productId=18450286


Evtl. Hilft das ja

Gruß derRobert
10  International / Deutsch / Re: Arduino MEGA nachbauen - Schaltplan, ect. ?? on: December 11, 2012, 02:26:20 pm
http://arduino.cc/en/uploads/Main/arduino-mega2560_R3-schematic.pdf   

http://arduino.cc/en/uploads/Main/arduino-mega2560_R3-reference-design.zip

http://arduino.cc/en/Hacking/PinMapping2560

Ist alles was man braucht um den Mega nach zu bauen. Allerdings wirds als Anfänger bestimmt nicht leicht eine Platine zu Entwickeln und dann noch den smd Mega 2560 zu Löten.    wenns nich unbedingt der Mega sein muss dann nimm doch nen Atmega 328  (Duemilanove / Uno)  den gibts als normalgroßen IC

nimm dann deinen Mega als ISP Programmer und gut is....    den Atmega328 gibts auch mit Arduino Bootloader+2Kondensatoren+Quarz bei ebay. dann musste noch ein FTDI Breakout kaufen
 http://www.watterott.com/de/FTDI-Breakout-Reloaded-V11
um normal mit der IDE deinen Controller benutzen zu können.

Wenns unbedingt ein mega sein muss kommste bestimmt billiger/günstiger/einfacher wenn de dir einen kaufst und den verbaust....

Gruß derRobert
11  International / Deutsch / Re: Spannungsversorgung wie Realisieren? on: November 28, 2012, 12:57:53 pm
Die stromaufnahme werde ich. Bei gelegenheit ermitteln. Mir geht es ersteinmal um die grundlegenden fakten welche spannungsversorgung am wirtschaftlichsten ist....
12  International / Deutsch / Re: Spannungsversorgung wie Realisieren? on: November 28, 2012, 12:19:57 pm
Der Preis des Netzteils/Spannungsversorgung spielt eine Untergeordnete Rolle. Was nützt mir ein 1€ Netzteil welches dann Haufen Wärme erzeugt.

Ich brauche eine sinnvolle Lösung die nich zu viel Energie in Wärme (Verlust) umsetzt sondern sparsam die benötigte Leistung liefert.

UND SICHER IST!!!

Aber trotzdem danke für die Antwort und Willkommen hier im Forum
13  International / Deutsch / Spannungsversorgung wie Realisieren? on: November 28, 2012, 10:50:09 am
Hallo @ all,
hab da ma wieder ne Frage. Die Frage hat zwar nix mit Arduino zu tun aber ich denke das hier genügend wissende mitlesen und mir eine gute Antwort geben können.

Und zwar habe ich jetzt einen Arduino mit ethernet so weit das er mir per Webinterface RGB leds ein und ausschaltet und auch ein paar Funksteckdosen werden damit bedient.
Jetzt möchte ich dort noch einen 433Mhz Empfänger einbinden.

Und dann will ich einen Attiny mit 433Mhz Sender und paar Taster am Eingang platzieren um nicht immer am Smartphone herumspielen zu müssen um nicht im Dunklen zu stehen.

Der tiny möchte nun aber auch mit 5V versorgt werden...

Wie realisiere ich das denn am günstigsten?  Also welche variante verbrät die wenigste energie? 

- ein steckernetzteil eines Alten Handys? 

- 7V Trafo und ein 7805?

- Kondensatornetzteil?

Wobei beim Kondensatornetzteil die Galvanische trennung fehlt und ich da natürlich schon respekt habe....

Wie sind eigentlich die einfachen Handynetzteile aufgebaut???? Kondensatornetzteil oder gar schaltnetzteile?


Ach ja. Ich habe keine Lust die Versorgungsspannung vom Arduino durch die ganze Wohnstube zu ziehen. Lieber eine Seperate Spannungsversorgung.

Oder kann jemand über den Daumen peilen wie lange ich mit ein bis zwei Knopfzellen hinkomme.

Danke schonmal für eventuelle Denkanstöße....

derRobert
14  International / Deutsch / Re: Fahrtenregler mit Arduino bauen on: November 26, 2012, 10:38:43 am
Um dir das Signal genauer an zu schauen lässt du dir die Serielle Ausgabe nicht in der ArduinoIDE ausgeben sondern mit Hyperterminal unter Windoof.
Da kannste dir die Ausgabe als .csv Datei speichern lassen und die dann mit Excel auswerten. Oder du versuchst http://accrochages.drone.ws/en/node/90

15  International / Deutsch / Re: Fahrtenregler mit Arduino bauen on: November 26, 2012, 10:23:20 am
Ich denke er meint die High Zeit trotzdem mit pulseIn Messen. Aber ebend die High Zeit da sie kürzer ist als Low.

Bei meiner Anwendung ist es Egal ob der Controller kürzer oder länger Blockiert ist. Daher habe ich mir die Längere Low Zeit genommen und habe diese dan noch durch 100 geteilt. Somit hatte ich einen Sauberen und fest Stehenden Wert. denn wenn du dir mal deinen Empfänger nimmst und den an den Arduino hängst und dir mit pulseIn() und serial.print() die Werte Anschaust dann wirst du sehen das die recht Springen. je nach dem wie sehr es sich auf deinen Fahrtregler ausübt würde ich einen mittelwert berechnen oder ebend auch einen Teiler Einbauen. Beim Teiler könnte es aber sein das dein fahrtregler dann nicht Feinfühlig genug wird.
So habe ich den Empfänger an einen Attiny angeschlossen. Kannst das aber auch an einen Digitalpin vom Arduino hängen


und das ist der Code dazu. 

Code:
#include <SoftwareSerial.h>
#define rxPin 3
#define txPin 4
SoftwareSerial serial(rxPin, txPin);

unsigned long timestamp1 = 0;
int timestamp2 = 0;



void setup(){

  pinMode(2,INPUT);
  pinMode(0,OUTPUT);
  digitalWrite (0, LOW);
   serial.begin(4800);
}


void loop(){

timestamp2= pulseIn(2,LOW);
timestamp1= timestamp2 / 100;
 serial.println(timestamp1);               // Oder timestamp2 für die ungeteilten Werte
 



  switch (timestamp1){
  case 193:
  rc1();
    break;
  case 185:
    rc2();
    break;
  }


}
void rc1()  //Gopro einschalten
{
  digitalWrite(0, HIGH);
  delay(300);
  digitalWrite(0, LOW);
 
}

void rc2()  //Gopro ausschalten
{
  digitalWrite(0, HIGH);
  delay(3000);
  digitalWrite(0, LOW);
 
}
Pages: [1] 2 3 ... 7