Show Posts
Pages: [1] 2
1  International / Deutsch / Re: Nochmal Hilfe gesucht zum Speichern/Abrufen (Flash Memory) on: April 18, 2013, 04:46:45 pm
Ja, danke für deinen Hinweis, da hatte ich wohl um die Ecke gedacht!
Inzwischen habe ich mein gesamtes Projekt neu gestaltet, und es läuft endlich wie gewünscht.

Grüße
stringwalker
2  International / Deutsch / Re: Nochmal Hilfe gesucht zum Speichern/Abrufen (Flash Memory) on: April 11, 2013, 06:05:50 pm
Ja, ich meinte das Pluszeichen in der analogWrite Zeile  - danke für deine Erklärung, habe sie verstanden.

stringwalker
3  International / Deutsch / Re: Nochmal Hilfe gesucht zum Speichern/Abrufen (Flash Memory) on: April 05, 2013, 05:24:43 pm
Ach so, das wusste ich nicht, deshalb die Probleme! Danke für den Hinweis.

Ich habe es gleich ausprobiert, und so funktioniert es endlich einwandfrei. Ich schreibe jetzt die Potistellung als Variable "z" ins EEPROM und lese den Wert zusammen mit den Flash Werten aus.

analogWrite (led_1, pgm_read_byte(pwm_1+z));

Noch eine Frage zu dem Pluszeichen im Code:
Auch wenn es funktioniert, hätte ich gerne noch ein paar Infos zu seiner Anwendung gelesen. Bisher habe ich noch keine Erklärungen dazu finden können.

Grüße
stringwalker
4  International / Deutsch / Nochmal Hilfe gesucht zum Speichern/Abrufen (Flash Memory) on: April 04, 2013, 06:41:43 pm
Hallo,

vor einiger Zeit hatte ich (Anfänger) euch um Hilfe gebeten bei einem Projekt, bei dem zwei LEDs von einem Poti geregelt werden und Potistellungen abgespeichert werden sollen. Inzwischen funktioniert alles tasächlich einwandfrei, aber mein Code ist völlig aufgeblasen durch zu viele ifs u.ä. und
belegt unmäßig viel Speicher.

Jetzt habe ich ein bisschen dazu gelernt und will den Code neu schreiben auf Basis einer Idee von pylon. Es gibt dabei allerdings ein Problem, an dem ich festhänge. Vielleicht könnt ihr helfen.

Der Code hier ist abgespeckt (normalerweise sind die arrays größer, es sollen mehr Werte gespeichert werden, Anzeige etc.), aber der Kern steht da.

Also:
Die PWM Werte von LED 1 und 2 werden nach Tabelle von einem Poti geregelt, das funktioniert gut. Mit Taster 1 soll dann eine Potistellung im Flash gespeichert werden. Ich habe mal "range" eingetragen (s. Codezeile), der Wert wird auch gespeichert, aber wenn ich diese Stellung incl. LED Werten mit Taster 2 reproduzieren will, machen die LEDs irgendwas, nur nicht das, was sie sollen.

Es fehlt also eine richtige Verbindung zwischen gespeicherte Potistellung und LED Werten.
Habt ihr vielleicht eine Idee dazu?

Code:
#include <avr/pgmspace.h>

  const int potiMin = 0;       // Poti Min
  const int potiMax = 1023; // Poti Max
  uint8_t led_1 = 9;           //  LED 1 (rot)
  uint8_t led_2 = 10;          // LED 2 (grün)
  uint8_t led_3 = 12;          // LED 3 (gelb)
                             
  uint8_t taster_1 = 4;        // Taster 1 // Taster und Schalter
  uint8_t taster_2 = 2;        // Taster 2 // sind elektr. entprellt
  uint8_t taster_3 = 7;        // Taster 3   (Schalter)
 
  int val_1 = 0;               // Status Taster 1
  int val_2 = 0;               // Status Taster 2
  int val_3 = 0;               // Status Taster 3

  PROGMEM uint8_t pwm_1[] = { 0, 255, 100,50,};  // zum Testen hier
                                                                      // jeweils nur
  PROGMEM uint8_t pwm_2[] = {10, 0, 200, 20,};   // vier PWM Werte

