immer implizite Deklaration Fehler

Ich bekomme immer diesen Fehler beim kompilieren. Ich veränderte den code, der ausgeführt wird auf einem arduino laufen auf meinem raspberry pi.

test1.c: In function ‘loop’:
test1.c:24:3: warning: implicit declaration of function ‘rotateDeg’ [-Wimplicit-function-declaration]
test1.c:33:3: warning: implicit declaration of function ‘rotate’ [-Wimplicit-function-declaration]
test1.c: At top level:
test1.c:42:6: warning: conflicting types for ‘rotate’ [enabled by default]
test1.c:33:3: note: previous implicit declaration of ‘rotate’ was here
test1.c: In function ‘rotate’:
test1.c:46:3: warning: implicit declaration of function ‘abs’ [-Wimplicit-function-declaration]
test1.c: At top level:
test1.c:61:6: warning: conflicting types for ‘rotateDeg’ [enabled by default]
test1.c:24:3: note: previous implicit declaration of ‘rotateDeg’ was here
/usr/lib/gcc/arm-linux-gnueabihf/4.6/../../../arm-linux-gnueabihf/crt1.o: In function `_start':
(.text+0x34): undefined reference to `main'
collect2: ld returned 1 exit status

Hier ist mein source code:

#include <wiringPi.h>
#include <stdio.h>
#include <stdio.h>

#define DIR_PIN 0
#define STEP_PIN 3

void setup() { 
  pinMode(DIR_PIN, OUTPUT); 
  pinMode(STEP_PIN, OUTPUT); 
} 

void loop(){ 

  rotateDeg(360, 1); 
  delay(1000);   
  rotateDeg(-360, .1);  //reverse
  delay(1000); 
  rotate(1600, .5); 
  delay(1000); 

  rotate(-1600, .25); //reverse
  delay(1000); 
}

void rotate(int steps, float speed){ 
  //rotate a specific number of microsteps (8 microsteps per step) - (negitive for reverse movement)
  //speed is any number from .01 -> 1 with 1 being fastest - Slower is stronger
  int dir = (steps > 0)? HIGH:LOW;
  steps = abs(steps);

  digitalWrite(DIR_PIN,dir); 

  float usDelay = (1/speed) * 70;

  for(int i=0; i < steps; i++){ 
    digitalWrite(STEP_PIN, HIGH); 
    delayMicroseconds(usDelay); 

    digitalWrite(STEP_PIN, LOW); 
    delayMicroseconds(usDelay); 
  } 
} 

void rotateDeg(float deg, float speed){ 
  //rotate a specific number of degrees (negitive for reverse movement)
  //speed is any number from .01 -> 1 with 1 being fastest - Slower is stronger
  int dir = (deg > 0)? HIGH:LOW;
  digitalWrite(DIR_PIN,dir); 

  int steps = abs(deg)*(1/0.225);
  float usDelay = (1/speed) * 70;

  for(int i=0; i < steps; i++){ 
    digitalWrite(STEP_PIN, HIGH); 
    delayMicroseconds(usDelay); 

    digitalWrite(STEP_PIN, LOW); 
    delayMicroseconds(usDelay); 
  } 
}

InformationsquelleAutor Yamaha32088 | 2013-07-26

arduino c raspberry-pi

8

Erhalten Sie eine implizite Deklaration Warnung, wenn es eine implizit deklarierte Funktion.

Eine implizit deklarierte Funktion ist eine Funktion, die weder eine
Prototyp noch eine definition, und dass ist der Grund, warum ein compiler nicht überprüfen kann
,, was willst du mit der-Funktion.

Wenn keine Vorherige Deklaration einer Funktion ist, dann ist seine erste Instanz davon ausgegangen, dass eine Deklaration implizit mit Rückgabetyp int und nichts ist ausgegangen über die Parameter.

