Forum: Mikrocontroller und Digitale Elektronik Speicher/Array kommt durcheinander/wird überschrieben ?


Speicher/Array kommt durcheinander/wird überschrieben ?
von Gregor B. (gregor54321)

Angehängte Dateien:
Lesenswert?
• ▲
▼ 
Hallo zusammen!
ich habe ein für mich völlig unverständliches Problem mit Arrays!
Ich definiere in main() zwei Arrays: wert_min[] und wert_max[] mit je 10 
Werten. Diese kann ich kurz danach auch noch auslesen. Aber unmittelbar 
darauf steht ein EINEM nur noch Müll drin!
Ab Zeile 66 des Protokolls (Anhang) sieht es schon sehr schlecht aus.

Habe ich ein Problem mit dem Chip (Atmega128), dem Compiler/Optimierung 
oder mit meinem Code?

Ich finde es merkwürdig, das nur das "wert_min" verrückt spielt und das 
"wert_max" tut was es soll, bei eigentlich identischem Code!?!
Hier der zusammengefasste Ablauf des ersten Durchlaufs:
1
  Direkt nach Init:

2
3
  wert_min[0] 1000

4
  wert_min[1] 1001

5
  wert_min[2] 1002

6
  wert_min[3] 1003

7
  wert_min[4] 1004

8
  wert_min[5] 1005

9
  wert_min[6] 1006

10
  wert_min[7] 1007

11
  wert_min[8] 1008

12
  wert_min[9] 1009

13
14
  wert_max[0] 10

15
  wert_max[1] 11

16
  wert_max[2] 12

17
  wert_max[3] 13

18
  wert_max[4] 14

19
  wert_max[5] 15

20
  wert_max[6] 16

21
  wert_max[7] 17

22
  wert_max[8] 18

23
  wert_max[9] 19

24
25
eintritt in die While-Schleife:

26
warten

27
port setzen

28
warten

29
wert analog lesen (im log >>279<<)

30
port setzen

31
32
Bedingung erfüllt: if ( wert < letzter_wert_min )

33
array wieder ausgeben:

34
35
  Werte vorher:

36
37
  wert_min[0] 12336   wert_max[0] 10

38
  wert_min[1] 8285    wert_max[1] 11

39
  wert_min[2] 10      wert_max[2] 12

40
  wert_min[3] 10      wert_max[3] 13

41
  wert_min[4] 1004    wert_max[4] 14

42
  wert_min[5] 1005    wert_max[5] 15

43
  wert_min[6] 1006    wert_max[6] 16

44
  wert_min[7] 1007    wert_max[7] 17

45
  wert_min[8] 1008    wert_max[8] 18

46
  wert_min[9] 1009    wert_max[9] 19

47
    

48
wert_max[0] = wert_max[1];

49
wert_max[1] = wert_max[2];

50
wert_max[2] = wert_max[3];

51
wert_max[3] = wert_max[4];

52
wert_max[4] = wert_max[5];

53
wert_max[5] = wert_max[6];

54
wert_max[6] = wert_max[7];

55
wert_max[7] = wert_max[8];

56
wert_max[8] = wert_max[9];

57
wert_max[9] = letzter_wert_max;

58
59
  Werte nach einfügen von letzter_wert_max 500:

60
61
  wert_min[0] 25972   wert_max[0] 11

62
  wert_min[1] 8285    wert_max[1] 12

63
  wert_min[2] 10      wert_max[2] 13

64
  wert_min[3] 10      wert_max[3] 14

65
  wert_min[4] 27999   wert_max[4] 15

66
  wert_min[5] 30817   wert_max[5] 16

67
  wert_min[6] 13600   wert_max[6] 17

68
  wert_min[7] 12336   wert_max[7] 18

69
  wert_min[8] 2618    wert_max[8] 19

70
  wert_min[9] 768     wert_max[9] 500

71
  letzter_wert_max verringert auf 450



Ich baue dies unter AtmelStudio7.
keine Warnungen oder Fehler.

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

dies ist mein kompletter Quellcode:
1
/*

2
 * Wasseruhr-Sensor.cpp

3
 *

4
 * Created: 28.01.2019 10:27:43

5
 * Author : Gregor

6
 */ 

7
#define F_CPU 14745600UL

8
9
#include <avr/io.h>