void setup()
{
    Serial.begin(9600);
 
    pinMode(taster_1, INPUT);       
    pinMode(taster_2, INPUT);       
    pinMode(taster_3, INPUT);       // ist Schalter
   
    pinMode(led_1, OUTPUT);         
    pinMode(led_2, OUTPUT);         
    pinMode(led_3, OUTPUT);         
}

void loop()
{
       while (digitalRead(taster_3)== 1 )  // Schalter an
    {
        val_3 = digitalRead(taster_3);     // Status Taster 3
           if (val_3 == 1)
             {
               digitalWrite(led_3, HIGH);   // gelbe LED an
             }         
           else
             {
              digitalWrite(led_3, LOW);      //gelbe LED aus
             } 
               
         int poti = analogRead(A0);            // Poti auslesen
         int range = map(poti, 0, 1023, 0, 4); // Zum Testen nur 4 Bereiche
           
         analogWrite(led_1, pgm_read_byte(pwm_1+range)); // PWM Wert aus Flash an LED 1
         analogWrite(led_2, pgm_read_byte(pwm_2+range)); // PWM Wert aus Flash an LED 2

         val_1 = digitalRead(taster_1);     
           
            if (val_1 == 1)                              /////////////////////////////////////////
             {                                             // HIER IST DAS ERSTE PROBLEM:
              PROGMEM int range;                 //  range speichert zwar die Potistellung, die Verbindung zu den LED Werten
                                                           // besteht dadurch aber noch nicht! (s.u.)
             }
             delay (10);
      }
             
             
             
         while (digitalRead(taster_3)== 0 )      // Schalter aus
      {
            val_3 = digitalRead(taster_3);        // Status Taster 3
            if (val_3 == 1)
             {
                digitalWrite(led_3, HIGH);        // gelbe LED an
             }         
           else
             {
               digitalWrite(led_3, LOW);            //gelbe LED aus
             } 
               
             int poti = analogRead(A0);                // Poti auslesen
             int range = map(poti, 0, 1023, 0, 4); // Zum Testen auch nur 4 Bereiche
       
           
           
             val_2 = digitalRead(taster_2); 
             if (val_2 == 1)
             {
             analogWrite(led_1, pgm_read_byte(pwm_1+range));       //   Hier sollte dann die mit Taster 1
             analogWrite(led_2, pgm_read_byte(pwm_2+range));       //   gespeicherte Potistellung zusammen
                                                                                           //   mit den entsprechenden PWM Werten ausgegeben
                                                                                           //   werden. Funktioniert aber nicht.
             }           
               
             delay(10);
     }
}           
           


Vielen Dank im Voraus!

stringwalker
5  International / Deutsch / Re: Hilfe beim Speichern und Abrufen von PWM Werten gesucht on: March 12, 2013, 11:50:14 am
Danke für die Aufmunterung und den Link! Die bounce lib ist super.

Grüße
stringwalker
6  International / Deutsch / Re: Hilfe beim Speichern und Abrufen von PWM Werten gesucht on: March 11, 2013, 12:29:00 pm
Quote
Der Code im if wird durchgehend ausgeführt, solange der Taster gedrückt ist.
Ja stimmt, das darf natürlich nicht sein beim Beschreiben des EEProms, das hatte ich nicht bedacht. Man braucht also einen Flankendetektor für pos. oder neg. Flanken, wie das in der Digitaltechnik genannt wird. Die Notwendigkeit, mechanischerSchalters zu entprellen, ist mir auch klar.

Leider merke ich aber, dass ich noch vieles lernen muss, ehe ich mein Projekt zu Ende kriege. Der Anfang ist zwar gemacht, aber es ist doch sehr frustrierend, dass es jetzt so viele Hindernisse und Misserfolge gibt.

