Forum: Mikrocontroller und Digitale Elektronik Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..


Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
von Philipp M. (lord-maricek)

Lesenswert?
• ▲
▼ 
Moin,

ich habe eine C++ Klasse geschrieben, die ich in mein AVR-gcc Programm 
einbinden will.

Ich benutzte AVR Studio5.

Ich binde die Klasse ein und lege instanzen an:
1
#include "protocol.h"

2
3
protocol *forward = new protocol();

4
protocol *com_in = new protocol(forward);

5
protocol *com_out = new protocol();


Hier die Klasse, protocol.h
1
class protocol

2
{

3
public:

4
    protocol();

5
    protocol(protocol *forward);

6
    unsigned char decode(unsigned char inChar);

7
8
    #ifndef DEBUG_PC

9
    unsigned char encode(fifo_t *fifo);

10
    #endif

11
12
    unsigned char encode(unsigned char* buffer);

13
14
    unsigned char get_servo();

15
    unsigned char get_motor();

16
    unsigned char get_bow();

17
18
protected:

19
    int check_byte;

20
    unsigned char data[100];

21
22
private:

23
    protocol *forward;

24
    unsigned char mode; //0x00: Normal    0xFF: Forward Data

25
    void reset_data(void);

26
};


Aber ich bekomme immer die Fehlermeldungen:

1
Error  3  expected '=', ',', ';', 'asm' or '__attribute__' before 'protocol'  C:\Users\Philipp\Documents\AVRStudio\Autopilot_0_1\Autopilot_0_1\protocol.h  52  7  Autopilot_0_1

2
Error  4  expected '=', ',', ';', 'asm' or '__attribute__' before '*' token  C:\Users\Philipp\Documents\AVRStudio\Autopilot_0_1\Autopilot_0_1\Autopilot_0_1.c  17  10  Autopilot_0_1

3
Error  5  expected '=', ',', ';', 'asm' or '__attribute__' before '*' token  C:\Users\Philipp\Documents\AVRStudio\Autopilot_0_1\Autopilot_0_1\Autopilot_0_1.c  18  10  Autopilot_0_1

4
Error  6  expected '=', ',', ';', 'asm' or '__attribute__' before '*' token  C:\Users\Philipp\Documents\AVRStudio\Autopilot_0_1\Autopilot_0_1\Autopilot_0_1.c  19  10  Autopilot_0_1


was mache ich falsch?

Ich hoffe ihr könnt mir helfen?

