Mehrere FSR-Sensoren mit Arduino Mega

reschko · September 25, 2021, 7:59am

Hallo zusammen,
Ich möchte gerne im Rahmen eines Projektes Drücke mit Hilfe von FSR-Sensoren messen. Ich habe den grundlegenden Quellcode schon fertig. Nur dieser funktioniert noch nicht so ganz. Ich bekomme in der Zeile 11 diesen Fehler: array bound is not an integer constant before ' ]' token. Ich habe keinen Plan, was das zu bedeuten hat. Der Quellcode ist unter Pastebin hinterlegt. Vielleicht kann da ja mal jemand drüber schauen.

Danke und viele Grüße
Robert

Tommy56 · September 25, 2021, 8:25am

Setze Deinen Code bitte direkt ins Forum. Benutze dazu Codetags (</>-Button oben links im Forumseditor).

Gruß Tommy

StefanL38 · September 25, 2021, 8:25am

Es wird hier nicht so gerne gesehen wenn code irgendwo anders deponiert wird.
Es gibt eine einfache Möglichkeit den Code direkt hier zu posten.

In der Arduino-IDE Rechtsklick mit der Maus
die Option für Forum kopieren
und dann den Inhalt der Zwischenablage einfach in ein Posting pasten.
vgs

reschko · September 25, 2021, 9:22am

Danke für die Antworten. Dann etwa so?



int fsrPins[] = {A0, A1, A2, A3, A4, A5, A6, A7, A8, A9}; // the FSR and 10K pulldown are connected to a0

int Sensoranzahl = sizeof(fsrPins);

unsigned long fsrReading[Sensoranzahl];     // the analog reading from the FSR resistor divider
unsigned long fsrVoltage[Sensoranzahl];     // the analog reading converted to voltage
unsigned long fsrResistance[Sensoranzahl];  // The voltage converted to resistance, can be very big so make "long"
unsigned long fsrConductance[Sensoranzahl];
long fsrForce[Sensoranzahl];       // Finally, the resistance converted to force

for (i = 0; i < Sensoranzahl; i++) {

  fsrReading[i] = analogRead(fsrPin[i]);
  Serial.print("Analog reading = ");
  Serial.println(fsrReading[i]);

  fsrVoltage[i] = map(fsrReading[i], 0, 1023, 0, 5000);
  Serial.print("Voltage reading in mV = ");
  Serial.println()fsrVoltage[i]);
}

if (fsrVoltage[i] == 0) {
  Serial.println("No pressure");
} else {
  // The voltage = Vcc * R / (R + FSR) where R = 10K and Vcc = 5V
  // so FSR = ((Vcc - V) * R) / V
  fsrResistance[i] = 5000 - fsrVoltage[i];     // fsrVoltage is in millivolts so 5V = 5000mV
  fsrResistance[i] *= 10000;                // 10K resistor
  fsrResistance[i] /= fsrVoltage[i];
  Serial.print("FSR resistance in ohms = ");
  Serial.println(fsrResistance[i]);

  fsrConductance[i] = 1000000;           // we measure in micromhos so
  fsrConductance[i] /= fsrResistance[i];
  Serial.print("Conductance in microMhos: ");
  Serial.println(fsrConductance[i]);

  // Use the two FSR guide graphs to approximate the force
  if (fsrConductance[i] <= 1000) {
    fsrForce[i] = fsrConductance[i] / 80;
    Serial.print("Force in Newtons: ");
    Serial.println(fsrForce[i]);
  } else {
    fsrForce[i] = fsrConductance[i] - 1000;
    fsrForce[i] /= 30;
    Serial.print("Force in Newtons: ");
    Serial.println(fsrForce[i]);
  } 9807
}
Serial.println("--------------------");
delay(1000);
}
}

Viele Grüße

Miq1 · September 25, 2021, 9:32am

Du musst Sensoranzahl zumindest als sizeof(fsrPins)/sizeof(int) berechnen, wei sizeof() die Größe in Bytes und nicht in Anzahl Indizes wiedergibt.
Und du verwendest fsrPin statt fsrPins!

Miq1 · September 25, 2021, 9:36am

Nur so aus Neugier, weil ich mich gerade selbst mit FSRs beschäftige: welche benutzt du da und wofür willst du sie einsetzen?

reschko · September 25, 2021, 9:45am

ich verwenden FSR-Sensoren vom Typ FSR 151 NS.

Ich möchte eine Kräfteermittlung für Alltagssituationen durchführen. Diese anschließen über Datastream auf exel importieren, um diese dann auszuwerten.

