Error: 'PinStatus' does not name a type

Hallo zusammen,

ich bekomme beim Kompilieren meines Codes folgende Fehlermeldung:

error: 'PinStatus' does not name a type

Liegt das an der WiFiNiNa-Bibliothek? Was kann ich da tun?

Grüße

Du hast vermutlich den falschen Sketch geladen, sagt meine Kristallkugel.

Was meinst du mit "den falschen Sketch" geladen?

Wir kennen deinen Sketch nicht und auch deine Library nicht, wie sollen wir sehen, welchen Fehler du machst.

Ok, also der Sketch sieht so aus und ich nutze ein Arduino Uni WiFi. Ich habe den Code bereits etwas eingekürzt. Es muss wohl irgendwas mit der Version der Bibliotheken zu tun haben.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//        Init
//
#include <SPI.h>
#include <WiFiNINA.h>
//
#include <PIDController.h>                                                    // Inkludieren Bibliothek fuer PID-Controller
PIDController pos_pid; 
//
#include <Servo.h>                                                            // Inkludieren Bibliothek fuer Servo
Servo myServo;
Servo myServo2;
//
#include "arduino_secrets.h" 
//
int schalter_kali =0;                                                         // Schalter fuer Kalibrierung
//
int counter=0;                                                                // Counter fuer das Auslesen der Zufallskartenwerte
//
int z=-1;                                                                     // Zaehler zum Speichern der Zufallskartenwerte im integer karte
//
int karte[52];                                                                // Speicher-Integer fuer die Zufallskartenwerte zur Weiterverarbeitung
//
volatile long int encoder_pos = 0;
int akt_encoder_pos = 0;
int akt_encoder_pos_2 = 0;
//
char incomingByte;                                                            // Eingehende Bytes fuer Trigger Serial Monitor
//
char ssid[] = "bla";
char pass[] = "bla";
int keyIndex = 0;
int status = WL_IDLE_STATUS;
//
WiFiServer server(80);
//
int motor_value = 255;                                                        // Motor-Wert
unsigned long start0;                                                         // Startwert fuer millis() 
unsigned long start1;                                                         // Startwert fuer millis()
unsigned long start2;                                                         // Startwert fuer millis()
unsigned long start3;                                                         // Startwert fuer millis()
unsigned long run_led_servo;                                                  // Startwert fuer millis()
//
//
//  Erklaerung zu cards_value
//
//  Jeder der 52 Karten wird ein Impulswert zugeordnet, auf den mit dem PID-Regler eingeregelt wird
//  Der Ecnoder registriert 823,13 PPR (pulses per revolution)
//  Es gibt 52 Anfahrpositionen
//  Der Abstand zwischen jeder der 52 Positionen ist also 823,13/52=15,8294 Impulse
//  Durch das Getriebe von 100/17=5,88 ergeben sich also 15,8294*5,88=93,114 Impulse zwischen zwei Karten     
int cards_value[ 52 ][ 2 ] = {
{1,  2328  },
{2, 2235  },
{3, 2142  },
{4, 2049  },
{5, 1955  },
{6, 1862  },
{7, 1769  },
{8, 1676  },
{9, 1583  },
{10,  1490  },
{11,  1397  },
{12,  1304  },
{13,  1210  },
{14,  1117  },
{15,  1024  },
{16,  931 },
{17,  838 },
{18,  745 },
{19,  652 },
{20,  559 },
{21,  466 },
{22,  372 },
{23,  279 },
{24,  186 },
{25,  93  },
{26,  0 },
{27,  4749  },
{28,  4656  },
{29,  4563  },
{30,  4469  },
{31,  4376  },
{32,  4283  },
{33,  4190  },
{34,  4097  },
{35,  4004  },
{36,  3911  },
{37,  3818  },
{38,  3725  },
{39,  3631  },
{40,  3538  },
{41,  3445  },
{42,  3352  },
{43,  3259  },
{44,  3166  },
{45,  3073  },
{46,  2980  },
{47,  2887  },
{48,  2793  },
{49,  2700  },
{50,  2607  },
{51,  2514  },
{52,  2421  }
};
//
//
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//        VOID SETUP
//
//
//  0.)
void setup() {
//    
Serial.begin(9600);                                                           // Starten des Serial Monitors mit Baudrate 9600 
//
  while (!Serial) {                                                           //Warten, bis die serielle Schnittstelle verbunden ist
  ;                             
  }
//

if (WiFi.status() == WL_NO_MODULE) {                                          // Wenn die Kommunikation mit dem WiFi-Modul fehltschlägt, dann Meldung
  Serial.println("Communication with WiFi module failed!");
  while (true);
 } 
//
String fv = WiFi.firmwareVersion();
if (fv < WIFI_FIRMWARE_LATEST_VERSION) {                                      // Wenn die aktuelle Firmware-Version veraltet ist, dann Meldung, dies zu beheben
    Serial.println("Please upgrade the firmware");
  }
//
while (status != WL_CONNECTED) {                                              // Wenn Kommunikation mit dem WiFi-Modul erfolgreich etabliert, dann Meldungen zu WFi ausgeben
  Serial.print("Attempting to connect to SSID: ");
  Serial.println(ssid);
  status = WiFi.begin(ssid, pass);
  delay(10000); 
  }  
//
server.begin();                                                               // start listening for incoming connections (start listening for clients) 
printWifiStatus();
//
myServo.attach(6);                                                            // Servo wird auf PIN 6 gelegt (Servo zum Ausschieben der Karten)
myServo2.attach(8);                                                           // Servo2 wird auf PIN 8 gelegt (Servo zum Kalibrieren)
myServo.write(0);                                                             // Servo wird auf Null gefahren
myServo2.write(0);                                                            // Servo2 wird auf Null gefahren
delay(500);
pinMode(2, INPUT);                                                            // PIN 2 ist ein INPUT (A-Signal Encoder)
pinMode(3, INPUT);                                                            // PIN 3 ist ein INPUT (B-Signal Encoder)
pinMode(4, OUTPUT);                                                           // PIN 4 ist ein OUTPUT fuer Kontrolllampe (Karten werden verteilt)
pinMode(5, INPUT);                                                            // PIN 5 ist ein INPUT (Interrupt-PIN fuer Speicherung Pos.1, siehe Ablaufplan oben)
pinMode(7, OUTPUT);                                                           // PIN 7 ist ein OUTPUT fuer Kontrolllampe (LED an/aus)
pinMode(9, OUTPUT);                                                           // PIN 9 ist ein OUTPUT (POWER DC-MOTOR fuer Steuergeraet)
pinMode(10, OUTPUT);                                                          // PIN 10 ist ein OUTPUT (POWER DC-MOTOR fuer Steuergeraet)
//
attachInterrupt(digitalPinToInterrupt(2), encoder, RISING);                   // Interrupt fuer DC-MOTOR-REGELUNG
attachInterrupt(digitalPinToInterrupt(5), schalter, RISING);                  // Interrupt fuer Speicherung Pos.1 zur Kalibrierung, siehe Ablaufplan oben
//
pos_pid.begin();                                                              // Beginn PID   
pos_pid.tune(100, 0, 2000);                                                   // Tuning Anteile P I D 
pos_pid.limit(-255, 255);                                                     // Grenzen Motor-Wert
}
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//        VOID LOOP
//
void loop() {
//  
//
//  1.)
WiFiClient client = server.available();                                       // Abfrage, ob WiFi-Client verfuegbar ist
  if (client) {                                                               // Wenn der Client verfuegbar ist, dann
  String currentLine= "";                                                     // einen leeren String namens currentLine anlegen
//
    while (client.connected()) {                                              // waehrend der Client verfuegbar ist, tue
      if (client.available()) {                                               // wenn der Client verfuegbar ist, dann
        char c = client.read();                                               // in c wird die Info, die aus dem Client kommt, geschrieben
//
          if (c == '\n') {                                                    // wenn ein Newline-Character auftritt ... 
            if (currentLine.length() == 0) {                                  // ...und die Laenge des Newline-Characters Null ist
              client.println("HTTP/1.1 200 OK");
              client.println("Content-Type:text/html");
              client.println();                                               // the connection will be closed after completion of the response
              client.print("Value at A0 is ");                                // refresh the page automatically every 5 sec
              client.print(analogRead(A0));
              client.print("<br>");
              client.println();
              break;
              }
           else {
  if (counter ==1) {                                                          // Programm zum Speichern der als String uebermittelten Zufallszahlen in einem Array karte
  z=-1; 
  Serial.println(F("\nProgrammstart"));
  Serial.println(currentLine.indexOf('['));
  Serial.println(currentLine.lastIndexOf(']'));
  currentLine = currentLine.substring(1 + currentLine.indexOf("["), currentLine.lastIndexOf(']'));
  Serial.println(currentLine);
  currentLine.replace("%22", "");
  currentLine.replace("%20", "");
  currentLine.replace(",[]", "");
  Serial.println(currentLine);
  //char * str = currentLine.c_str();
  //const char * stri;
  char * str;
  strcpy(str,currentLine.c_str());
  char * pch;
  pch = strtok (str, ",");
  while (pch != NULL)
  {
    z=z+1;
    Serial.print(pch);
    Serial.print('\t');
    Serial.println(atoi(pch));
    karte[z]=atoi(pch);                                                        // Achtung !!! karte enthält nicht nur alle Karten, sondern als letzten zahlenbehafteten Eintrag auch die Anzahl der Spieler
    pch = strtok (NULL, " ,.-");
    //Serial.println(karte[z]);
    } 
  for(int i = 0; i < 22; i++){
  Serial.println(karte[i]);
  } 
 }
counter=counter+1;       
//
//                      
             currentLine = "";
             }
           } else if (c != '\r') {                                             // wenn ein Character in der current line ist, dann
              currentLine += c;                                                // currentLine = currentLine +c
              }
//
//
//  2.1)
if (currentLine.endsWith("GET /H")) {                                          // wenn die aktuelle Line mit /H endet, dann Test-LED an
          digitalWrite(7, HIGH);
          Serial.println("check_an");
}                                                                              
//
//
//
//
//      
   }                                                                           // Ende if client available
  }                                                                            // Ende if client connected                               
client.stop();                                                                 // Client stop 
 }                                                                             // Ende if client
}                                                                              // Ende void loop
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//        VOIDS
//
//  Interrupt fuer Kalibrierung
//
void schalter() {
akt_encoder_pos = encoder_pos;
}
//
//  Interrupt fuer Motorsteuerung
//
void encoder(){

  if(digitalRead(3) == HIGH){
    encoder_pos++;
  }else{
    encoder_pos--;
  }
}
//
//  Motor im Uhrzeigersinn drehen
//
void MotorClockwise(int power){
  if(power > 100){
  analogWrite(9, power);
  digitalWrite(10, LOW);
  digitalWrite(13, HIGH);
  }else{
    digitalWrite(9, LOW);
    digitalWrite(10, LOW);
    digitalWrite(13, LOW);
  }
}
//
// Motor gegen den Uhrzeigersinn drehen
//
void MotorCounterClockwise(int power){
  if(power > 100){
  analogWrite(10, power);
  digitalWrite(9, LOW);
  digitalWrite(12, HIGH);
  }else{
    digitalWrite(9, LOW);
    digitalWrite(10, LOW);
    digitalWrite(12, LOW);
  }
}
//
// WiFi-Status printen
//
void printWifiStatus() {
  // print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // print your board's IP address:
  Serial.print(F("IP: "));Serial.println(WiFi.localIP());
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);

  // print the received signal strength:
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
}