Ich mache mich jetzt erst einmal daran, grundsätzliche Elemente zu beherrschen wie EEProm beschreiben, Flashspeicher auslesen u.a. So komme ich jedenfalls nicht mehr befriedigend voran.

Danke trotzdem für eure Hilfe und Geduld.

stringwalker
7  International / Deutsch / Re: Hilfe beim Speichern und Abrufen von PWM Werten gesucht on: March 09, 2013, 06:18:32 pm

Quote
Dann kannst du mit den Tastern B, C, D eine Zustandsvariable setzen, mit der du dann unterschiedliche Aktionen auslöst.
Und, wie schon Uwe geschrieben hat, beim drücken von A eine Zustandsvariable toggeln
(if (Taste A pressed) PWMSet = !PWMSet) und den Speicherplatz zu selektieren.

Hallo,
also ich habe mich wirklich redlich bemüht, eure Vorschläge umzusetzen, habe einiges auf den Arduino Seiten gelernt, aber ich hänge jetzt fest. Zwar kann ich Taster abfragen und irgend etwas einschalten, aber es gelingt mir einfach nicht, das z.B. mit switch/case, if... etc. sinnvoll zu verbinden.

Könnt ihr bitte noch einmal einen Blick auf meinen Code werfen und mich beraten?

Ich habe an der Stelle, wo es nicht weitergeht, nochmal notiert, was da passieren soll. Steht zwar auch oben, aber ist hier für euch vielleicht hilfreich.

Code:
#include <avr/pgmspace.h>

const int potiMin = 0;           // Poti Minimum
const int potiMax = 1023;     // Poti Maximum
uint8_t ledPin1 = 9;             // LED 1 an digital pin 9
uint8_t ledPin2 = 10;           // LED 2 an digital pin 10

int tasterRec = 2;               // merkt sich auf Tastendruck die aktuellen PWM Werte
int tasterWrite1 = 4;           // gibt die ersten "gemerkten" Werte an ledPin1 und ledPin2 aus
int tasterWrite2 = 7;           // gibt die als zweites "gemerkten" Werte an den ledPin1 und ledPin2 aus
int tasterPoti = 8;               // führt zurück zum Potimodus, PWM Werte entsprechen Potistellung

int tasterStatusRec;            // Variable zur Aufname des Status TasterRec
int tasterStatusWrite1;        // Variable zur Aufname des Status TasterWrite1
int tasterStatusWrite2;        // Variable zur Aufname des Status TasterWrite2
int tasterStatusPoti;            // Variable zur Aufname des Status TasterPoti


PROGMEM uint8_t outvalue1[] =
{
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,                         // Liste der möglichen Werte für LED1
                                                                                          // hier stehen z.Zt. hauptsächlich nur Platzhalter
 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,                   
 
 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,
 
 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63} ;

   
PROGMEM uint8_t outvalue2[] =
{

 25,24,53,52,51,25,24,8,2,24,25,4,3,2,241,39,                           // Liste der möglichen Werte für LED2
                                                                                            // hier stehen z.Zt. ebenfalls nur Platzhalter
 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,                   
 
 2,1,0,9,8,21,6,25,4,3,212,211,210,209,208,207,
 
 20,20,20,26,2,2,21,199,198,197,16,15,94,93,12,10,};
 
 
void setup()
{
  Serial.begin(9600);                    // serielle Schnittstelle initialisieren
 
pinMode(tasterRec,INPUT);           // Pin 2 ist Input
pinMode(tasterWrite1,INPUT);       // Pin 4 ist Input
pinMode(tasterWrite2,INPUT);       // Pin 7 ist Input
pinMode(tasterPoti,INPUT);           // Pin 8 ist Input
}