10
#include <util/delay.h>

11
#include <stdint.h>

12
#include <stdio.h>

13
#include <string.h>

14
#include <avr/interrupt.h>

15
#include ".\uart.h"            // pfleury

16
#define UART_BAUD_RATE 921600

17
18
19
#define GeberDDR       DDRG

20
#define GeberPORT      PORTG

21
#define GeberPORTPin   PG3

22
23
#define LaserDDR       DDRG

24
#define LaserPORT      PORTG

25
#define LaserPORTPin   PG4

26
27
#define SensorDDR      DDRF

28
#define SensorPORT     PORTF

29
#define SensorPORTPin  PF0

30
31
#define UartDDR        DDRE

32
#define UartPORT       PORTE

33
#define UartRx         PE0

34
#define UartTx         PE1

35
36
#define MIN(a,b) (((a)<(b))?(a):(b))

37
#define MAX(a,b) (((a)>(b))?(a):(b))

38
39
void switchLaseron(void);

40
void switchLaseroff(void);

41
uint16_t readSensor(void);

42
43
void switchLaseron() {

44
  LaserPORT |=  (1 << LaserPORTPin);

45
}

46
void switchLaseroff() {

47
  LaserPORT &= ~(1 << LaserPORTPin);

48
}

49
uint16_t readSensor() {

50
  uint16_t wert1;

51
52
  ADMUX  |=  (0<<REFS1)|(1<<REFS0);                // AVCC with external capacitor at AREF pin

53
  ADMUX  |=  (0<<MUX4)|(0<<MUX3)|(0<<MUX2)|(0<<MUX1)|(0<<MUX0);  // ADC0 ausgewählt

54
  ADCSRA |=  (1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0);          // ADC PreScaler FCPU/128

55
  

56
  ADCSRA |= (1<<ADEN);                      // ADC enable

57
  wert1 = ADCW;                          // ADCW muss einmal gelesen werden, sonst wird Ergebnis

58
  wert1 = 0;                            //   der nächsten Wandlung nicht übernommen.

59
  

60
  ADCSRA |= (1<<ADSC);                      // start single converson

61
  while (ADCSRA & (1<<ADSC) ) {}                  // auf Abschluss der Konvertierung warten

62
  wert1 = ADCW;                          // ADC auslesen und zurückgeben

63
  ADCSRA &= ~(1<<ADEN);                      // ADC disable

64
  

65
  return wert1 ;

66
}

67
68
uint16_t array_min ( uint16_t array[], uint8_t element_cnt ) {

69
70
    char buffer[70];

71
    sprintf(buffer, "\n\t\tarray_min() aufgerufen.\n"); uart_puts(buffer);

72
    sprintf(buffer, "\t\t\t element_cnt: %u\n", element_cnt); uart_puts(buffer);

73
74
    uint16_t min=2000;

75
    

76
    for ( uint8_t i=0;i<element_cnt;i++ ) {

77
        sprintf(buffer, "\t\t\tmin=MIN(min(%u) ),array[i(%u)](%u) ))\n",min,i,array[i] ); uart_puts(buffer);

78
79
        min=MIN(min,array[i]);

80
    }

81
    return min;

82
}

83
uint16_t array_max ( uint16_t array[], uint8_t element_cnt ) {

84
    uint16_t max=0;

85
    

86
    for ( uint8_t i=0;i<element_cnt;i++ ) {

87
        max=MAX(max, array[i]);

88
    }

89
    return max;

90
}

91
uint16_t array_avg ( uint16_t array[], uint8_t element_cnt ) {

92
    uint16_t avg=0;

93
    

94
    for ( uint8_t i=0;i<element_cnt;i++ ) {

95
        avg=avg + array[i];

96
    }

97
    return avg/element_cnt;

98
}

99
100
101
int main(void) {

102
  sei();

103
  

104
  {  // Pin init

105
    LaserDDR  |=  (1 << LaserPORTPin);                          // Output

106
107
    GeberDDR  |=  (1 << GeberPORTPin);                          // Output

108
109
    SensorDDR  &= ~( 1 << SensorPORTPin );            // 0 = Input

110
    SensorPORT &= ~( 1 << SensorPORTPin );            // 0 = kein PullUp

111
  }

112
113
114
  { // UART Initialisieren

115
    uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );

116
    uart_puts("UART-Initialized\n\n");

117
//    _delay_ms(500);

118
  }