reschko · September 25, 2021, 9:47am

Wie könnte ein korrigiertes Beispiel aussehen?

Miq1 · September 25, 2021, 9:54am

Habe ich doch oben geschrieben? Sensoranzahl korrekt berechnen und das "s" bei fsrPin ergänzen

reschko · September 25, 2021, 9:59am

Ok so?

int fsrPins[] = {A0, A1, A2, A3, A4, A5, A6, A7, A8, A9}; // the FSR and 10K pulldown are connected to a0

int Sensoranzahl = sizeof(fsrPins)/sizeof(int);

unsigned long fsrReading[Sensoranzahl];     // the analog reading from the FSR resistor divider
unsigned long fsrVoltage[Sensoranzahl];     // the analog reading converted to voltage
unsigned long fsrResistance[Sensoranzahl];  // The voltage converted to resistance, can be very big so make "long"
unsigned long fsrConductance[Sensoranzahl];
long fsrForce[Sensoranzahl];       // Finally, the resistance converted to force

for (i = 0; i < Sensoranzahl; i++) {

  fsrReading[i] = analogRead(fsrPins[i]);
  Serial.print("Analog reading = ");
  Serial.println(fsrReading[i]);

  fsrVoltage[i] = map(fsrReading[i], 0, 1023, 0, 5000);
  Serial.print("Voltage reading in mV = ");
  Serial.println()fsrVoltage[i]);
}

if (fsrVoltage[i] == 0) {
  Serial.println("No pressure");
} else {
  // The voltage = Vcc * R / (R + FSR) where R = 10K and Vcc = 5V
  // so FSR = ((Vcc - V) * R) / V
  fsrResistance[i] = 5000 - fsrVoltage[i];     // fsrVoltage is in millivolts so 5V = 5000mV
  fsrResistance[i] *= 10000;                // 10K resistor
  fsrResistance[i] /= fsrVoltage[i];
  Serial.print("FSR resistance in ohms = ");
  Serial.println(fsrResistance[i]);

  fsrConductance[i] = 1000000;           // we measure in micromhos so
  fsrConductance[i] /= fsrResistance[i];
  Serial.print("Conductance in microMhos: ");
  Serial.println(fsrConductance[i]);

  // Use the two FSR guide graphs to approximate the force
  if (fsrConductance[i] <= 1000) {
    fsrForce[i] = fsrConductance[i] / 80;
    Serial.print("Force in Newtons: ");
    Serial.println(fsrForce[i]);
  } else {
    fsrForce[i] = fsrConductance[i] - 1000;
    fsrForce[i] /= 30;
    Serial.print("Force in Newtons: ");
    Serial.println(fsrForce[i]);
  } 9807
}
Serial.println("--------------------");
delay(1000);
}
}

Miq1 · September 25, 2021, 10:14am

Keine Ahnung - compiliert es ohne Fehler? Läuft es bei Dir?

StefanL38 · September 25, 2021, 12:15pm

Die Fehlermeldung sagt doch was dem Compiler nicht gefällt

array bound is not an integer constant before ' ]' token

getreu dem Motto wenn es so nicht geht probiere etwas anderes vielleicht funktioniert es dann auch nicht ;-))

wenn du die Zeile

int Sensoranzahl = sizeof(fsrPins)/sizeof(int);

änderst in

const int Sensoranzahl = sizeof(fsrPins)/sizeof(int);

const int Sensoranzahl

dann bekommst du eine neue Fehlermeldung weiter unten im code
expected unqualified-id before 'for'

Die Zeilen die du gepostest hast sind noch lange kein vollständiger sketch
da gehört mindestens

void setup () {}
void loop () {}

dazu

vgs

agmue · September 25, 2021, 1:47pm

Eher so ist der Kompiler glücklich:

const int fsrPins[] = {A0, A1, A2, A3, A4, A5, A6, A7, A8, A9}; // the FSR and 10K pulldown are connected to a0

const int Sensoranzahl = sizeof(fsrPins) / sizeof(int);

unsigned long fsrReading[Sensoranzahl];     // the analog reading from the FSR resistor divider
unsigned long fsrVoltage[Sensoranzahl];     // the analog reading converted to voltage
unsigned long fsrResistance[Sensoranzahl];  // The voltage converted to resistance, can be very big so make "long"
unsigned long fsrConductance[Sensoranzahl];
long fsrForce[Sensoranzahl];       // Finally, the resistance converted to force
int i;

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