void loop()
{
  int poti = analogRead(A0);                                           // Poti auslesen
  int range = map(poti, 0, 1023, 0, 63);                           // Poti Gesamtbereich in 64 Bereiche unterteilen
                                                                 
  Serial.print("B ");                                                       // "B x", zeigt aktuellen Potibereich an
 
  analogWrite(ledPin1, pgm_read_byte(outvalue1+range));   // PWM Wert aus Flash an LED 1
  analogWrite(ledPin2, pgm_read_byte(outvalue2+range));   // PWM Wert aus Flash an LED 2

 
 /*             Und hier fangen die Probleme an!
 
                 Mit dem tasterRec sollen die PWM Werte, die gerade durch die aktuelle Potistellung an den Leds anliegen, im Speicher irgendwie
                 "markiert" werden, damit ich sie später mit tasterWrite1 - unabhängig von der Potistellung - wieder an den ledPins ausgeben kann.
                                             
                 Das gleiche möchte ich einer zweiten Potistellung und den den dazu gehörenden PWM Werten mit tasterRec und TasterWrite2 erreichen.
                                             
                 tasterPoti muss mich zurück in den Potimodus bringen, damit wieder die der momentanen Potistellung entsprechenden PWM Werte
                 an den ledPins ankommen
 */                                             
           
  tasterStatusRec = digitalRead(tasterRec);     
  if(tasterStatusRec == HIGH)                               
   ...?                                                            // Ich kann doch die PWM Werte hier nicht nochmal speichern, sie sind doch schon im Flash...?
   
  tasterStatusWrite1 = digitalRead(tasterWrite1);
  if(tasterStatus == HIGH)
 
 
  tasterStatusWrite2 = digitalRead(tasterWrite2);
  if(tasterStatus == HIGH)
 
   
  tasterStatusPoti = digitalRead(tasterPoti);
  if(tasterStatus == HIGH)
 
       
  delay(10);                               
}

Danke für eure Hilfe und Grüße von
stringwalker
8  International / Deutsch / Re: Hilfe beim Speichern und Abrufen von PWM Werten gesucht on: March 08, 2013, 06:21:47 pm
Verstehe, dann werde ich lieber gleich die universellen Begriffe verwenden. Die Möglichkeiten der Microcontroller faszinieren mich viel zu sehr, um mich nur auf den Arduino festzulegen.

Grüße zurück
stringwalker
9  International / Deutsch / Re: Hilfe beim Speichern und Abrufen von PWM Werten gesucht on: March 08, 2013, 05:10:29 pm
Uwe
Quote
Falls die Beziehung Helligkeit und  Potistellung linear ist braucht es keine Wertetabelle sondern es genügt ein map() Funktion.

Nein, diese Linearität gibt es nicht, mein Ziel ist es ja gerade, mit Hilfe vom Arduino ganz krumme Kennlinien zu erzeugen (läuft über nachgeschaltete Optokoppler etc.).

Gunther
Quote
erst wenn du ein
Serial.println(irgendwas);  ausgibst, fängt die neue Zeile an.

Es war genau dieses kleine "ln" im println, das ich überlesen hatte. Erklärung kapiert, danke für ein weiteres Aha-Erlebnis.

Pylon,
dein Code war doch für mich Neuling anfangs völlig kryptisch, aber ich habe gründlich recherchiert und gelernt und verstehe ihn jetzt vollständig. Hinterher erscheint alles wie so oft ganz logisch.

Du hast angeboten, evt. anfallende Fragen zu beantworten. Grundsätzlich ist mir, wie gesagt, alles klar, in vier Fällen wäre ich aber noch für eine Bestätigung dankbar:

Quote
uint8_t ledPin1 = 9;
uint_8 speichert "a type of unsigned integer of length 8 bits", und byte speichert einen ganzzahligen 8-bit Wert.
Dann wären die Befehle m.E. doch austauschbar, oder nicht? (Byte wäre dabei für mich der "griffigere", weil aussagekräftigere Befehl.)

Um PROGMEM im Code nutzen zu können, muss ich am Anfang die passende Bibliothek anfordern. Ich habe das im Code ergänzt. OK?

Quote
PROGMEM uint8_t outvalue1[]
outvalue hatte ich zuerst für einen Befehl gehalten, aber es ist nur ein Name für eine Variable. Ist das eine Art Standardbezeichnung, die man verwendet? Dann wäre es sinnvoll, sich das auch anzueignen.