119
  uint16_t wert = 0;

120
  uint16_t letzter_wert_max = 500;

121
  uint16_t letzter_wert_min = 500;

122
  uint16_t wert_max[10] = {10,11,12,13,14,15,16,17,18,19};

123
  uint16_t wert_min[10] = {1000,1001,1002,1003,1004,1005,1006,1007,1008,1009};

124
  char buffer[30];

125
126
127
    sprintf(buffer, "\n\tDirekt nach Init:\n");uart_puts(buffer);

128
    sprintf(buffer, "\n\twert_min[0] %u\n",wert_min[0] );uart_puts(buffer);

129
    sprintf(buffer, "\twert_min[1] %u\n",  wert_min[1] );uart_puts(buffer);

130
    sprintf(buffer, "\twert_min[2] %u\n",  wert_min[2] );uart_puts(buffer);

131
    sprintf(buffer, "\twert_min[3] %u\n",  wert_min[3] );uart_puts(buffer);

132
    sprintf(buffer, "\twert_min[4] %u\n",  wert_min[4] );uart_puts(buffer);

133
    sprintf(buffer, "\twert_min[5] %u\n",  wert_min[5] );uart_puts(buffer);

134
    sprintf(buffer, "\twert_min[6] %u\n",  wert_min[6] );uart_puts(buffer);

135
    sprintf(buffer, "\twert_min[7] %u\n",  wert_min[7] );uart_puts(buffer);

136
    sprintf(buffer, "\twert_min[8] %u\n",  wert_min[8] );uart_puts(buffer);

137
    sprintf(buffer, "\twert_min[9] %u\n",  wert_min[9] );uart_puts(buffer);

138
139
    sprintf(buffer, "\n\twert_max[0] %u\n",wert_max[0] );uart_puts(buffer);

140
    sprintf(buffer, "\twert_max[1] %u\n",  wert_max[1] );uart_puts(buffer);

141
    sprintf(buffer, "\twert_max[2] %u\n",  wert_max[2] );uart_puts(buffer);

142
    sprintf(buffer, "\twert_max[3] %u\n",  wert_max[3] );uart_puts(buffer);

143
    sprintf(buffer, "\twert_max[4] %u\n",  wert_max[4] );uart_puts(buffer);

144
    sprintf(buffer, "\twert_max[5] %u\n",  wert_max[5] );uart_puts(buffer);

145
    sprintf(buffer, "\twert_max[6] %u\n",  wert_max[6] );uart_puts(buffer);

146
    sprintf(buffer, "\twert_max[7] %u\n",  wert_max[7] );uart_puts(buffer);

147
    sprintf(buffer, "\twert_max[8] %u\n",  wert_max[8] );uart_puts(buffer);

148
    sprintf(buffer, "\twert_max[9] %u\n",  wert_max[9] );uart_puts(buffer);

149
150
    

151
    sprintf(buffer, "\tsizeof(wert_min) %u\n",(sizeof(wert_min) / sizeof(wert_min[0]) ));uart_puts(buffer);

152
    sprintf(buffer, "\tsizeof(wert_max) %u\n",(sizeof(wert_max) / sizeof(wert_max[0]) ));uart_puts(buffer);

153
154
    sprintf(buffer, "\tarray_min(wert_min): %u\n",  array_min(wert_min,(sizeof(wert_min) / sizeof(wert_min[0]))));uart_puts(buffer);

155
    sprintf(buffer, "\tarray_max(wert_min): %u\n",  array_max(wert_min,(sizeof(wert_min) / sizeof(wert_min[0]))));uart_puts(buffer);

156
    sprintf(buffer, "\tarray_avg(wert_min): %u\n\n",array_avg(wert_min,(sizeof(wert_min) / sizeof(wert_min[0]))));uart_puts(buffer);

157
    

158
    sprintf(buffer, "\tarray_min(wert_max): %u\n",  array_min(wert_max,(sizeof(wert_max) / sizeof(wert_max[0]))));uart_puts(buffer);

159
    sprintf(buffer, "\tarray_max(wert_max): %u\n",  array_max(wert_max,(sizeof(wert_max) / sizeof(wert_max[0]))));uart_puts(buffer);

