Kraftsensoren für den Physikunterricht mit Arduino

[Christoph E. (stoppi)]

Hallo!

Als schnelles Zwischenprojekt habe ich mir zwei Kraftsensoren für den 
Physikunterricht gebastelt. Basis ist in beiden Fällen ein Arduino, 
einmal ein Nano und beim anderen ein Mega.

Beim Modell mit dem 16x2 display kommt ein 100g-Wägezelle zum Einsatz, 
bei jenem mit dem 320x480 pixel display eine 1kgWägezelle.

Damit erhalte ich eine Auflösung von 0.1 mN bzw. 10 mN.

Mit den Sensoren lassen sich dann allerhand physikalische Experimente 
quantitativ und qualitativ erfassen wie zum Beispiel die Bestimmung der 
Oberflächenspannung mit der Ringmethode oder die Bestimmung des Haft- 
und Gleitreibungskoeffizienten.

Gekostet hat mich der Spaß für beide Modelle wohl nicht einmal 30 Euro. 
Hier gibt es ja eine Menge Leute, die über Arduino gewaltig lästern. Ich 
finde ihn für meine Zwecke (in der Regel Physikexperimente bzw. 
Messgeräte für den Physikunterricht) einfach ideal. Habe bis jetzt noch 
jede meiner Ideen damit umsetzen können und zwar vom einer einfachen 
Sonographie, über Lasermikroskop bis hin zum Segway. Und das ganz ohne 
shield ;-)

#include <UTFT.h>
#include <Wire.h>
#include <HX711.h>                       

HX711 scale(A1, A0);  

long Rohwert;                  // vom HX711 gelieferter Rohwert
long offset = 5300;            // offset
float Scale = 50000;           // scale
float Kraft_alt, Kraft_neu;    // berechnete Kraft in N


// Declare which fonts we will be using
extern uint8_t SmallFont[];

UTFT myGLCD(ILI9486,38,39,40,41);

int i, j;                 // Zählvariable

const int offsetPin = 2;     // the number of the pushbutton pin
int offsetState = 0;         // variable for reading the pushbutton status
const int startPin = 3;      // the number of the switch pin
int startState = 0;          // variable for reading the switch status



// ====================================
// ===                              ===
// ===            SETUP             ===
// ===                              ===
// ====================================

void setup()
   {
    Serial.begin(9600);
   //    while(!Serial);    // time to get serial running

    pinMode(offsetPin, INPUT);
    pinMode(startPin, INPUT);
  
    // Setup the LCD
    myGLCD.InitLCD();
    myGLCD.setFont(SmallFont);    
    myGLCD.clrScr();
   
    myGLCD.setColor(255, 255, 0);
    myGLCD.fillRect(0, 0, 479, 13);
    myGLCD.setColor(0, 0, 0);
    myGLCD.setBackColor(255, 255, 0);
    myGLCD.print("Newtonmeter - stoppi", CENTER, 1); 


    scale.set_gain(128);   // A-Kanal: gain = 64 oder 128; B-Kanal: fix 32

    Kraft_alt = 0.0;    
   }




// ====================================
// ===                              ===
// ===        HAUPTSCHLEIFE         ===
// ===                              ===
// ====================================