Quote
analogWrite(ledPin1, pgm_read_byte(outvalue1+range));                // PWM Wert aus Flash an LED 1
Für das das Pluszeichen habe ich bisher keine direkte Erklärung gefunden. Ich denke, es gehört zur syntax und sagt hier: Ordne dem gespeicherten Wert von outvalue dem entsprechenden Potibereich zu. Richtig?

Jetzt kann mich an meine Taster machen, es war mir aber erst einmal wichtiger, vor dem nächsten Schritt bis hierhin alles zu verstehen.

Ach so, klar geworden ist mir natürlich auch, dass die Werte per Tastendruck gar nicht mehr gespeichert werden müssen, da sie ja schon im Flashspeicher liegen. Ich muss vielmehr - wenn das Poti an der "richtigen" Stelle steht - die aktuellen PWM Werte irgendwie "markieren", um sie dann später auf Tastendruck wieder hervorholen zu können. Ich arbeite dran.

Grüße an euch alle

stringwalker
10  International / Deutsch / Re: Hilfe beim Speichern und Abrufen von PWM Werten gesucht on: March 07, 2013, 06:06:10 pm
Pylon,
vorab erst einmal herzlichen Dank für die Mühe, die du dir gemacht hast. "Massiv gekürzt" ist aber wohl eine ziemliche Untertreibung - meine Güte, der Code ist ja nur noch ein Bruchteil so lang!

Natürlich verstehe ich jetzt vieles noch nicht (PROGMEM uint8_t outvalue1 u.a.), aber das recherchiere ich selbst und frage nach, wenn ich dann immer noch etwas nicht kapiere.

Eines wüsste ich aber gerne doch gleich:

 Serial.print("B ");                    // "B X" für Bereich X anzeigen
 Serial.println(range);

Verstehe ich es richtig, dass die Leerstelle hinter dem B ("B ") in Verbindung mit der nächsten Befehlszeile dazu führt, dass die einzelnen Poti Bereiche angezeigt werden? Das wäre ja elegant.

Mit den Tastern bin ich leider noch nicht weiter, aber sowie ich etwas habe, melde ich mich. Ich hatte Überlegungen auf Basis meines Codes angestellt, aber der gefällt mir jetzt nicht mehr, und ich muss erst die Folgen deiner massive Kürzung verdauen... smiley

Nochmals danke

stringwalker

11  International / Deutsch / Re: Hilfe beim Speichern und Abrufen von PWM Werten gesucht on: March 07, 2013, 10:43:20 am
Quote
Was an Uwe's Vorgehen verstehst Du denn nicht? Ich finde es sehr anschaulich erklärt. Erwarte bitte nicht, dass wir Dir hier fertigen Code vorsetzen, zuerst musst Du mal Eigeninitiative zeigen.

Pylon, ich erwarte keineswegs, dass mir jemand einen fertigen Code vorsetzt, und Eigeninitiative entwickle ich reichlich, das kannst du mir glauben. smiley So einfach ist die Umsetzung für einen Anfänger aber eben doch nicht, auch wenn man es prinzipiell versteht.

Ich komme aus dem auch oft komplexen Gebiet der Analog- und Digitalelektronik und habe viele Leute im Netz beraten, die nicht klar kamen mit ihren Projekten. Deshalb weiß ich, mit welchen Tücken sich Einsteiger herumschlagen, und dass sich für sie imanchmal Hürden auftun, die ich kaum nachvollziehen kann.
Sie erwarten aber (i.d.R.) auch keine fertig dimensionierte Schaltung incl. Platinenlayouts von mir, es sind viel mehr Antworten auf Fragen wie : Lässt es sich überhaupt realisieren, was ich mir da vorstelle, wo fange ich an, unter welchen Fachbegriffen sollte ich im Netz suchen etc. Damit kommt ein interessierter Einsteiger dann einen guten Schritt weiter.

Gunther hat mir genau in diesem Sinne schon mal geholfen, danke dafür, damit kann ich etwas anfangen.