160
    sprintf(buffer, "\tarray_avg(wert_max): %u\n\n",array_avg(wert_max,(sizeof(wert_max) / sizeof(wert_max[0]))));uart_puts(buffer);

161
162
    // while (1)

163
    // {

164
    // }

165
    

166
  while (1)

167
  {

168
    _delay_ms(50);

169
170
    switchLaseron();

171
    _delay_us(100);

172
    wert = readSensor();

173
    switchLaseroff();

174
    

175
    sprintf(buffer, "Messwert %u\n",wert );

176
    uart_puts(buffer);

177
    

178
    if ( wert > letzter_wert_max ) {  // jeder noch größere  Wert wird zwischengespeichert und das letzte Minimum ins Array geschrieben

179
            sprintf(buffer, "\twert %u > letzter_wert_max %u \n",wert,letzter_wert_max );

180
      uart_puts(buffer);

181
            

182
      letzter_wert_max = wert;

183
            

184
            sprintf(buffer, "\n\tWerte vorher:\n");uart_puts(buffer);

185
            sprintf(buffer, "\n\twert_min[0] %u \t wert_max[0] %u\n",  wert_min[0], wert_max[0]);uart_puts(buffer);

186
            sprintf(buffer,   "\twert_min[1] %u \t wert_max[1] %u\n",  wert_min[1], wert_max[1]);uart_puts(buffer);

187
            sprintf(buffer,   "\twert_min[2] %u \t wert_max[2] %u\n",  wert_min[2], wert_max[2]);uart_puts(buffer);

188
            sprintf(buffer,   "\twert_min[3] %u \t wert_max[3] %u\n",  wert_min[3], wert_max[3]);uart_puts(buffer);

189
            sprintf(buffer,   "\twert_min[4] %u \t wert_max[4] %u\n",  wert_min[4], wert_max[4]);uart_puts(buffer);

190
            sprintf(buffer,   "\twert_min[5] %u \t wert_max[5] %u\n",  wert_min[5], wert_max[5]);uart_puts(buffer);

191
            sprintf(buffer,   "\twert_min[6] %u \t wert_max[6] %u\n",  wert_min[6], wert_max[6]);uart_puts(buffer);

192
            sprintf(buffer,   "\twert_min[7] %u \t wert_max[7] %u\n",  wert_min[7], wert_max[7]);uart_puts(buffer);

193
            sprintf(buffer,   "\twert_min[8] %u \t wert_max[8] %u\n",  wert_min[8], wert_max[8]);uart_puts(buffer);

194
            sprintf(buffer,   "\twert_min[9] %u \t wert_max[9] %u\n",  wert_min[9], wert_max[9]);uart_puts(buffer);

195
      

196
      wert_min[0] = wert_min[1];

197
      wert_min[1] = wert_min[2];

198
      wert_min[2] = wert_min[3];

199
      wert_min[3] = wert_min[4];

200
      wert_min[4] = wert_min[5];

201
      wert_min[5] = wert_min[6];

202
      wert_min[6] = wert_min[7];

203
      wert_min[7] = wert_min[8];

204
      wert_min[8] = wert_min[9];

205
      wert_min[9] = letzter_wert_min;

206
            

207
            sprintf(buffer, "\n\tWerte nach einfügen von letzter_wert_min %u:\n", letzter_wert_min );uart_puts(buffer);

208
            sprintf(buffer, "\n\twert_min[0] %u \t wert_max[0] %u\n",  wert_min[0], wert_max[0]);uart_puts(buffer);

209
            sprintf(buffer,   "\twert_min[1] %u \t wert_max[1] %u\n",  wert_min[1], wert_max[1]);uart_puts(buffer);

210
            sprintf(buffer,   "\twert_min[2] %u \t wert_max[2] %u\n",  wert_min[2], wert_max[2]);uart_puts(buffer);

211
            sprintf(buffer,   "\twert_min[3] %u \t wert_max[3] %u\n",  wert_min[3], wert_max[3]);uart_puts(buffer);

212
            sprintf(buffer,   "\twert_min[4] %u \t wert_max[4] %u\n",  wert_min[4], wert_max[4]);uart_puts(buffer);

213
            sprintf(buffer,   "\twert_min[5] %u \t wert_max[5] %u\n",  wert_min[5], wert_max[5]);uart_puts(buffer);

214
            sprintf(buffer,   "\twert_min[6] %u \t wert_max[6] %u\n",  wert_min[6], wert_max[6]);uart_puts(buffer);

215
            sprintf(buffer,   "\twert_min[7] %u \t wert_max[7] %u\n",  wert_min[7], wert_max[7]);uart_puts(buffer);

216
            sprintf(buffer,   "\twert_min[8] %u \t wert_max[8] %u\n",  wert_min[8], wert_max[8]);uart_puts(buffer);

217
            sprintf(buffer,   "\twert_min[9] %u \t wert_max[9] %u\n",  wert_min[9], wert_max[9]);uart_puts(buffer);

218
      

219
      letzter_wert_min *= 1.1;  // erhöhe das Minimum um 10%

220
      sprintf(buffer, "\tletzter_wert_min erhoeht auf %u\n\n",letzter_wert_min );

221
      uart_puts(buffer);

222
    }

223
    if ( wert < letzter_wert_min ) {  // jeder noch kleinere Wert wird zwischengespeichert und das letzte Maximum ins Array geschrieben

224
            sprintf(buffer, "\twert %u < letzter_wert_min %u \n",wert,letzter_wert_min );

225
      uart_puts(buffer);

226
227
      letzter_wert_min = wert;

228
      

229
            sprintf(buffer, "\n\tWerte vorher:\n");uart_puts(buffer);

230
            sprintf(buffer, "\n\twert_min[0] %u \t wert_max[0] %u\n",  wert_min[0], wert_max[0]);uart_puts(buffer);

231
            sprintf(buffer,   "\twert_min[1] %u \t wert_max[1] %u\n",  wert_min[1], wert_max[1]);uart_puts(buffer);

232
            sprintf(buffer,   "\twert_min[2] %u \t wert_max[2] %u\n",  wert_min[2], wert_max[2]);uart_puts(buffer);

233
            sprintf(buffer,   "\twert_min[3] %u \t wert_max[3] %u\n",  wert_min[3], wert_max[3]);uart_puts(buffer);

234
            sprintf(buffer,   "\twert_min[4] %u \t wert_max[4] %u\n",  wert_min[4], wert_max[4]);uart_puts(buffer);

235
            sprintf(buffer,   "\twert_min[5] %u \t wert_max[5] %u\n",  wert_min[5], wert_max[5]);uart_puts(buffer);

236
            sprintf(buffer,   "\twert_min[6] %u \t wert_max[6] %u\n",  wert_min[6], wert_max[6]);uart_puts(buffer);

237
            sprintf(buffer,   "\twert_min[7] %u \t wert_max[7] %u\n",  wert_min[7], wert_max[7]);uart_puts(buffer);

238
            sprintf(buffer,   "\twert_min[8] %u \t wert_max[8] %u\n",  wert_min[8], wert_max[8]);uart_puts(buffer);

239
            sprintf(buffer,   "\twert_min[9] %u \t wert_max[9] %u\n",  wert_min[9], wert_max[9]);uart_puts(buffer);

240
      

241
      wert_max[0] = wert_max[1];

242
      wert_max[1] = wert_max[2];

243
      wert_max[2] = wert_max[3];

244
      wert_max[3] = wert_max[4];

245
      wert_max[4] = wert_max[5];

246
      wert_max[5] = wert_max[6];

247
      wert_max[6] = wert_max[7];

248
      wert_max[7] = wert_max[8];

249
      wert_max[8] = wert_max[9];

250
      wert_max[9] = letzter_wert_max;

251
252
            sprintf(buffer, "\n\tWerte nach einfügen von letzter_wert_max %u:\n", letzter_wert_max );uart_puts(buffer);

253
            sprintf(buffer, "\n\twert_min[0] %u \t wert_max[0] %u\n",  wert_min[0], wert_max[0]);uart_puts(buffer);

254
            sprintf(buffer,   "\twert_min[1] %u \t wert_max[1] %u\n",  wert_min[1], wert_max[1]);uart_puts(buffer);

255
            sprintf(buffer,   "\twert_min[2] %u \t wert_max[2] %u\n",  wert_min[2], wert_max[2]);uart_puts(buffer);

256
            sprintf(buffer,   "\twert_min[3] %u \t wert_max[3] %u\n",  wert_min[3], wert_max[3]);uart_puts(buffer);

257
            sprintf(buffer,   "\twert_min[4] %u \t wert_max[4] %u\n",  wert_min[4], wert_max[4]);uart_puts(buffer);

258
            sprintf(buffer,   "\twert_min[5] %u \t wert_max[5] %u\n",  wert_min[5], wert_max[5]);uart_puts(buffer);

259
            sprintf(buffer,   "\twert_min[6] %u \t wert_max[6] %u\n",  wert_min[6], wert_max[6]);uart_puts(buffer);

260
            sprintf(buffer,   "\twert_min[7] %u \t wert_max[7] %u\n",  wert_min[7], wert_max[7]);uart_puts(buffer);

261
            sprintf(buffer,   "\twert_min[8] %u \t wert_max[8] %u\n",  wert_min[8], wert_max[8]);uart_puts(buffer);

262
            sprintf(buffer,   "\twert_min[9] %u \t wert_max[9] %u\n",  wert_min[9], wert_max[9]);uart_puts(buffer);

263
264
      

265
      letzter_wert_max *= 0.9;  // verringere das Maximum um 10%

266
      sprintf(buffer, "\tletzter_wert_max verringert auf %u\n",letzter_wert_max );

267
      uart_puts(buffer);

268
    }

269
    // if ( wert > uint16_t ((array_avg(wert_max) - array_avg(wert_min) / 2)*1,1 + array_avg(wert_min)) ) {  // wenn Wert größer als 10% über dem Mittelwert der Durchschnittsamplitude

270
      // sprintf(buffer, "Impuls an: %u > %u\n",wert, uint16_t ((array_avg(wert_max) - array_avg(wert_min) / 2)*1.1 + array_avg(wert_min)) );

271
      // uart_puts(buffer);

272
      // GeberPORT |=  (1 << GeberPORTPin); // Impulsausgang an

273
    // }

274
    // if ( wert < uint16_t ((array_avg(wert_max) - array_avg(wert_min) / 2)*0,9 + array_avg(wert_min)) ) {  // wenn Wert kleiner als 10% unter dem Mittelwert der Durchschnittsamplitude

275
      // sprintf(buffer, "Impuls aus: %u > %u\n",wert, uint16_t ((array_avg(wert_max) - array_avg(wert_min) / 2)*0.9 + array_avg(wert_min)) );

276
      // uart_puts(buffer);

277
      // GeberPORT &= ~(1 << GeberPORTPin); // Impulsausgang aus

278
    // }

279
  }