void loop()
   {    
    while(startState = digitalRead(startPin))   // Warten bis start-Taster betätigt wurde
       {        
        Rohwert = scale.read();              // Einlesen eines Rohwerts
  
        Kraft_neu = (Rohwert - offset) / Scale;  // Berechnung der Kraft in Newton

        //Serial.println(Kraft_neu);
        
        myGLCD.setColor(0, 255, 0);
        myGLCD.setBackColor(0, 0, 0);
        myGLCD.print("        ", 70, 18);
        myGLCD.printNumF(Kraft_neu, 2, 70, 18);

        offsetState = digitalRead(offsetPin);    // button for new tara (offset)
    
        if (offsetState == LOW)
           {        
            offset = scale.read();   // Einlesen eines Rohwerts zur Ermittlung des offsets            
           }       

        delay(20);
       }

    Kraft_alt = 0.0; 
    
    myGLCD.clrScr();
    
    myGLCD.setColor(255, 255, 0);
    myGLCD.fillRect(0, 0, 479, 13);
    myGLCD.setColor(0, 0, 0);
    myGLCD.setBackColor(255, 255, 0);
    myGLCD.print("Newtonmeter - stoppi", CENTER, 1);

    // Zeichnen der beiden Achsen
    
    myGLCD.setColor(255, 255, 255);
    myGLCD.drawLine(50,290,430,290);
    myGLCD.drawLine(50,20,50,290);

    myGLCD.setColor(255, 255, 255);
    myGLCD.setBackColor(0, 0, 0);
    myGLCD.print("F[N]", 5, 18);
    myGLCD.setColor(255, 255, 255);
    myGLCD.setBackColor(0, 0, 0);
    myGLCD.print("t[sec]", 420, 300);
                
    myGLCD.setColor(255, 255, 255);
    myGLCD.drawLine(45,290,50,290);
    myGLCD.drawLine(45,240,50,240);
    myGLCD.drawLine(45,190,50,190);
    myGLCD.drawLine(45,140,50,140);
    myGLCD.drawLine(45,90,50,90);
    myGLCD.drawLine(45,40,50,40);
        
    myGLCD.drawLine(50,290,50,295);
    myGLCD.drawLine(100,290,100,295);
    myGLCD.drawLine(150,290,150,295);
    myGLCD.drawLine(200,290,200,295);
    myGLCD.drawLine(250,290,250,295);
    myGLCD.drawLine(300,290,300,295);
    myGLCD.drawLine(350,290,350,295);
    myGLCD.drawLine(400,290,400,295);
        
    myGLCD.setColor(255, 255, 255);
    myGLCD.setBackColor(0, 0, 0);
    myGLCD.printNumI(0,30,285);
    myGLCD.printNumI(2,30,235);
    myGLCD.printNumI(4,30,185);
    myGLCD.printNumI(6,30,135);
    myGLCD.printNumI(8,30,85);
    myGLCD.printNumI(10,25,35);
       
    myGLCD.printNumI(0,48,300);
    myGLCD.printNumI(4,98,300);
    myGLCD.printNumI(8,148,300);
    myGLCD.printNumI(12,194,300);
    myGLCD.printNumI(16,244,300);
    myGLCD.printNumI(20,294,300);
    myGLCD.printNumI(24,344,300);
    myGLCD.printNumI(28,394,300);
        

    // graues Gitternetz zeichnen

    myGLCD.setColor(120, 120, 120);
    myGLCD.drawLine(51,265,430,265);
    myGLCD.drawLine(51,240,430,240);
    myGLCD.drawLine(51,215,430,215);
    myGLCD.drawLine(51,190,430,190);
    myGLCD.drawLine(51,165,430,165);
    myGLCD.drawLine(51,140,430,140);
    myGLCD.drawLine(51,115,430,115);
    myGLCD.drawLine(51,90,430,90);
    myGLCD.drawLine(51,65,430,65);
    myGLCD.drawLine(51,40,430,40);

    myGLCD.drawLine(100,40,100,289);
    myGLCD.drawLine(150,40,150,289);
    myGLCD.drawLine(200,40,200,289);
    myGLCD.drawLine(250,40,250,289);
    myGLCD.drawLine(300,40,300,289);
    myGLCD.drawLine(350,40,350,289);
    myGLCD.drawLine(400,40,400,289);

    
    myGLCD.setColor(0, 255, 0);
    
    for(i = 1; i <= 380; i++)
       {
        offsetState = digitalRead(offsetPin);    // button for new tara (offset)
    
        if (offsetState == LOW)
           {        
            offset = scale.read();   // Einlesen eines Rohwerts zur Ermittlung des offsets
           }

        
        //Rohwert = scale.read_average(2);   // Einlesen der gemittelten Rohwerten
        Rohwert = scale.read();              // Einlesen eines Rohwerts
  
        Kraft_neu = (Rohwert - offset) / Scale;  // Berechnung der Kraft in Newton

        //Serial.println(Rohwert);

        myGLCD.print("        ", 70, 18);
        myGLCD.printNumF(Kraft_neu, 2, 70, 18);
        
        if(Kraft_neu >= 0 && Kraft_neu <= 10)
           {
            //myGLCD.drawPixel(50 + i, 290 - Kraft * 25);
            myGLCD.drawLine(50 + (i - 1),290 - Kraft_alt * 25,50 + i,290 - Kraft_neu * 25);

            Kraft_alt = Kraft_neu;
           }
      
       }
               
   }

[Harald W. (wilhelms)]

Christoph E. schrieb:

> Hier gibt es ja eine Menge Leute, die über Arduino gewaltig lästern. Ich
> finde ihn für meine Zwecke (in der Regel Physikexperimente bzw.
> Messgeräte für den Physikunterricht) einfach ideal.

Nun, hier dient der Ardino wohl nur als Voltmeter. Das gleiche
könnte man wohl auch mit Loadzelle plus Panelmeter bauen.

[Günni (Gast)]

Für Sensoranwendungen finde ich den Arduino auch gut geeignet, wobei man 
für die Erfassung schnellerer Bewegungen notfalls auf 
Assemblerprogrammierung übergehen muss. Der Raspberry ist besser 
geeignet, wenn ein höherer Rechenaufwand entsteht, z.B. für 
Bildmustererkennung oder FFT-Analysen.

[Der Hugo (Gast)]

Ich finde die Idee sehr gut, das im Rahmen der Schule zu nutzen. Oftmals 
wird auf Arduino ja auch später im Rahmen der Ausbildung 
zurückgegriffen, z.B. an (Fach-)Hochschulen. Ich denke, man kann damit 
gar nicht früh genug anfangen, einfach ein Grundverständnis dafür zu 
schaffen und Interesse zu wecken.

Bei den Meisten von uns war das damals einfacher: Der C64 startete immer 
mit diesem "Basic" wo man dann seine Spiele starten konnte, irgendwann 
wollte man mal ausprobieren was das macht...

(Arduino-Bashing ist angebracht, wenn der Bachelor in der Firma damit 
ein "professionelles Produkt" entwickeln möchte, aber doch bestimmt 
nicht, wenn jemand damit zuhause sein Eigenheim automatisieren möchte 
oder andere für Technik begeistern möchte. Ich hätte mir damals einen 
Lehrer mit so viel Begeisterung für Technik gewünscht ...)

FFT Analyse in der Schule? An der FH gibts dafür den Teensy 4.0, an der 
Uni das Beispiel auf Seite 538ff ;-)