Mein Code (noch ohne die Speicherung) sieht übrigens bisher so aus, da werde ich also die Tasterabfragen einarbeiten:

const int potiMin = 0;                                // Poti Minimum
const int potiorMax = 1023;                       // Poti Maximum
      int ledPin1 = 9;                                  // LED 1 an digital pin 9
      int ledPin2 = 10;                                // LED 2 an digital pin 10
     
void setup()
{
 
  Serial.begin(9600);                                // serielle Schnittstelle initialisieren
}

void loop()
{
    int poti = analogRead(A0);                   // Poti auslesen
    int range = map(poti, 0, 1023, 0, 63);   // Poti Gesamtbereich in 64 Bereiche unterteilen
                                                                 
  switch (range)                           
  {
  case 0:                                 
    Serial.println("B 01");                    // "B 01" für Bereich 1 anzeigen
    analogWrite(ledPin1, 0);                // PWM Wert 0 an LED 1
    analogWrite(ledPin2, 50);               // PWM Wert 50 an LED 2
    break;
  .
  .
  .
   case 63:                                 
    Serial.println("B 63");                     // "B 64" für Bereich 63 anzeigen
    analogWrite(ledPin1, 255);              // PWM Wert 255 an LED
    analogWrite(ledPin2, 182);              // PWM Wert 182 an LED 2
    break;
   
   }
  delay(10);                               
}

Grüße,
stringwalker
12  International / Deutsch / Hilfe beim Speichern und Abrufen von PWM Werten gesucht on: March 06, 2013, 06:57:35 pm
Hallo,

ich benötige noch einmal eure Hilfe für Teil 2 meines "großen" Projektes (Anfänger)!

Teil 1 funktioniert schon einwandfrei:
Entsprechend der Position eines Potis am analogen Eingang werden an zwei PWM Ausgängen verschiedene, von mir festgelegte Werte ausgegeben.
 
Teil 2 kriege ich bisher aber nicht hin: Ich will nämlich o.g. PWM Werte im EEProm speichern und später wieder ausgeben.
 
Wie das mir das genau vorstelle, möchte ich kurz beschreiben:

An den Eingängen des Arduino Uno hängen 4 Taster sowie  ein Poti, an zwei PWM Ausgängen je eine LED. (Die Taster nenne ich mal A, B, C, D). Das  Poti steht an irgendeiner Stelle, und die beiden LEDs leuchten unterschiedlich hell entsprechend den Werten, die ich im sketch für die betreffende Potiposition eingetragen habe.

Jetzt will ich ich Taster A drücken,  und die momentan ausgegebenen PWM Werte sollen im EEprom gespeichert werden. Danach drehe ich das Poti in eine andere Position, drücke wieder Taster A, und auch diese Werte sollen gespeichert werden.

Später möchte ich durch Drücken der Taster B oder C  die gespeicherten PWM Werte  wieder abrufen, woraufhin die LEDs entsprechend dieser Werte leuchten werden. Um dann wieder in den „Poti Modus“ kommen (das Leuchten der LEDs hängt von der Potistellung ab) drücke ich Taster D.

Uwe hatte mir schon eine erste Hilfe gegeben:
Quote
Du kontrollierst den Taster und wen dieser gedrückt wird (zB LOW-HIGH-Übergang) Speicherst Du den Analogwert ab un setzt eine Statusvariable auf 1. Beim Drücken des zweiten Tasters setzt Du die Statusvariable auf 0.
Solange diese Statusvariable 1 ist nimmst Du den gespeicherten Wert ansonsten den gelesenen Analogwert von den Potis.

Im Prinzip verstehe ich das, ich stehe aber doch noch zu sehr am Anfang, um es auch umsetzen zu können. Ich wäre sehr dankbar, wenn mir jemand genauer sagen würde, wie ich meine Idee konkret angehen soll bzw. wo ich mich schlau machen kann.
Vielen Dank !

stringwalker