280
}


Vielen Dank für eure Hinweise!

Gregor

  


  




  

    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: Speicher/Array kommt durcheinander/wird überschrieben ?
  


  

    

      von
      
        spess53 (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Hi

Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

MfG Spess

  


  




  

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







      

      



  

    Re: Speicher/Array kommt durcheinander/wird überschrieben ?
  


  

    

      von
      
        Dr. Sommer (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Schreibe doch mal "snprintf(buffer, sizeof(buffer), ..." statt sprintf. 
So viele sprintf's fordern einen Buffer Overflow ja geradezu heraus.

Und warum #include ".\uart.h"? Damit man das garantiert nicht unter 
Linux kompilieren kann? Mach doch einfach #include "uart.h".
Falls doch mal Verzeichnisse in #include-Pfade aufgenommen werden, 
schreibe / statt \, das geht unter Windows und Linux - \ hingegen nur 
unter Windows.

  


  




  

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







      

      



  

    Re: Speicher/Array kommt durcheinander/wird überschrieben ?
  


  

    

      von
      
        Jim M.
        (turboj)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Das  char buffer[30]; ist zu klein. Zähl mal durch, Du packst da ein 
paar Mal mehr Bytes rein.

Die sprintf() ist für ihre Buffer overflows bekannt, deswegen nimmt man 
lieber sowas wie snprintf().

  


  




  

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







      

      



  

    Re: Speicher/Array kommt durcheinander/wird überschrieben ?
  


  

    

      von
      
        Falk B.
        (falk)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Gregor B. schrieb:
> Hallo zusammen!
> ich habe ein für mich völlig unverständliches Problem mit Arrays!

Und nicht nur damit.

> Ich definiere in main() zwei Arrays: wert_min[] und wert_max[] mit je 10
> Werten. Diese kann ich kurz danach auch noch auslesen. Aber unmittelbar
> darauf steht ein EINEM nur noch Müll drin!
> Ab Zeile 66 des Protokolls (Anhang) sieht es schon sehr schlecht aus.
>
> Habe ich ein Problem mit dem Chip (Atmega128), dem Compiler/Optimierung
> oder mit meinem Code?

Mit deinem C-Verständnis.

> Hier der zusammengefasste Ablauf des ersten Durchlaufs:

Aua. Schon mal was von Schleifen gehört? Oder wirst du nach der Länge 
deines Quelltextes bezahlt?

  


  




  

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







      

      



  

    Re: Speicher/Array kommt durcheinander/wird überschrieben ?
  


  

    

      von
      
        PittyJ (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
wert_min[0] = wert_min[1];
  wert_min[1] = wert_min[2];
  wert_min[2] = wert_min[3];
  wert_min[3] = wert_min[4];
  wert_min[4] = wert_min[5];
  wert_min[5] = wert_min[6];
  wert_min[6] = wert_min[7];
  wert_min[7] = wert_min[8];
  wert_min[8] = wert_min[9];

->

for(int i=0;i<9;i++)
{
  wert_min[i] = wert_min[i+1];
}


usw

  


  




  

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







      

      



  

    Re: Speicher/Array kommt durcheinander/wird überschrieben ?
  


  

    

      von
      
        Gregor B.
        (gregor54321)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Jim M. schrieb:
> Das  char buffer[30]; ist zu klein. Zähl mal durch, Du packst da ein
> paar Mal mehr Bytes rein.
>
> Die sprintf() ist für ihre Buffer overflows bekannt, deswegen nimmt man
> lieber sowas wie snprintf().

Das war es!
snprintf schau ich mir an!

Vielen Dank!

  


  




  

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







      

      



  

    Re: Speicher/Array kommt durcheinander/wird überschrieben ?
  


  

    

      von
      
        Einer K. (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
PittyJ schrieb:
> for(int i=0;i<9;i++)
> {
>   wert_min[i] = wert_min[i+1];
> }


memcpy()

Oder evtl. gleich einen Ringpuffer
Denn Daten werden durchs häufige kopieren weder schöner noch sonst wie 
wertvoller.

  


  




  

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







      

      



  

    Re: Speicher/Array kommt durcheinander/wird überschrieben ?
  


  

    

      von
      
        PittyJ (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
>
> memcpy()
>
> Oder evtl. gleich einen Ringpuffer
> Denn Daten werden durchs häufige kopieren weder schöner noch sonst wie
> wertvoller.

Er ist jung, er hat noch Zeit.

  


  




  

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







      

      



  

    Re: Speicher/Array kommt durcheinander/wird überschrieben ?
  


  

    

      von
      
        Stefan F. (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Die ganzen String Literale belegen alle Platz im RAM.

Ich würde Dir dazu raten, sie direkt aus dem Flash Speicher zu 
verwenden, anstatt RAM zu belegen:

1
snprintf_P(buffer, sizeof(buffer), PSTR("\twert_min[9] %u \t wert_max[9] %u\n"),  wert_min[9], wert_max[9]);


Wenn du die serielle Schnittstelle als Konsole (stdout) einrichtest, 
kannst du die Strings direkt mit printf_P() ausgeben. Meine "Hello 
World" Vorlage zeigt, wie man das macht: 
http://stefanfrings.de/avr_hello_world/index.html

  


  




  

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







      

      



  

    Re: Speicher/Array kommt durcheinander/wird überschrieben ?
  


  

    

      von
      
        Peter D.
        (peda)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Ich würde erstmal dieses riesige Copy&Paste Monster in Unterfunktionen 
und Schleifen zerkleinern.
Die Code- und RAM-Einsparung dürfte bei >90% liegen und obendrein wird 
es viel übersichtlicher.

  


  




  

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







      

      



  

    Re: Speicher/Array kommt durcheinander/wird überschrieben ?
  


  

    

      von
      
        Dirk B.
        (dirkb2)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Arduino Fanboy D. schrieb:
> memcpy()

Bei memcpy dürfen sich Ziel und Quelle nicht überlappen.

Darum memmove()

  


  




  

    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.