Und dabei die Stelle mit PinStatus rausgeschnitten.....?

Wie wäre es denn mal mit der vollständigen Fehlermeldung?

Das ist optimal, sehr Gut....besser gehts nicht.

Wo bitte ist der Fehler ?
Meine Kristallkugel findet den gemeldeten Fehler nicht.

Irgendwie fühle ich mich verarscht.

Der Fehler ist:

C:\Users\PK\Documents\Arduino\libraries\WiFiNINA\src/utility/wifi_drv.h:293:12: error: 'PinStatus' does not name a type
     static PinStatus digitalRead(uint8_t pin);

Ich verarsche hier niemanden. Aber vielleicht erkennt man ja direkt an der Meldung "PinStatus does not name...", worum es geht. Das ist ja die eigentliche Frage gewesen.

Was bringt das, wenn deine Frage nichts mit dem gezeigten Sketch zu tun hat ?

Also wenn ich den gezeigten Sketch kompiliere, kommt genau diese Fehlermeldung.

Schön für dich....bei mir nicht, da ich nicht deine Hardware habe.

Also wenn du den Sketch geheim hältst, dann bin ich raus.
Da ist mir meine Zeit zu schade für deinen Müll.

Ich habe den Sketch doch oben gepostet...

Ach....und wo steht da PinStatus ?

....ok, kein Problem.

Ja das ist wahrscheinlich ein Teil des Problems... Nirgends. Früher lief das Ding ja... Jetzt kommt so ein Fehler...

Sowas hatten wir doch schon mal....wirklich sehr seltsam.

Machst Du jetzt für jede Fehlermeldung einen eigenen Thread auf?
Das dürfte nach hinten losgehen.

Gruß Tommy