MfG
Philipp

  


  




  

    Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
  


  

    

      von
      
        Floh (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Philipp Maricek schrieb:
> Ich binde die Klasse ein und lege instanzen an:

Sind die Anweisungen außerhalb eines Blocks (Main oder Funktion)?
Und poste doch einfach die gesamte Datei Autpilot.c.
Übrigends, warum Endung "c"? Hätte für C++-Dateien eher "cc" oder "cpp" 
genommen.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
  


  

    

      von
      
        Philipp M.
        (lord-maricek)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Hallo,

die Klasse liegt in der protocol.h/protocol.cpp.
Ich mache nur die Klassen in C++ Dateien, den Rest wollte ich in C 
Dateien machen, oder wärs da sinnvoller direkt nur C++ Dateien zu 
verwenden?
Hier mal alle Dateien:
Autopilot.c
1
#include "defines.h"

2
#include "functions.h"

3
#include "uarts.h"

4
#include "fifo.h"

5
#include "protocol.h"

6
#include "navi.h"

7
8
#include <avr/io.h>

9
#include <stdio.h>

10
#include <stdlib.h>

11
12
fifo_t GPS;

13
fifo_t xbee_in;

14
fifo_t xbee_out;

15
16
17
protocol *forward = new protocol();

18
protocol *com_in = new protocol(forward);

19
protocol *com_out = new protocol();

20
21
volatile int counter;

22
23
int main(void){

24
  

25
  TCCR0B = ( 1 << CS02 ) | ( 1 << CS00 ); // Teiler: 1024

26
  TIMSK0 = ( 1 << TOIE0 );         // Overflow Interrupt einschalten

27
  

28
  //Leds

29
  DDRC |= (1<<2)|(1<<5);

30
  DDRD |= (1<<7);

31
  

32
  set_leds(0x07);

33
  

34
  //FIFO Buffer

35
  uint8_t gps_buffer[BUFFER_SIZE];

36
  fifo_init(&GPS,gps_buffer,BUFFER_SIZE);

37
  

38
  uint8_t xbee_in_buffer[BUFFER_SIZE];

39
  fifo_init(&xbee_in,xbee_in_buffer,BUFFER_SIZE);

40
  

41
  uint8_t xbee_out_buffer[BUFFER_SIZE];

42
  fifo_init(&xbee_out,xbee_out_buffer,BUFFER_SIZE);

43
  

44
  sei();

45
  uart_init();

46
  

47
  uint8_t a[] = {"\nReady for Connection\n"};

48
  for(int i=0;i<22;i++){

49
    fifo_put(&xbee_out,a[i]);

50
  }

51
  

52
    while(1){

53
    

54
        int tmp = fifo_get(&xbee_in);

55
    if(tmp!=-1){

56
      uint8_t t = decode((uint8_t)tmp);

57
      if(t==0xff){

58
        //Decoded

59
      }else if(t==0x01){

60
        fifo_put(&xbee_out,'E');

61
        fifo_put(&xbee_out,'R');

62
        fifo_put(&xbee_out,'R');

63
        fifo_put(&xbee_out,'O');

64
        fifo_put(&xbee_out,'R');

65
        set_leds(0x04);

66
      }

67
    }      

68
    }

69
}

70
71
ISR(USART0_RX_vect){

72
  uint8_t tmp = UDR0;

73
  fifo_put(&GPS,tmp);

74
}

75
76
ISR(USART1_RX_vect){

77
  uint8_t tmp = UDR1;

78
  fifo_put(&xbee_in,tmp);

79
}

80
81
ISR(USART1_UDRE_vect){

82
  int tmp = fifo_get(&xbee_out);

83
  if(tmp==-1){

84
    set_leds(0x00);

85
    UCSR1B &= ~(1<<UDRIE1);

86
  }else{

87
    set_leds(0x01);

88
    UDR1 = (uint8_t)tmp;

89
  }

90
}

91
92
//Timer Overflow

93
ISR(TIMER0_OVF_vect){

94
  counter++;

95
  if(counter>=10){

96
    

97
    //Senden

98
    

99
    counter = 0;

100
  }

101
}


protocol.h
1
#ifndef PROTOCOL_H

2
#define PROTOCOL_H

3
4
//#define DEBUG_PC

5
6
#include <stdio.h>

7
8
#ifndef DEBUG_PC

9
#include "fifo.h"

10
#endif

11
12
#define START_BYTE '*'

13
#define END_BYTE '$'

14
15
#define SERVO 0x01

16
#define MOTOR 0x02

17
#define BOW 0x03

18
19
#define STATUS_1 0x04

20
#define STATUS_2 0x05

21
22
#define KRAN 0x06

23
24
#define AUTOPILOT 0x07

25
26
#define NEW_WAYPOINT_ID 0x08

27
#define NEW_WAYPOINT_LON1 0x09

28
#define NEW_WAYPOINT_LON2 0x0A

29
#define NEW_WAYPOINT_LON3 0x0B

30
#define NEW_WAYPOINT_LON4 0x0C

31
#define NEW_WAYPOINT_LAT1 0x0D

32
#define NEW_WAYPOINT_LAT2 0x0E

33
#define NEW_WAYPOINT_LAT3 0x0F

34
#define NEW_WAYPOINT_LAT4 0x10

35
36
#define DIRECT 0x11

37
38
#define KURS_SOLL 0x12

39
#define KURS_AKTUELL 0x13

40
41
#define RGB_ID 0x14

42
#define RGB_R 0x15

43
#define RGB_G 0x16

44
#define RGB_B 0x17

45
46
#define LICHT_1 0x18

47
#define LICHT_2 0x19

48
#define LICHT_3 0x20

49
#define LICHT_4 0x21

50
#define LICHT_5 0x22

51
52
class protocol

53
{

54
public:

55
    protocol();

56
    protocol(protocol *forward);

57
    unsigned char decode(unsigned char inChar);

58
59
    #ifndef DEBUG_PC

60
    unsigned char encode(fifo_t *fifo);

61
    #endif

62
63
    unsigned char encode(unsigned char* buffer);

64
65
    unsigned char get_servo();

66
    unsigned char get_motor();

67
    unsigned char get_bow();

68
69
protected:

70
    int check_byte;

71
    unsigned char data[100];

72
73
private:

74
    protocol *forward;

75
    unsigned char mode; //0x00: Normal    0xFF: Forward Data

76
    void reset_data(void);

77
};

78
79
80
#endif // PROTOCOL_H


protocol.cpp
1
#include "protocol.h"

2
3
protocol::protocol()

4
{

5
    this->check_byte = 0x00;

6
    this->mode = 0x00;

7
    this->reset_data();

8
}

9
10
protocol::protocol(protocol *forward)

11
{

12
    this->mode = 0xff;

13
    this->forward = forward;

14
    this->check_byte = 0x00;

15
    this->reset_data();

16
}

17
18
unsigned char protocol::decode(unsigned char inChar)

19
{

20
    static unsigned char buffer[100];

21
    static unsigned char indexer;

22
23
    if(inChar==START_BYTE)

24
    {

25
        for(unsigned char i=0; i<100; i++)

26
        {

27
            buffer[i] = 0;

28
        }

29
        indexer = 0;

30
    }

31
32
    buffer[indexer] = inChar;

33
34
    if(buffer[indexer]==END_BYTE)

35
    {

36
        if(buffer[0]==START_BYTE)

37
        {

38
            unsigned char tmp_indexer = 2;

39
            unsigned char tmp_letter = buffer[1];

40
            while(tmp_indexer<indexer)

41
            {

42
                switch(tmp_letter)

43
                {

44
                case SERVO: //Servo

45
                    this->data[SERVO] = buffer[tmp_indexer];

46
                    if(this->mode==0xff)

47
                    {

48
                        if(this->data[AUTOPILOT]==0)

49
                        {

50
                            this->forward->data[SERVO] = this->data[SERVO];

51
                            this->forward->check_byte |= (1<<SERVO);

52
                        }

53
                    }else{

54
                        this->check_byte |= (1<<SERVO);

55
                    }

56
                    break;

57
                case MOTOR: //Motor

58
                    this->data[MOTOR] = buffer[tmp_indexer];

59
                    if(this->mode==0xff)

60
                    {

61
                        if(this->data[AUTOPILOT]==0)

62
                        {

63
                            this->forward->data[MOTOR] = this->data[MOTOR];

64
                            this->forward->check_byte |= (1<<MOTOR);

65
                        }

66
                    }else{

67
                        this->check_byte |= (1<<MOTOR);

68
                    }

69
                    break;

70
                case BOW:

71
                    this->data[BOW] = buffer[tmp_indexer];

72
                    if(this->mode==0xff)

73
                    {

74
                        if(this->data[AUTOPILOT]==0)

75
                        {

76
                            this->forward->data[BOW] = this->data[BOW];

77
                            this->forward->check_byte |= (1<<BOW);

78
                        }

79
                    }else{

80
                        this->check_byte |= (1<<BOW);

81
                    }

82
                    break;

83
                case STATUS_1:

84
                    this->data[STATUS_1] = buffer[tmp_indexer];

85
                    tmp_indexer++;

86
                    this->data[STATUS_2] = buffer[tmp_indexer];

87
                    this->check_byte |= (1<<STATUS_1);

88
                    break;

89
                case KRAN:

90
                    this->data[KRAN] = buffer[tmp_indexer];

91
                    if(this->mode==0xff)

92
                    {

93
                        this->forward->data[KRAN] = this->data[KRAN];

94
                        this->forward->check_byte |= (1<<KRAN);

95
                    }else{

96
                        this->check_byte |= (1<<KRAN);

97
                    }

98
                    break;

99
                case AUTOPILOT:

100
                    this->data[AUTOPILOT] = buffer[tmp_indexer];

101
                    this->check_byte |= (1<<AUTOPILOT);

102
                    break;

103
                case NEW_WAYPOINT_ID:

104
                    this->data[NEW_WAYPOINT_ID] = buffer[tmp_indexer];

105
                    tmp_indexer++;

106
                    this->data[NEW_WAYPOINT_LON1] = buffer[tmp_indexer];

107
                    tmp_indexer++;

108
                    this->data[NEW_WAYPOINT_LON2] = buffer[tmp_indexer];

109
                    tmp_indexer++;

110
                    this->data[NEW_WAYPOINT_LON3] = buffer[tmp_indexer];

111
                    tmp_indexer++;

112
                    this->data[NEW_WAYPOINT_LON4] = buffer[tmp_indexer];

113
                    tmp_indexer++;

114
                    this->data[NEW_WAYPOINT_LAT1] = buffer[tmp_indexer];

115
                    tmp_indexer++;

116
                    this->data[NEW_WAYPOINT_LAT2] = buffer[tmp_indexer];

117
                    tmp_indexer++;

118
                    this->data[NEW_WAYPOINT_LAT3] = buffer[tmp_indexer];

119
                    tmp_indexer++;

120
                    this->data[NEW_WAYPOINT_LAT4] = buffer[tmp_indexer];

121
                    this->check_byte |= (1<<NEW_WAYPOINT_ID);

122
                    break;

123
                case DIRECT:

124
                    this->data[DIRECT] = buffer[tmp_indexer];

125
                    this->check_byte |= (1<<DIRECT);

126
                    break;

127
                case RGB_ID:

128
                    if(mode==0xff)

129
                    {

130
                        this->forward->data[RGB_ID] = buffer[tmp_indexer];

131
                        tmp_indexer++;

132
                        this->forward->data[RGB_R] = buffer[tmp_indexer];

133
                        tmp_indexer++;

134
                        this->forward->data[RGB_G] = buffer[tmp_indexer];

135
                        tmp_indexer++;

136
                        this->forward->data[RGB_B] = buffer[tmp_indexer];

137
                        this->forward->check_byte |= (1<<RGB_ID);

138
                    }

139
                    else

140
                    {

141
                        this->data[RGB_ID] = buffer[tmp_indexer];

142
                        tmp_indexer++;

143
                        this->data[RGB_R] = buffer[tmp_indexer];

144
                        tmp_indexer++;

145
                        this->data[RGB_G] = buffer[tmp_indexer];

146
                        tmp_indexer++;

147
                        this->data[RGB_B] = buffer[tmp_indexer];

148
                        this->check_byte |= (1<<RGB_ID);

149
                    }

150
                    break;

151
                case LICHT_1:

152
                    if(mode==0xff)

153
                    {

154
                        this->forward->data[LICHT_1] = buffer[tmp_indexer];

155
                        tmp_indexer++;

156
                        this->forward->data[LICHT_2] = buffer[tmp_indexer];

157
                        tmp_indexer++;

158
                        this->forward->data[LICHT_3] = buffer[tmp_indexer];

159
                        tmp_indexer++;

160
                        this->forward->data[LICHT_4] = buffer[tmp_indexer];

161
                        this->forward->check_byte |= (1<<LICHT_1);

162
                        break;

163
                    }else{

164
                        this->data[LICHT_1] = buffer[tmp_indexer];

165
                        tmp_indexer++;

166
                        this->data[LICHT_2] = buffer[tmp_indexer];

167
                        tmp_indexer++;

168
                        this->data[LICHT_3] = buffer[tmp_indexer];

169
                        tmp_indexer++;

170
                        this->data[LICHT_4] = buffer[tmp_indexer];

171
                        this->check_byte |= (1<<LICHT_1);

172
                        break;

173
                    }

174
                }

175
                tmp_letter = buffer[tmp_indexer];

176
                tmp_indexer++;

177
            }

178
            return 0xff;

179
        }

180
        return 0x01;

181
    }

182
183
    indexer++;

184
    return 0x00;

185
}

186
187
#ifndef DEBUG_PC

188
unsigned char protocol::encode(fifo_t *fifo)

189
{

190
    if(this->check_byte!=0x00)

191
    {

192
        fifo_put(&fifo,STARTBYTE);

193
        if(this->check_byte&(1<<SERVO))

194
        {

195
            fifo_put(&fifo,SERVO);

196
            fifo_put(&fifo,data[SERVO]);

197
        }

198
199
        if(this->check_byte&(1<<MOTOR))

200
        {

201
            fifo_put(&fifo,MOTOR);

202
            fifo_put(&fifo,data[MOTOR]);

203
        }

204
205
        if(this->check_byte&(1<<BOW))

206
        {

207
            fifo_put(&fifo,BOW);

208
            fifo_put(&fifo,data[BOW]);

209
        }

210
211
        if(this->check_byte&(1<<STATUS_1))

212
        {

213
            fifo_put(&fifo,STATUS_1);

214
            fifo_put(&fifo,data[STATUS_1]);

215
            fifo_put(&fifo,data[STATUS_2]);

216
        }

217
218
        if(this->check_byte&(1<<KRAN))

219
        {

220
            fifo_put(&fifo,KRAN);

221
            fifo_put(&fifo,data[KRAN]);

222
        }

223
224
        if(this->check_byte&(1<<AUTOPILOT))

225
        {

226
            fifo_put(&fifo,AUTOPILOT);

227
            fifo_put(&fifo,data[AUTOPILOT]);

228
        }

229
230
        if(this->check_byte&(1<<NEW_WAYPOINT_ID))

231
        {

232
            fifo_put(&fifo,NEW_WAYPOINT_ID);

233
            fifo_put(&fifo,data[NEW_WAYPOINT_ID]);

234
            fifo_put(&fifo,data[NEW_WAYPOINT_LON1]);

235
            fifo_put(&fifo,data[NEW_WAYPOINT_LON2]);

236
            fifo_put(&fifo,data[NEW_WAYPOINT_LON3]);

237
            fifo_put(&fifo,data[NEW_WAYPOINT_LON4]);

238
            fifo_put(&fifo,data[NEW_WAYPOINT_LAT1]);

239
            fifo_put(&fifo,data[NEW_WAYPOINT_LAT2]);

240
            fifo_put(&fifo,data[NEW_WAYPOINT_LAT3]);

241
            fifo_put(&fifo,data[NEW_WAYPOINT_LAT4]);

242
        }

243
244
        if(this->check_byte&(1<<DIRECT))

245
        {

246
            fifo_put(&fifo,DIRECT);

247
            fifo_put(&fifo,data[DIRECT]);

248
        }

249
250
        if(this->check_byte&(1<<KURS_AKTUELL))

251
        {

252
            fifo_put(&fifo,KURS_AKTUELL);

253
            fifo_put(&fifo,data[KURS_AKTUELL]);

254
        }

255
256
        if(this->check_byte&(1<<KURS_SOLL))

257
        {

258
            fifo_put(&fifo,KURS_SOLL);

259
            fifo_put(&fifo,data[KURS_SOLL]);

260
        }

261
262
        if(this->check_byte&(1<<RGB_ID))

263
        {

264
            fifo_put(&fifo,RGB_ID;

265
            fifo_put(&fifo,data[RGB_ID]);

266
            fifo_put(&fifo,data[RGB_R]);

267
            fifo_put(&fifo,data[RGB_G]);

268
            fifo_put(&fifo,data[RGB_B]);

269
        }

270
271
        if(this->check_byte&(1<<LICHT_1))

272
        {

273
            fifo_put(&fifo,LICHT_1;

274
            fifo_put(&fifo,data[LICHT_1]);

275
            fifo_put(&fifo,data[LICHT_2]);

276
            fifo_put(&fifo,data[LICHT_3]);

277
            fifo_put(&fifo,data[LICHT_4]);

278
            fifo_put(&fifo,data[LICHT_5]);

279
        }

280
281
        fifo_put(&fifo,END_BYTE);

282
        return 0xff;

283
    }

284
    return 0;

285
}

286
#endif

287
288
unsigned char protocol::encode(unsigned char* buffer)

289
{

290
    if(this->check_byte!=0x00)

291
    {

292
        buffer[0] = START_BYTE;

293
        unsigned char indexer = 1;

294
        if(this->check_byte&(1<<SERVO))

295
        {

296
            buffer[indexer] = SERVO;

297
            buffer[indexer+1] = data[SERVO];

298
            indexer+=2;

299
        }

300
301
        if(this->check_byte&(1<<MOTOR))

302
        {

303
            buffer[indexer] = MOTOR;

304
            buffer[indexer+1] = data[MOTOR];

305
            indexer+=2;

306
        }

307
308
        if(this->check_byte&(1<<BOW))

309
        {

310
            buffer[indexer] = BOW;

311
            buffer[indexer+1] = data[BOW];

312
            indexer+=2;

313
        }

314
315
        if(this->check_byte&(1<<STATUS_1))

316
        {

317
            buffer[indexer] = STATUS_1;

318
            buffer[indexer+1] = data[STATUS_1];

319
            buffer[indexer+2] = data[STATUS_2];

320
            indexer+=3;

321
        }

322
323
        if(this->check_byte&(1<<KRAN))

324
        {

325
            buffer[indexer] = KRAN;

326
            buffer[indexer+1] = data[KRAN];

327
            indexer+=2;

328
        }

329
330
        if(this->check_byte&(1<<AUTOPILOT))

331
        {

332
            buffer[indexer] = AUTOPILOT;

333
            buffer[indexer+1] = data[AUTOPILOT];

334
            indexer+=2;

335
        }

336
337
        if(this->check_byte&(1<<NEW_WAYPOINT_ID))

338
        {

339
            buffer[indexer] = NEW_WAYPOINT_ID;

340
            buffer[indexer+1] = data[NEW_WAYPOINT_ID];

341
            buffer[indexer+2] = data[NEW_WAYPOINT_LON1];

342
            buffer[indexer+3] = data[NEW_WAYPOINT_LON2];

343
            buffer[indexer+4] = data[NEW_WAYPOINT_LON3];

344
            buffer[indexer+5] = data[NEW_WAYPOINT_LON4];

345
            indexer+=6;

346
            buffer[indexer] = data[NEW_WAYPOINT_LAT1];

347
            buffer[indexer+1] = data[NEW_WAYPOINT_LAT2];

348
            buffer[indexer+2] = data[NEW_WAYPOINT_LAT3];

349
            buffer[indexer+3] = data[NEW_WAYPOINT_LAT4];

350
            indexer+=4;

351
        }

352
353
        if(this->check_byte&(1<<DIRECT))

354
        {

355
            buffer[indexer] = DIRECT;

356
            buffer[indexer+1] = data[DIRECT];

357
            indexer+=2;

358
        }

359
360
        if(this->check_byte&(1<<KURS_AKTUELL))

361
        {

362
            buffer[indexer] = KURS_AKTUELL;

363
            buffer[indexer+1] = data[KURS_AKTUELL];

364
            indexer+=2;

365
        }

366
367
        if(this->check_byte&(1<<KURS_SOLL))

368
        {

369
            buffer[indexer] = KURS_SOLL;

370
            buffer[indexer+1] = data[KURS_SOLL];

371
            indexer+=2;

372
        }

373
374
        if(this->check_byte&(1<<RGB_ID))

375
        {

376
            buffer[indexer] = RGB_ID;

377
            buffer[indexer+1] = data[RGB_ID];

378
            buffer[indexer+2] = data[RGB_R];

379
            buffer[indexer+3] = data[RGB_G];

380
            buffer[indexer+4] = data[RGB_B];

381
            indexer+=5;

382
        }

383
384
        if(this->check_byte&(1<<LICHT_1))

385
        {

386
            buffer[indexer] = LICHT_1;

387
            buffer[indexer+1] = data[LICHT_1];

388
            buffer[indexer+2] = data[LICHT_2];

389
            buffer[indexer+3] = data[LICHT_3];

390
            buffer[indexer+4] = data[LICHT_4];

391
            buffer[indexer+5] = data[LICHT_5];

392
            indexer+=6;

393
        }

394
395
        buffer[indexer] = END_BYTE;

396
        return 0xff;

397
    }

398
    return 0x00;

399
}

400
401
unsigned char protocol::get_servo()

402
{

403
    return this->data[SERVO];

404
}

405
406
unsigned char protocol::get_motor()

407
{

408
    return this->data[MOTOR];

409
}

410
411
unsigned char protocol::get_bow()

412
{

413
    return this->data[BOW];

414
}

415
416
void protocol::reset_data(void)

417
{

418
    for(unsigned char i=0;i<30;i++)

419
    {

420
        this->data[i] = 0;

421
    }

422
    check_byte = 0x00;

423
}


Ich habe die Klasse vorher in einem C++ Prgramm auf dem Rechner mit 
Codeblocks getestet, und da ging alles.

Ist es generell eigentlich möglich, das Komplette AVR-Programm einfach 
in C++ zu schreiben?

MfG
Philipp

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
  


  

    

      von
      
        Floh (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Lange Dateien als Anhang.

Philipp Maricek schrieb:
> protocol *forward = new protocol();
> protocol *com_in = new protocol(forward);
> protocol *com_out = new protocol();

Hier willst du Code außerhalb eines Blocks ausführen, das wird so nicht 
gehen. Trenne Deklaration und Definition auf, wenn die Variablen global 
sein müssen.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
  


  

    

      von
      
        (prx) A. K.
        (prx)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Philipp Maricek schrieb:

> Ich mache nur die Klassen in C++ Dateien, den Rest wollte ich in C
> Dateien machen,

Und du stellst dir vor, dass der C-Compiler C++-Klassen versteht???

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
  


  

    

      von
      
        Klaus W.
        (mfgkw)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Philipp Maricek schrieb:
> Ist es generell eigentlich möglich, das Komplette AVR-Programm einfach
> in C++ zu schreiben?

ja

Wobei auf einem armen kleinen AVR nicht gerade alles nutzen kann, was 
C++ so bietet.
Aber mit etwas Zurückhaltung kann man gleich alles in C++ schreiben.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
  


  

    

      von
      
        Philipp M.
        (lord-maricek)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Waer es sinnvoller, bei so einem Protocol wie meinem alles in C++ 
zumachen oder in C und dann mit Structen?

Philipp

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
  


  

    

      von
      
        Klaus W.
        (mfgkw)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Das kommt drauf an.

Und zwar weniger auf deine Aufgabenstellung, sondern ob man mit C++ 
umgehen kann.

Man kann vieles deutlich eleganter, prägnanter und wartbarer 
formulieren.
Schon in C kann man prinzipiell alles machen, kann also auch viel falsch 
machen - wenn man es nicht verstanden hat.
In C++ hat man dann deutlich mehr Möglichkeiten, Gutes oder Schlechtes 
zu tun.

Ich nehme auch auf einem MC deutlich lieber C++, wobei die Programme 
über weite Strecken dadurch nicht anders aussehen (auf einem MC 
zumindest).
Aber an vielen Stellen kann man C++ dann sehr gut brauchen.

Ein Aufteilen auf C- und C++-Teile ist möglich, aber nicht unbedingt 
sinnvoll (es sei denn, man hat bereits C-Teile fertig; die kann man 
natürlich unverändert nehmen).
Schließlich kann man in eine *.cpp ja genau dasselbe reinschreiben wie 
in eine *.c, solange man die Möglichkeiten von C++ gerade nicht braucht.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
  


  

    

      von
      
        Philipp M.
        (lord-maricek)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Ok, danke,
dann werde ich das meiste jetzt in C++ machen, natürlich zurückhaltend.
Eine Frage noch, ich habe gelesen, dass new und delete nicht unterstützt 
werden, ist das immer noch so?

Wäre es dann so richtig?
1
protocol forward();

2
protocol com_in(forward);

3
protocol com_out();


MfG
Philipp

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
  


  

    

      von
      
        Philipp M.
        (lord-maricek)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Ich habe gerade mal Probiert in Avr Studio 5 ein Projekt zu erstellen. 
Die Datei mit der main Funktion habe ich in eine C++ Datei umbenannt.
Beim Kompilieren bekam ich zuerst immer nur die Meldung:
1
undefined referenze to main

nach ein paar Versuchen, steht jetzt nichts mehr in der Error List, 
sondern nur noch das:
1
------ Build started: Project: Autopilot_0_2, Configuration: Debug AVR ------

2
Build started.

3
Project "Autopilot_0_2.avrgccproj" (default targets):

4
Target "PreBuildEvent" skipped, due to false condition; ('$(PreBuildEvent)'!='') was evaluated as (''!='').

5
Target "CoreBuild" in file "C:\Program Files (x86)\Atmel\AVR Studio 5.0\Vs\AvrGCC.targets" from project "C:\Users\Philipp\Documents\AVRStudio\Autopilot_0_2\Autopilot_0_2\Autopilot_0_2.avrgccproj" (target "Build" depends on it):

6
  Task "RunAvrGCC"

7
    C:\Program Files (x86)\Atmel\AVR Studio 5.0\AVR ToolChain\bin\make.exe all 

8
    make: *** Keine Regel vorhanden, um das Target ╗makedep.mk½, 

9
      ben÷tigt von ╗Autopilot_0_2.elf½, zu erstellen.  Schluss.

10
  Done executing task "RunAvrGCC" -- FAILED.

11
Done building target "CoreBuild" in project "Autopilot_0_2.avrgccproj" -- FAILED.

12
Done building project "Autopilot_0_2.avrgccproj" -- FAILED.

13
14
Build FAILED.

15
========== Build: 0 succeeded or up-to-date, 1 failed, 0 skipped ==========


Was mache ich falsch?

MfG
Philipp

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
  


  

    

      von
      
        Klaus W.
        (mfgkw)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Das kann ich nicht sagen, wiel ich nicht mit dem AVRStudio arbeite.

Ich habe da aber einen bösen Verdacht; kannst du mal das Makefile zu dem 
Projekt zeigen, das irgendwo herumliegen müsste?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
  


  

    

      von
      
        Klaus W.
        (mfgkw)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Philipp Maricek schrieb:
> undefined referenze to main

irgendwas falsch abtippen ist immer schlecht; lieber mit copy&paste den 
Originaltext zeigen :-)

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
  


  

    

      von
      
        Klaus W.
        (mfgkw)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Philipp Maricek schrieb:
> Ich habe gerade mal Probiert in Avr Studio 5 ein Projekt zu erstellen.
> Die Datei mit der main Funktion habe ich in eine C++ Datei umbenannt.
> Beim Kompilieren bekam ich zuerst immer nur die Meldung:

Du musst aber natürlich auch dem Studio-Dings sagen, daß es jetzt eine 
andere Datei gibt; nicht nur die Datei umbenennen (Explorer oder so)

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
  


  

    

      von
      
        Philipp M.
        (lord-maricek)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Hier das MakeFile, habs vergessen zu ändern. Ist jetzt auf 
Autopilot_0_2.cpp
Ich habe die Datei aber direkt im Studio umbenannt.
1
################################################################################

2
# Automatically-generated file. Do not edit!

3
################################################################################

4
5
SHELL := cmd.exe

6
RM := rm -rf

7
8
USER_OBJS :=

9
10
LIBS := 

11
PROJ := 

12
13
O_SRCS := 

14
C_SRCS := 

15
S_SRCS := 

16
S_UPPER_SRCS := 

17
OBJ_SRCS := 

18
ASM_SRCS := 

19
PREPROCESSING_SRCS := 

20
OBJS := 

21
OBJS_AS_ARGS := 

22
C_DEPS := 

23
C_DEPS_AS_ARGS := 

24
EXECUTABLES := 

25
LIB_AS_ARGS :=

26
OUTPUT_FILE_PATH :=

27
OUTPUT_FILE_PATH_AS_ARGS :=

28
HEX_FLASH_FILE_PATH :=

29
HEX_FLASH_FILE_PATH_AS_ARGS :=

30
HEX_EEPROM_FILE_PATH :=

31
HEX_EEPROM_FILE_PATH_AS_ARGS :=

32
LSS_FILE_PATH :=

33
LSS_FILE_PATH_AS_ARGS :=

34
MAP_FILE_PATH :=

35
MAP_FILE_PATH_AS_ARGS :=

36
AVR_APP_PATH :=C:/Program Files (x86)/Atmel/AVR Studio 5.0/AVR ToolChain/bin/

37
QUOTE := "

38
ADDITIONAL_DEPENDENCIES:=

39
OUTPUT_FILE_DEP:=

40
41
# Every subdirectory with source files must be described here

42
SUBDIRS := 

43
44
45
# Add inputs and outputs from these tool invocations to the build variables 

46
C_SRCS +=  \

47
../Autopilot_0_2.cpp

48
49
50
PREPROCESSING_SRCS += 

51
52
53
ASM_SRCS += 

54
55
56
OBJS +=  \

57
Autopilot_0_2.o

58
59
60
OBJS_AS_ARGS +=  \

61
Autopilot_0_2.o

62
63
64
C_DEPS +=  \

65
Autopilot_0_2.d

66
67
68
C_DEPS_AS_ARGS +=  \

69
Autopilot_0_2.d

70
71
72
OUTPUT_FILE_PATH +=Autopilot_0_2.elf

73
74
OUTPUT_FILE_PATH_AS_ARGS +=Autopilot_0_2.elf

75
76
HEX_FLASH_FILE_PATH +=Autopilot_0_2.hex

77
78
HEX_FLASH_FILE_PATH_AS_ARGS +=Autopilot_0_2.hex

79
80
HEX_EEPROM_FILE_PATH +=Autopilot_0_2.eep

81
82
HEX_EEPROM_FILE_PATH_AS_ARGS +=Autopilot_0_2.eep

83
84
LSS_FILE_PATH +=Autopilot_0_2.lss

85
86
LSS_FILE_PATH_AS_ARGS +=Autopilot_0_2.lss

87
88
MAP_FILE_PATH =Autopilot_0_2.map

89
90
MAP_FILE_PATH_AS_ARGS =Autopilot_0_2.map

91
92
LIB_AS_ARGS +=libAutopilot_0_2.a

93
94
ADDITIONAL_DEPENDENCIES:= $(HEX_FLASH_FILE_PATH) $(LSS_FILE_PATH) $(HEX_EEPROM_FILE_PATH) size

95
96
OUTPUT_FILE_DEP:= ./makedep.mk

97
98
# AVR/GNU C Compiler

99
100
./%.o: .././%.c

101
  @echo Building file: $<

102
  @echo Invoking: AVR/GNU C Compiler

103
  $(QUOTE)$(AVR_APP_PATH)avr-gcc.exe$(QUOTE) -funsigned-char -funsigned-bitfields -O0 -fpack-struct -fshort-enums -g2 -Wall -c -std=gnu99  -mmcu=atmega1284p   -MD -MP -MF"$(@:%.o=%.d)" -MT"$(@:%.o=%.d)" -o"$@" "$<"

104
  @echo Finished building: $<

105
106
./%.o: .././%.cpp

107
  @echo Building file: $<

108
  @echo Invoking: AVR/GNU CPP Compiler

109
  $(QUOTE)$(AVR_APP_PATH)avr-g++.exe$(QUOTE)   -MD -MP -MF"$(@:%.o=%.d)" -MT"$(@:%.o=%.d)" -o"$@" "$<"

110
  @echo Finished building: $<

111
112
113
114
# AVR/GNU Assembler

115
116
117
118
119
ifneq ($(MAKECMDGOALS),clean)

120
ifneq ($(strip $(C_DEPS)),)

121
-include $(C_DEPS)

122
endif

123
endif

124
125
# Add inputs and outputs from these tool invocations to the build variables 

126
127
# All Target

128
all: $(OUTPUT_FILE_PATH) $(ADDITIONAL_DEPENDENCIES)

129
130
# AVR/GNU C/C++ Linker

131
$(OUTPUT_FILE_PATH): $(OBJS) $(USER_OBJS) $(OUTPUT_FILE_DEP)

132
  @echo Building target: $@

133
  @echo Invoking: AVR/GNU C/C++ Linker

134
  $(QUOTE)$(AVR_APP_PATH)avr-gcc.exe$(QUOTE)  -mmcu=atmega1284p  -Wl,-Map=$(MAP_FILE_PATH_AS_ARGS) -o$(OUTPUT_FILE_PATH_AS_ARGS) $(OBJS_AS_ARGS) $(USER_OBJS) $(LIBS)

135
  @echo Finished building target: $@

136
137
138
139
$(HEX_FLASH_FILE_PATH): $(OUTPUT_FILE_PATH)

140
  $(QUOTE)$(AVR_APP_PATH)avr-objcopy.exe$(QUOTE) -O ihex -R .eeprom -R .fuse -R .lock -R .signature  $(QUOTE)$<$(QUOTE) $(QUOTE)$@$(QUOTE)

141
142
$(HEX_EEPROM_FILE_PATH): $(OUTPUT_FILE_PATH)

143
  -$(QUOTE)$(AVR_APP_PATH)avr-objcopy.exe$(QUOTE) -j .eeprom --set-section-flags=.eeprom=alloc,load --change-section-lma .eeprom=0 --no-change-warnings -O ihex $(QUOTE)$<$(QUOTE) $(QUOTE)$@$(QUOTE) || exit 0

144
145
$(LSS_FILE_PATH): $(OUTPUT_FILE_PATH)

146
  $(QUOTE)$(AVR_APP_PATH)avr-objdump.exe$(QUOTE) -h -S $(QUOTE)$<$(QUOTE) > $(QUOTE)$@$(QUOTE)

147
148
size: $(OUTPUT_FILE_PATH)

149
  @$(QUOTE)$(AVR_APP_PATH)avr-size.exe$(QUOTE) -C --mcu=atmega1284p $(OUTPUT_FILE_PATH_AS_ARGS)

150
151
# Other Targets

152
clean:

153
  -$(RM) $(OBJS_AS_ARGS)$(C_DEPS_AS_ARGS) $(EXECUTABLES) $(LIB_AS_ARGS) $(HEX_FLASH_FILE_PATH_AS_ARGS) $(HEX_EEPROM_FILE_PATH_AS_ARGS) $(LSS_FILE_PATH_AS_ARGS) $(MAP_FILE_PATH_AS_ARGS)


Jetzt gibts aber einen neuen Fehler:
1
Error  1  avr architecture of input file `Autopilot_0_2.o' is incompatible with avr:51 output  C:\Users\Philipp\Documents\AVRStudio\Autopilot_0_2\Autopilot_0_2\Debug  1  1  Autopilot_0_2


MfG
Philipp

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Problem mit C++ Klasse: expected '=', ',', ';', 'asm' or '__attribute__' be..
  


  

    

      von
      
        Klaus W.
        (mfgkw)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Da sind ja auch für *.c und *.cpp andere Compileroptionen definiert:
1
...

2
./%.o: .././%.c

3
  @echo Building file: $<

4
  @echo Invoking: AVR/GNU C Compiler

5
  $(QUOTE)$(AVR_APP_PATH)avr-gcc.exe$(QUOTE) -funsigned-char -funsigned-bitfields -O0 -fpack-struct -fshort-enums -g2 -Wall -c -std=gnu99  -mmcu=atmega1284p   -MD -MP -MF"$(@:%.o=%.d)" -MT"$(@:%.o=%.d)" -o"$@" "$<"

6
  @echo Finished building: $<

7
8
./%.o: .././%.cpp

9
  @echo Building file: $<

10
  @echo Invoking: AVR/GNU CPP Compiler

11
  $(QUOTE)$(AVR_APP_PATH)avr-g++.exe$(QUOTE)   -MD -MP -MF"$(@:%.o=%.d)" -MT"$(@:%.o=%.d)" -o"$@" "$<"

12
  @echo Finished building: $<

13
...


Ich weiß nicht, ob man beim AVRStudio einfach das Makefile ändert, oder 
irgendwo anders die Compileroptionen ändert.
Aber jedenfalls sollte man auch bei C++ -mmcu=atmega1284p setzen.
-fpack-struct -fshort-enums würde ich auch angleichen.

Und natürlich ein komplettes Rebuild machen (make clean).

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  








    

    

       Thread beobachten

      |
         Seitenaufteilung abschalten

    

        


Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.



  Bestehender Account

  


  
  

  
    

      

        
          
        
        
          
        
      

      

        
          
        
        
          
        
      

    


    
    
    





  Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!

  Mit Google-Account einloggen
  





  Noch kein Account? Hier anmelden.