Lassen Sie eine Erklärung der Funktionen rotate und rotatedeg wie diese :
```
void rotate (int , float );
```
und
```
void rotateDeg (float , float );
```
Bevor Sie es in der Schleife :
```
void loop(){ 

  rotateDeg(360, 1); 
  ....
  ....
  rotate(1600, .5); 
  ... 
  rotate(-1600, .25); //reverse
  delay(1000); 
}
```
Verwenden auch #include<math.h> vor der Verwendung von mathematischen Funktionen wie abs(); .

Die Quintessenz ist , Sie haben, um Ihren compiler wissen über die Funktionen, die Sie verwenden.

Die arduino IDE versteckt diese Anforderung von dem Benutzer, so dass es einfacher zu schreiben, einfacher arduino Skizzen, aber als Sie entdeckt haben, auf Kosten von nicht-standard-C.

InformationsquelleAutor 0decimal0
2

Müssen Sie die Deklarationen der Funktionen rotate und rotateDeg usw., bevor Sie anrufen. Oder besser, legen Sie die Deklarationen in eine header-und include es in der Anfang.

Für die Funktion abs müssen Sie include <math.h>

, Warum Sie diese Warnungen: Angesichts dieses einfache Programm:
```
int main(void)
{
    func();
    return 0;
}
void func(void)
{
    //do something
}
```
Der compiler sah func vor sah seine Erklärung, also compiler generiert einen impliziten Deklaration: int func();, der Rückgabetyp ist int standardmäßig. Das ist nicht, was Sie meinte. Um es zu korrigieren, verwenden Sie diese:
```
void func(void);
int main(void)
{
    func();
    return 0;
}
void func(void)
{
    //do something
}
```
Beachten Sie auch, dass implizite Deklaration der Funktion legal ist in C89, aber entfernt wurde in C99.

InformationsquelleAutor Yu Hao
1

Teilen Sie der compiler wissen über die Funktion, bevor Sie es verwenden. Sie in der Regel tun dies in einer .h-Datei, die Sie enthalten, aber Sie können einfach schreiben Sie die Funktion, bevor Sie es nennen, als gut.

C-compiler ist ein one-pass compiler. Es beginnt am Anfang und wenn es dann zu Ende ist, ist es fertig. Wenn er sieht Sie mit der Funktion bevor Sie haben gesagt, der compiler, dass es existiert, dann bekommen Sie diese Fehlermeldung/Warnung.

Können Sie einfach sagen
```
void my_func(int); 
```
oben in deinem code, und dann wird der compiler wissen, was Sie meinen, wenn Sie rufen my_func später in Ihrem code, auch wenn es noch nicht gesehen haben, der eigentliche Inhalt der Funktion.

InformationsquelleAutor xaxxon
1

Der Grund, warum das wieder als ein Fehler ist, dass C keine read-ahead zu finden Funktionsdeklarationen. Stattdessen erstellt es eine implizite Funktion entspricht der Signatur, die Sie verwendet.

Den code rotateDeg(-360, .1) schafft eine implizite Funktion mit einer Signatur der Methode von roatateDeg(int deg, double speed) weil die Typen, die diese Anzahl Literale parser.

Um dieses problem zu lösen, fügen Sie die Zeile
```
void rotateDeg(float deg, float speed);
```
an die Spitze des Codes, nach dem die Einfuhren. Dies erklärt ausdrücklich die Methode vor seiner Verwendung, und entfernt sowohl die Methode der Konflikt-und der implicit declaration Warnung.

InformationsquelleAutor cptroot
1

Andere Lösung ist einfach legen Sie Ihre Funktionen vor main. Dies ist nützlich beim schreiben funktioniert, und Sie haben keine Feste Funktion, Parameter und Typen.

Nach dem Aufbau Funktionen, Header, wie bereits gesagt, stellen Prototypen, bevor Sie Haupt-oder setzen Sie Sie in eine header-Datei, und schließen Sie es.

InformationsquelleAutor LS_ᴅᴇᴠ

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.