void loop()
{
  for (i = 0; i < Sensoranzahl; i++) {

    fsrReading[i] = analogRead(fsrPins[i]);
    Serial.print("Analog reading = ");
    Serial.println(fsrReading[i]);

    fsrVoltage[i] = map(fsrReading[i], 0, 1023, 0, 5000);
    Serial.print("Voltage reading in mV = ");
    Serial.println(fsrVoltage[i]);
  }

  if (fsrVoltage[i] == 0) {
    Serial.println("No pressure");
  } else {
    // The voltage = Vcc * R / (R + FSR) where R = 10K and Vcc = 5V
    // so FSR = ((Vcc - V) * R) / V
    fsrResistance[i] = 5000 - fsrVoltage[i];     // fsrVoltage is in millivolts so 5V = 5000mV
    fsrResistance[i] *= 10000;                // 10K resistor
    fsrResistance[i] /= fsrVoltage[i];
    Serial.print("FSR resistance in ohms = ");
    Serial.println(fsrResistance[i]);

    fsrConductance[i] = 1000000;           // we measure in micromhos so
    fsrConductance[i] /= fsrResistance[i];
    Serial.print("Conductance in microMhos: ");
    Serial.println(fsrConductance[i]);

    // Use the two FSR guide graphs to approximate the force
    if (fsrConductance[i] <= 1000) {
      fsrForce[i] = fsrConductance[i] / 80;
      Serial.print("Force in Newtons: ");
      Serial.println(fsrForce[i]);
    } else {
      fsrForce[i] = fsrConductance[i] - 1000;
      fsrForce[i] /= 30;
      Serial.print("Force in Newtons: ");
      Serial.println(fsrForce[i]);
    }
  }
  Serial.println("--------------------");
  delay(1000);
}

Ich habe nicht auf Funktion oder Schönheit geachtet!

reschko · September 25, 2021, 2:02pm

Ich werde verrückt :D.
Es klappt.. Ich werde es am Montag in der Firma am Gerät testen.
Ich muss den Code weiter hin noch um die kalibrierten Bedingungen, die ich anhand eines Sensors aufgestellt habe, erweitern.
Besten Dank Euch allen.

Miq1 · September 25, 2021, 2:10pm

Du benutzt ja kommerzielle Sensoren. Haben die ein Driftverhalten, wenn sie länger belastet werden, oder ist der Widerstandswert bei gleicher Last immer konstant?

Ich frage, weil ich Velostat als Sensormaterial benutze, was unter Dauerlast zur plastischen Verformung und damit Drift des Widerstandswertes neigt.

agmue · September 25, 2021, 2:20pm

Stattdessen könntest Du auch den Code optimieren.