13  International / Deutsch / Re: Umsetzung Potistellung zu PWM Werten, erbitte Hilfe on: March 03, 2013, 05:44:35 am
Quote
Du kontrollierst den Taster und wen dieser gedrückt wird (zB LOW-HIGH-Übergang) Speicherst Du den Analogwert ab un setzt eine Statusvariable auf 1. Beim Drücken des zweiten Tasters setzt Du die Statusvariable auf 0.
Solange diese Statusvariable 1 ist nimmst Du den gespeicherten Wert ansonsten den gelesenen Analogwert von den Potis.

Falls es Dauerhaft (als auch nach den Ausschalten, Stromausfall) sein soll dann mußt Du die Variablen ins interne EEProm schreiben.

Ja, die Werte sollen fest im EEProm gespeichert werden, nicht im RAM.

Ansonsten:
Ich habe jetzt erst einmal verstanden, dass mein Vorhaben mit dem Abspeichern und Reproduzieren der Werte grundsätzlich möglich ist. Sehr gut.
Wie ich das umsetze, was du schreibst, muss ich erst noch lernen, ich verstehe aber schon mal den Ansatz.

Danke Uwe

stringwalker
14  International / Deutsch / Re: Umsetzung Potistellung zu PWM Werten, erbitte Hilfe on: March 02, 2013, 05:36:34 pm
Hey, es funktioniert inzwischen ganz hervorragend!!
Danke an alle, die mir geholfen haben, ohne euch hätte ich es nämlich nicht hingekriegt.

Ich mache es mit der map/switch/case Methode - eigentlich doch ganz easy, wenn man das erst einmal kapiert hat.

Gunther:
"lineare Interpolation c++", danke noch für den Begriff, das ist auch sehr interessant, da tun sich für meine analogen Entwicklungen ungeahnte Möglichkeiten auf.

Uwe:
Ich ahne entfernt, dass sich mit deinem Vorschlag mein Projekt wesentlich weniger aufwändig gestalten würde... smiley


Jetzt habe ich (klar) auch noch eine Anschlussfrage zu meinem LED Projekt:

Z.Zt. erhalten doch, je nach Potistellung, meine beiden LEDs ihre unterschiedlichen, individuellen PWM Werte. Könnte man nun  mit dem Arduino diese Werte mit dem Drücken eines Tasters dauerhaft abspeichern, um sie dann irgendwann durch Drücken eines anderen Tasters wieder an den gleichen Ausgängen auszugeben?

Bin nicht sicher, ob das jetzt hier noch her gehört oder besser in ein neues Thema. In der Suche finde ich nichts Passendes, vielleicht formuliere ich das Problem aber dort auch nur nicht richtig.

Grüße an alle

stringwalker


15  International / Deutsch / Re: Umsetzung Potistellung zu PWM Werten, erbitte Hilfe on: March 01, 2013, 07:06:14 pm
Danke, mkl0815, ich denke, du hast genau erkannt, worum es mir geht.

Die Switch/Case Lösung ist erst einmal durch ihre klare Struktur für mich leichter zu verstehen, und da ich zwei LEDs unterschiedlich mit dem Poti ansteuern will, vielleicht auch die richtige.

Die Lösung mit den Arrays hört sich natürlich schon sehr elegant an, ich fürchte aber, ich könnte sie mit meinem derzeitigen Wissen noch nicht umsetzen. damit befasse ich mich aber unbedingt noch.

Zu deiner Frage nach dem Poti und den Winkelbereichen:

Das Poti wird ein lineares sein, wäre aber im Prinzip auch egal, ich biege mir ja softwaremäßig ohnehin eine eigene Kennlinie zurecht. Ich will 64 Winkelbereiche haben, d.h. jeweils 16 Eingangswerte bekämen gleiche PWM Werte.

Ich hoffe, dass aufgrund dieser hohen Auflösung in Verbindung mit einem guten Poti das Springen zwischen zwei Zuständen nicht so störend sein wird.

Hier auch noch danke an JürgenR für die Idee mit if/ else Lösung.

Ein Anfänger sieht Land !  smiley


Grüße stringwalker


Pages: [1] 2