analogRead gibt Integer-Werte zwischen 0 und 1023 zurück, warum nutzt Du unsigned long fsrReading ? Lesestoff analogRead.
const int fsrPins benötigt 16 Bit für einen Pin, acht genügen auch.
const int Sensoranzahl wird wohl wegoptimiert, aber kannst Du mehr als 255 Pins nutzen?
if (fsrVoltage[i] == 0) { sollte vermutlich Teil der for-Schleife sein. Dann braucht es auch keine globale Variable i, sondern for ( byte i = 0; i < Sensoranzahl; i++) {.
Rechts vom Gleichheitszeichen wird mit int gerechnet, das könnte bei fsrResistance[i] *= 10000; problematisch werden. Eventuell ist fsrResistance[i] *= 10000UL; notwendig. Der Kompiler überrascht mich da immer wieder.

Vermutlich habe ich noch was übersehen, für ein ruhiges Wochenende ist es auf jeden Fall zu früh.

Zwei Widerstände oder ein Poti machen auch eine meßbare Spannung zum Testen

reschko · September 25, 2021, 3:46pm

Top besten Dank. Ich schaue mir das mal an. . Weiterhin ein schönes Wochenende.

reschko · September 27, 2021, 10:33am

Hallo

ich habe es mal getestet. Da ist irgend wo noch der Wurm drin. Ich habe mal zwei Bilder hoch geladen. Im ersten Bild wird der Sensor auf A0 belastet. Dort wird mir die fsrResistance falsch ausgerechnet und demzufolge auch fsrForce, obwohl die Grundwerte richtig sind.
Beim zweiten Bild wird der Sensor A1 belastet. Es wird der obere Bereich auch richtig ausgegeben, aber kein fsrResistance und auch kein fsrForce. Das gleiche zieht sich bis A9 so durch. Ich glaube der Fehler liegt in der Deklaration, aber ich bin auch noch sehr unwissend, was das betrifft :). Hat jemand einen Plan?

Beste Grüße
Robert

fett gedruckter Text```
const int fsrPins[] = {A0, A1, A2, A3, A4, A5, A6, A7, A8, A9}; // the FSR and 10K pulldown are connected to a0

const int Sensoranzahl = sizeof(fsrPins) / sizeof(int);

unsigned long fsrReading[Sensoranzahl]; // the analog reading from the FSR resistor divider
unsigned long fsrVoltage[Sensoranzahl]; // the analog reading converted to voltage
unsigned long fsrResistance[Sensoranzahl]; // The voltage converted to resistance, can be very big so make "long"
unsigned long fsrConductance[Sensoranzahl];
unsigned long fsrweight [Sensoranzahl];
long fsrForce[Sensoranzahl]; // Finally, the resistance converted to force
int i;

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

void loop()
{
for (i = 0; i < Sensoranzahl; i++) {

fsrReading[i] = analogRead(fsrPins[i]);
Serial.print("Analog reading = ");
Serial.println(fsrReading[i]);

fsrVoltage[i] = map(fsrReading[i], 0, 1023, 0, 5000);
Serial.print("Voltage reading in mV = ");
Serial.println(fsrVoltage[i]);

}

if (fsrVoltage[i] == 0) {
Serial.println("No pressure");
} else {
// The voltage = Vcc * R / (R + FSR) where R = 10K and Vcc = 5V
// so FSR = ((Vcc - V) * R) / V
fsrResistance[i] = 5000 - fsrVoltage[i]; // fsrVoltage is in millivolts so 5V = 5000mV
fsrResistance[i] *= 10000UL; // 10K resistor
fsrResistance[i] /= fsrVoltage[i];
Serial.print("FSR resistance in ohms = ");
Serial.println(fsrResistance[i]);

fsrConductance[i] = 500000;           // we measure in micromhos so
fsrConductance[i] /= fsrResistance[i];
Serial.print("Conductance in microMhos: ");
Serial.println(fsrConductance[i]);

          //0.5   51
if (fsrConductance[i] <= 5) {
  fsrForce[i] = fsrConductance[i] / 10 ;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}

      //0.75      76.5
  else{if (fsrConductance[i] <= 7.5) {
  fsrForce[i] = fsrConductance[i] / 10;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
     //1       101
  else{if (fsrConductance[i] <= 15) {
  fsrForce[i] = fsrConductance[i] / 15;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
   //1,25       126,5
  else{if (fsrConductance[i] <= 22.5) {
  fsrForce[i] = fsrConductance[i] / 18;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
   //1,5       152
  else{if (fsrConductance[i] <= 27.5) {
  fsrForce[i] = fsrConductance[i] / 18.3;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
    //1,75       177,5
  else{if (fsrConductance[i] <= 31.7) {
  fsrForce[i] = fsrConductance[i] / 18.1;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
     //2       203
  else{if (fsrConductance[i] <= 35.5) {
  fsrForce[i] = fsrConductance[i] / 17.75;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
   //2,25       228,5
  else{if (fsrConductance[i] <= 38) {
  fsrForce[i] = fsrConductance[i] / 16.8;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
   //2,5       254
  else{if (fsrConductance[i] <= 46.5) {
  fsrForce[i] = fsrConductance[i] / 18.6;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
   //2,75       279,5
  else{if (fsrConductance[i] <= 49.2) {
  fsrForce[i] = fsrConductance[i] / 17.89;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
    //3       305
  else{if (fsrConductance[i] <= 54.3) {
  fsrForce[i] = fsrConductance[i] / 18.1;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
    //3,25       330,5
  else{if (fsrConductance[i] <= 61) {
  fsrForce[i] = fsrConductance[i] / 18.77;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
   //3,5       356
  else{if (fsrConductance[i] <= 63) {
  fsrForce[i] = fsrConductance[i] / 18;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
   //3,75       381,5
  else{if (fsrConductance[i] <= 67.5) {
  fsrForce[i] = fsrConductance[i] / 18;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
   //4       407
  else{if (fsrConductance[i] <= 69) {
  fsrForce[i] = fsrConductance[i] / 17.25;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  //4,25       432,5
  else{if (fsrConductance[i] <= 72.7) {
  fsrForce[i] = fsrConductance[i] / 17.1;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
   //4,5       458
  else{if (fsrConductance[i] <= 83) {
  fsrForce[i] = fsrConductance[i] / 18.4;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  //4,75       483,5
  else{if (fsrConductance[i] <= 87) {
  fsrForce[i] = fsrConductance[i] / 18.3;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  //5       509
  else{if (fsrConductance[i] <= 88.5) {
  fsrForce[i] = fsrConductance[i] / 17.7;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  //5,25       534,5
  else{if (fsrConductance[i] <= 91.5) {
  fsrForce[i] = fsrConductance[i] / 17.4;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  //5,5       560
  else{if (fsrConductance[i] <= 93.5) {
  fsrForce[i] = fsrConductance[i] / 17;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  //5,75       585,5
  else{if (fsrConductance[i] <= 97) {
  fsrForce[i] = fsrConductance[i] / 16.8;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  //6       611
  else{if (fsrConductance[i] <= 98.5) {
  fsrForce[i] = fsrConductance[i] / 16.4;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  //6,25       636,5
  else{if (fsrConductance[i] <= 99) {
  fsrForce[i] = fsrConductance[i] / 15.84;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}

  //6,5       662
  else{if (fsrConductance[i] <= 102.5) {
  fsrForce[i] = fsrConductance[i] / 15.77;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}

   //6,75       687,5
  else{if (fsrConductance[i] <= 104.6) {
  fsrForce[i] = fsrConductance[i] / 15.5;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
    //7       713
  else{if (fsrConductance[i] <= 105.5) {
  fsrForce[i] = fsrConductance[i] / 15.07;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
     //7,25       738,5
  else{if (fsrConductance[i] <= 112) {
  fsrForce[i] = fsrConductance[i] / 15.45;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  //7,5       764
  else{if (fsrConductance[i] <= 112.5) {
  fsrForce[i] = fsrConductance[i] / 15;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
   //7,75       789,5
  else{if (fsrConductance[i] <= 114) {
  fsrForce[i] = fsrConductance[i] / 14.71;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  //8       815
  else{if (fsrConductance[i] <= 115) {
  fsrForce[i] = fsrConductance[i] / 14.37;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
   //8,25       840,5
  else{if (fsrConductance[i] <= 116.6) {
  fsrForce[i] = fsrConductance[i] / 14.13;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
    //8,5       866
  else{if (fsrConductance[i] <= 117.7) {
  fsrForce[i] = fsrConductance[i] / 13.85;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
   //8,75       891,5
  else{if (fsrConductance[i] <= 119) {
  fsrForce[i] = fsrConductance[i] / 13.6;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
   //9       917
  else{if (fsrConductance[i] <= 120) {
  fsrForce[i] = fsrConductance[i] / 13.33;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  //9,25       942,5
  else{if (fsrConductance[i] <= 120.5) {
  fsrForce[i] = fsrConductance[i] / 13.03;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  //9,5       968
  else{if (fsrConductance[i] <= 121) {
  fsrForce[i] = fsrConductance[i] / 12.73;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  //9,75       993,5
  else{if (fsrConductance[i] <= 122.8) {
  fsrForce[i] = fsrConductance[i] / 12.59;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  //10       1019
  else{if (fsrConductance[i] <= 124) {
  fsrForce[i] = fsrConductance[i] / 12.4;
  fsrweight[i] =    fsrForce[i] / 9.81 * 1000 ;
  Serial.print("Gewichtskraft in Newton: ");
  Serial.println(fsrForce[i],4);
  Serial.print("Gewicht in gramm: ");
  Serial.println(fsrweight[i],4);}
  
  
 
  
  


      




       }}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}
}
 delay(2000);

}

my_xy_projekt · September 27, 2021, 10:46am

Kannst Du mal bitte in Deinem Post den kompletten Code markieren und oben auf das </> Symbol klicken?
Das ist so nicht lesbar.

Katsumi_S · September 27, 2021, 10:47am

Bitte Code immer in Code Tags (Preformatted Text) hier reinstellen. Sonst wird der Code von der Forensoftware verfälscht!

const int fsrPins[] = {A

Zum Bleistift wird aus den zwei [ ] ein [].

Gruß, Jürgen

Topic		Replies	Views
FSR SENSOR PROGRAMMING Programming	29	4098	May 5, 2021
Installing 4 fsr Pressuresensors Programming	13	688	May 6, 2021
newbie creating fsr voting system Sensors	32	8590	May 6, 2021
how to write a code for multiple fsr sensor? Sensors	9	7725	May 6, 2021
Array di frazionari Software	30	8535	May 7, 2021

Mehrere FSR-Sensoren mit Arduino Mega

Related topics