[AVR]Memory Overflow - Programmcode verkleinern

  • C

SSL ist deaktiviert! Aktivieren Sie SSL für diese Sitzung, um eine sichere Verbindung herzustellen.

Es gibt 11 Antworten in diesem Thema. Der letzte Beitrag () ist von diylab.

    [AVR]Memory Overflow - Programmcode verkleinern

    Hi,

    ich bin dabei in C (AVR-GCC) eine kleine Spannungsanzeige zu programmieren. Als Microcontroller verwende ich den ATTINY13 (1024Bytes PROGMEM, 64Bytes RAM). Mein Problem ist, das mein aktueller Code knapp mehr als 1kB (10Bytes zuviel) braucht. Ich habe selber schon versucht, den Code etwas zu verkleinern, jedoch ohne grossen Erfolg.

    Spoiler anzeigen

    C-Quellcode

    1. /*
    2. * Voltmeter_ATTINY13.c
    3. *
    4. * Created: 06.02.2014 09:42:38
    5. * Author: gespa1
    6. *
    7. * Beschreibung: Ein Voltmeter mit dem ATTINY, die über 1 Shiftregister
    8. * und 2 7SEG/LCD-Treiber auf 7Segment-Anzeigen ausgegeben werden.
    9. *
    10. * Schaltung:
    11. *
    12. * +1.2-12V VOUT
    13. * X----o---------------X
    14. * |
    15. * | ___6.6k ___3.3k
    16. * '----|___|--o--|___|-.
    17. * +5V | |
    18. * X-o-----. .---' GND
    19. * | | |
    20. * .-.10k |8 |3
    21. * | | .-----------. .--------------------.
    22. * | | | |5 CLK| |
    23. * '-' | |-----------| |
    24. * | 1| |6 SER| CD4015BE |
    25. * '--| |-----------| 4bit Shift Register|
    26. * | |7 | |
    27. * | ATTINY 13 |--------. '--------------------'
    28. * | MCU |2 | |4bit BUS
    29. * | |---. | | 7SEG Anzeige
    30. * | | | | .-------. .-----------.
    31. * | | | | |CD4511 | ___220R | LED |
    32. * | | | | CS1| |---|___|--------|---->|-----|------.
    33. * '-----------' | '---------------| |---|___|--------|---->|-----|------o
    34. * |4 | | |---|___|--------|---->|-----|------o
    35. * | | | |---|___|--------|---->|-----|------o
    36. * GND | | |---|___|--------|---->|-----|------o
    37. * | | |---|___|--------|---->|-----|------o
    38. * | | |---|___|--------|---->|-----|------o
    39. * | | | | | |
    40. * | '-------' '-----------' |
    41. * | |4bit BUS GND
    42. * | |
    43. * | .-------. .-----------.
    44. * | |CD4511 | ___220R | LED |
    45. * | CS2| |---|___|--------|---->|-----|------.
    46. * '--------------------| |---|___|--------|---->|-----|------o
    47. * | |---|___|--------|---->|-----|------o
    48. * | |---|___|--------|---->|-----|------o
    49. * | |---|___|--------|---->|-----|------o
    50. * | |---|___|--------|---->|-----|------o
    51. * | |---|___|--------|---->|-----|------o
    52. * | | | | |
    53. * '-------' '-----------' |
    54. * GND
    55. */
    56. #include <avr/io.h>
    57. char E1, E2 = 0;
    58. float ADCNUM = 0;
    59. void Segment_OUT(char SEG1, char SEG2);
    60. void SerialOUT(char num);
    61. int main(void)
    62. {
    63. DDRB |= (1<<PB0) | (1<<PB1) | (1<<PB2) | (1<<PB3);
    64. while(1)
    65. {
    66. ADMUX |= (1<<MUX1);
    67. ADCSRA |= (1<<ADEN) | (1<<ADPS2) | (1<<ADSC);
    68. while (ADCSRA & (1<<ADSC));
    69. ADCNUM = ADC;
    70. ADCNUM = ((ADCNUM * 5) / 1023) *3;
    71. E1 = ADCNUM / 1;
    72. E2 = (int)ADCNUM % 1;
    73. Segment_OUT(E1, E2);
    74. }
    75. }
    76. // Zahl ausgeben
    77. void Segment_OUT(char SEG1, char SEG2)
    78. {
    79. SerialOUT(SEG1);
    80. asm volatile ("sbi 0x18,2 \n\t"
    81. "nop \n\t"
    82. "cbi 0x18,2 \n\t");
    83. SerialOUT(SEG2);
    84. asm volatile ("sbi 0x18,3 \n\t"
    85. "nop \n\t"
    86. "cbi 0x18,3 \n\t"); // hat _delay_us(10) ersetzt
    87. }
    88. // Daten seriell ausgeben
    89. void SerialOUT(char num)
    90. {
    91. for (char i = 0; i < 4; i++)
    92. {
    93. if (num & (1<<i)) PORTB |= (1<<PB1);
    94. PORTB |= (1<<PB0);
    95. asm volatile ("nop"); // hat _delay_us(10) ersetzt
    96. PORTB &=~ (1<<PB0) | (1<<PB1);
    97. }
    98. }


    Könntet ihr mir helfen, den Code kleiner zu machen? Habs schon probiert und konnte 24Bytes 'sichern'.

    thx & mfg

    gfc

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „gfcwfzkm“ ()

    Kann mir kaum vorstellen, dass ein so minimaler Code den ATTINY13 schon seine Grenzen bringt. Ich meine das ist so gut wie rein gar nichts.
    Ich sehe da jetzt auch auf die Schnelle nichts wo man viel einsparen kann. Oft kann man bei Headerdateien einsparen (brauchste wirklich die avr/io.h oder reicht auch eine andere (siehe Beispiel Windows.h => verweist auf viele andere Headerdateien). Für normal müsste das ein compiler aber auch weg optimieren.
    Du könntest auch versuchen rien mit AVR ASM auszukommen (welcher eigentlich recht einfach ist) oder du verwendest ne komplett andere Sprache wie z.B. BASCOM BASIC.
    PS:
    Bringt zwar nix aber rein vom Codestil:

    Quellcode

    1. while (ADCSRA & (1<<ADSC)) {}

    Kannste in

    Quellcode

    1. while (ADCSRA & (1<<ADSC));

    ändern.


    Opensource Audio-Bibliothek auf github: KLICK, im Showroom oder auf NuGet.
    Habe schon teile (delay durch nop) in Assembler geändert.
    Das Problem ist, das ich keine Erfahrung mit Kommazahlen in Assembler habe, die ich jedoch benötige.
    Und ich zweifle das BASCOM Basic besser/effektiver ist als AVR-GCC ^^

    Habe schon die Code optimierungs-Optionen eingehauen... :/

    EDIT://
    Hab mal die Int und uint8_t's durch "char" ersetzt. Nun fehlt mir genau 1 Byte :o

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „gfcwfzkm“ ()

    gfcwfzkm schrieb:

    C-Quellcode

    1. ADCNUM = ((ADCNUM * 5) / 1023) *3;
    Kann es sein, dass durch 1024 geteilt werden muss?
    Dann könntest Du aus ADCNUM ein Integer machen und das war es dann schon.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!
    Leider ja, benötige den Wert nach dem Komma um die Spannung richtig anzuzeigen.

    gfcwfzkm schrieb:

    Und ich zweifle das BASCOM Basic besser/effektiver ist als AVR-GCC ^^

    Da wäre ich mir an Deiner Stelle nicht so sicher!
    Ich habe in meiner aktiven Modellbauzeit einen sehr guten PWM-Motorsteller mit diversen Messungen, Automatiken und Failsafe in einen Tiny13 gequetscht und er war nicht voll.
    Also erst selbst testen, dann solche Aussagen machen.

    Übrigens, egal ob Du Dein Problem löst, ich finde es merkwürdig, dass Du das Projekt unbedingt in einen Tiny13 stopfen willst.
    Wenn es denn unbedingt ein 8-Beiner sein soll, dann eben ein Tiny45 o.ä. - da ist mehr Platz.

    Allerdings entzieht sich mir der Sinn des Ganzen - es sei denn man macht es um zu Lernen?
    Denn Du nimmst außer dem AVR noch ein Schieberegister und zwei Decoder - alle drei ICs viel größer als der AVR selbst :D ..

    Schau mal - ich hatte damals einen Akkupack-Entlader mit sehr präziser Spannungsanzeige gebaut und dafür einen Tiny26L genommen - der war dafür genial:


    Denke Dir alles auf der linken Seite des Tiny26 weg und die reine Anzeige befindet sich rechts vom AVR (die Taster natürlich auch wegdenken *ggg*).
    Ich kam völlig ohne Spalten- und Segmentreiber aus - einfacher gehts nicht.
    Die 7-Segment Anzeigen sind natürlich LowCurrent-Versionen.

    LG,
    Bruno
    =) Schönes Projekt diylab.

    Ich mach es teilweise aus Lernzwecken("Porterweiterungen" mit Shift-Register) und Materialgründen("Will meine 74'er ICs und ATTINYs mal brauchen ^^").

    Ich glaube, das C ziehmlich mit dem "float" zu kämpfen hat. Als ich das mal zum probieren die Zeile "float ADCNUM = 0;" durch "int ADCNUM = 0;" ersetzt habe, ist das Programm auf 276Bytes gefallen :wacko:
    jedoch wüsste ich nicht wie ich um das float herumkomme um an mein Ziel zu gelangen :S

    gfcwfzkm schrieb:

    jedoch wüsste ich nicht wie ich um das float herumkomme um an mein Ziel zu gelangen :S


    float gibts bei mir nicht :)
    Und Divisionen möglichst durch Bit-Shiften ersetzen..

    Anbei der BASCOM-Code von damals - vielleicht hilfts Dir ja, auf neue Ideen in 'C' zu kommen?

    Spoiler anzeigen

    VB.NET-Quellcode

    1. '******************************************************************************
    2. '******************************************************************************
    3. '** **
    4. '** ENTLADER mit ATtiny26 & LED-Anzeige **
    5. '** ------------ **
    6. '** Version: 1.1 - 10.09.2006 **
    7. '** **
    8. '** 6 bis 32 Zellen, 0,7V bis 1,3V, Abschaltung über 40,9V **
    9. '** **
    10. '******************************************************************************
    11. '******************************************************************************
    12. '==============================================================================
    13. 'COMPILER
    14. '==============================================================================
    15. $Device = Tiny26
    16. $Stack = 32
    17. $Clock = 4
    18. $Source = On
    19. '------------------------------------------------------------------------------
    20. '==============================================================================
    21. ' INIT
    22. '==============================================================================
    23. '~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    24. Dim Result As Word
    25. Dim ADCin As Word
    26. Dim Summe As Word
    27. Dim abschalt As Word
    28. Dim hunderter As Byte
    29. Dim zehner As Byte
    30. Dim einer As Byte
    31. Dim stelle As Byte
    32. Dim bcd_aus As Byte
    33. Dim ausgang As Byte
    34. Dim zellen As Byte
    35. Dim cutoff As Byte
    36. Dim CutoffMin As Byte
    37. Dim tcounter As Byte
    38. Dim dp As Byte
    39. Dim i As Byte
    40. Dim Ok As Bit
    41. '~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    42. '~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    43. Declare Interrupt Ovf0()
    44. Declare Sub einlesen()
    45. Declare Sub tasten()
    46. Declare Sub separieren()
    47. Declare Sub Sek()
    48. '~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    49. '~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    50. DDRA = &B11111111
    51. DDRB = &B10101111
    52. '~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    53. '~ KOMPARATOR ~~~~~~~~~~~~~~~
    54. ACSR = &B10000000 'OFF - spart Strom!
    55. '~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    56. '~ TIMER0 ~~~~~~~~~~~~~~~~~~~
    57. TIMSK = &B00000010 'Timer0 Overflow IRQ=ON
    58. TCCR0 = &B00000011 'Prescaler=64
    59. '~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    60. '~ TIMER1 ~~~~~~~~~~~~~~~~~~~
    61. TCCR1A = &B00100001
    62. TCCR1B = &B00001001 '1000Hz
    63. OCR1C = 255 'Upper Limit
    64. OCR1B = 0 'Compare for OSC1B Outputs
    65. PLLCSR.1 = 1 'To use Asyn PLL, 64mhz clock source
    66. WaitMs 150
    67. PLLCSR.2 = 1
    68. '~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    69. '~ ADC ~~~~~~~~~~~~~~~~~~~~~~
    70. ADMUX = &B01000000 'externe Referenzspannung
    71. ADCSR = &B11000111 'ADC=ON, Start Wandlung, FreeRunning=OFF, ADC-IRQ=OFF, Prescaler=128
    72. '~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    73. 'Enable Interrupts 'Interrupts global einschalten
    74. '-------------------------------------------------------------------------------
    75. Ok = 0
    76. dp = 0 'Dezimalpunkt AUS
    77. '===============================================================================
    78. ' SETUP
    79. '===============================================================================
    80. '- 3x CEL BLINKEN LASSEN -------------------------------------------------------
    81. For i=1 To 3
    82. '--------------
    83. Disable Interrupts
    84. PORTA=0
    85. PORTB=0
    86. '--------------
    87. WaitMs 255
    88. Enable Interrupts 'Interrupts global einschalten
    89. '--------------
    90. hunderter = 13 '"CEL" darstellen
    91. zehner = 11
    92. einer = 14
    93. '--------------
    94. WaitMs 255
    95. Next i
    96. '-------------------------------------------------------------------------------
    97. tcounter = ReadEE(&H10)
    98. Sek() '1Sek
    99. '-ZELLENZAHL EINSTELLEN---------------------------------------------------------
    100. While Ok = 0
    101. tasten()
    102. If tcounter < 6 Then tcounter = 6 'Zellen zwischen 6 und 30 begrenzen
    103. If tcounter > 32 Then tcounter = 32
    104. Result = tcounter * 10
    105. separieren() 'einzelne Stellen separieren für die Anzeige
    106. WaitMs 150
    107. Wend
    108. zellen = tcounter 'Anzahl Zellen in Var "zellen" ablegen
    109. WriteEE(&H10,zellen)
    110. '-------------------------------------------------------------------------------
    111. '- 3x CUT BLINKEN LASSEN -------------------------------------------------------
    112. For i=1 To 3
    113. '--------------
    114. Disable Interrupts
    115. PORTA=0
    116. PORTB=0
    117. '--------------
    118. WaitMs 255
    119. Enable Interrupts 'Interrupts global einschalten
    120. '--------------
    121. hunderter = 13 '"CUT" darstellen
    122. zehner = 15
    123. einer = 12
    124. '--------------
    125. WaitMs 255
    126. Next i
    127. '-------------------------------------------------------------------------------
    128. tcounter = ReadEE(&H20)
    129. Sek() '1Sek
    130. '----------------------
    131. While ADCin < 900
    132. tasten()
    133. Wend
    134. '----------------------
    135. '-CUT OFF SPANNUNG EINSTELLEN---------------------------------------------------
    136. dp = 1 'Dezimalpunkt an 1. Stelle
    137. 'ab 7 Zellen ist die CutOff-Spannung 0,7V, bei 6 Zellen 0,9V
    138. CutoffMin = 70
    139. If Zellen = 6 Then CutOffMin = 90
    140. While Ok = 0
    141. tasten()
    142. If tcounter < CutoffMin Then tcounter = CutoffMin 'Spannungsanzeige begrenzen
    143. If tcounter > 130 Then tcounter = 130
    144. Result = tcounter * 10
    145. separieren() 'einzelne Stellen separieren für die Anzeige
    146. WaitMs 150
    147. Wend
    148. cutoff = tcounter 'CUT-OFF Spannung in Var "cutoff" ablegen
    149. WriteEE(&H20,cutoff)
    150. '-------------------------------------------------------------------------------
    151. dp = 0 'Dezimalpunkt AUS
    152. '--------------
    153. hunderter = 16 '"run" darstellen
    154. zehner = 17
    155. einer = 18
    156. '--------------
    157. '===============================================================================
    158. ' Hauptprogramm
    159. '===============================================================================
    160. einlesen()
    161. If Summe > 4090 Then GoTo schlafen
    162. '--------------------------
    163. abschalt = zellen * cutoff 'Abschaltschwelle berechnen
    164. '--------------------------
    165. '--------------------------
    166. For i = 0 To 255 'Last langsam von 0 bis 100% PWM hochfahren
    167. OCR1B = i
    168. WaitMs 20
    169. Next i
    170. '--------------------------
    171. OCR1B = 255
    172. dp = 2 'Dezimalpunt an 2. Stelle
    173. '-Anfang Hauptschleife-
    174. Do
    175. einlesen()
    176. '----------------------------------
    177. 'Wenn Abschaltspannung erreicht -> raus
    178. If Summe <= abschalt Then GoTo raus
    179. 'Überspannungsschutz
    180. If Summe > 4090 Then GoTo schlafen
    181. '----------------------------------
    182. '----------------------------------
    183. Incr tcounter 'Anzeige zwischen Soll- und Istwert alterieren
    184. If tcounter > 20 Then
    185. tcounter = 0
    186. Do
    187. dp = 2
    188. Result = abschalt
    189. separieren()
    190. WaitMs 255
    191. dp = 0
    192. hunderter = 20
    193. zehner = 20
    194. einer = 20
    195. WaitMs 255
    196. Incr tcounter
    197. Loop While tcounter <> 2
    198. tcounter = 0
    199. Else
    200. dp = 2
    201. Result = Summe
    202. separieren()
    203. End If
    204. '----------------------------------
    205. Loop
    206. '-Ende Hauptschleife-
    207. '-------------------------------------------------------------------------------
    208. '===
    209. End
    210. '===
    211. '===============================================================================
    212. ' ISR - Ausgabe 7-Segment Anzeige und PWM
    213. '===============================================================================
    214. Interrupt Ovf0(), Save 2
    215. TCNT0 = 194
    216. PORTA = 0 'Alle Ziffern aus, ansonsten gibt es "Geister" Anzeigen
    217. If stelle = 3 Then stelle = 0 'bestimmt die auszugebende Ziffer (1 bis 3)
    218. Incr stelle
    219. Select Case stelle 'welche Ziffer soll angesteuert werden?
    220. Case 1
    221. PORTB = &B011
    222. If dp = 1 Then PORTB.5 = 1
    223. bcd_aus = hunderter
    224. If dp = 0 Or dp = 2 Then
    225. If bcd_aus = 0 Then bcd_aus = 20 'Nullen unterdrücken
    226. End If
    227. Case 2
    228. PORTB = &B110
    229. If dp = 2 Then PORTB.5 = 1
    230. bcd_aus = zehner
    231. If dp = 0 And bcd_aus = 0 Then bcd_aus = 20 'Nullen unterdrücken
    232. Case 3
    233. PORTB = &B101
    234. bcd_aus = einer
    235. End Select
    236. '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    237. Select Case bcd_aus '7-Segmentcode f. gem. Katoden
    238. '--> Ziffern
    239. Case 0 : PORTA = &B11100111 '0
    240. Case 1 : PORTA = &B10000010 '1
    241. Case 2 : PORTA = &B01110011 '2
    242. Case 3 : PORTA = &B11010011 '3
    243. Case 4 : PORTA = &B10010110 '4
    244. Case 5 : PORTA = &B11010101 '5
    245. Case 6 : PORTA = &B11110101 '6
    246. Case 7 : PORTA = &B10000011 '7
    247. Case 8 : PORTA = &B11110111 '8
    248. Case 9 : PORTA = &B11011111 '9
    249. '--> Sonderzeichen
    250. Case 11 : PORTA = &B01110101 'E
    251. Case 12 : PORTA = &B00100101 'T
    252. Case 13 : PORTA = &B01100101 'C
    253. Case 14 : PORTA = &B01100100 'L
    254. Case 15 : PORTA = &B11100110 'U
    255. Case 16 : PORTA = &B00110000 'r
    256. Case 17 : PORTA = &B11100000 'u
    257. Case 18 : PORTA = &B10110000 'n
    258. Case 19 : PORTA = &B11110010 'd
    259. Case 20 : PORTA = &B00000000 'BLANK
    260. End Select
    261. '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    262. End Interrupt
    263. '-------------------------------------------------------------------------------
    264. '===============================================================================
    265. ' ADC
    266. '===============================================================================
    267. Sub einlesen()
    268. Summe = 0
    269. For i=1 To 16
    270. ADCin = Adc(7)
    271. WaitMs 16
    272. Summe = summe + ADCin
    273. Next i
    274. Shift(Right, 2, Summe) '/4
    275. End Sub
    276. '-------------------------------------------------------------------------------
    277. '===============================================================================
    278. ' Stellen separieren
    279. '===============================================================================
    280. Sub separieren()
    281. hunderter = 0
    282. zehner = 0
    283. einer = 0
    284. While result >= 1000
    285. result = result - 1000
    286. Incr hunderter
    287. Wend
    288. While result >= 100
    289. result = result - 100
    290. Incr zehner
    291. Wend
    292. While result >= 10
    293. result = result - 10
    294. Incr einer
    295. Wend
    296. End Sub
    297. '-------------------------------------------------------------------------------
    298. '===============================================================================
    299. ' Tastenauswertung
    300. '===============================================================================
    301. Sub tasten()
    302. ADCin = Adc(9)
    303. WaitMs 5
    304. ADCin = Adc(9)
    305. WaitMs 5
    306. Ok = 0
    307. If ADCin > 50 And ADCin < 100 Then Decr tcounter
    308. If ADCin > 200 And ADCin < 300 Then Incr tcounter
    309. If ADCin > 550 And ADCin < 750 Then Ok = 1
    310. End Sub
    311. '-------------------------------------------------------------------------------
    312. '===============================================================================
    313. ' Verzögerungszeit * 255ms
    314. '===============================================================================
    315. Sub Sek()
    316. WaitMs 255
    317. WaitMs 255
    318. WaitMs 255
    319. WaitMs 255
    320. End Sub
    321. '-------------------------------------------------------------------------------
    322. '===============================================================================
    323. ' raus - Ausstieg, wenn Abschaltschwelle erreicht ist
    324. '===============================================================================
    325. raus:
    326. OCR1B = 0
    327. For i = 1 To 100
    328. dp = 0
    329. '--------------
    330. hunderter = 11 '"End" darstellen
    331. zehner = 18
    332. einer = 19
    333. '--------------
    334. Sek() '1Sek
    335. dp = 2
    336. Result = abschalt 'Abschaltspannung darstellen
    337. separieren()
    338. Sek() '1Sek
    339. Next i
    340. '-------------------------------------------------------------------------------
    341. '===============================================================================
    342. ' Schlafen gehen..
    343. '===============================================================================
    344. schlafen:
    345. OCR1B = 0
    346. Disable Interrupts
    347. PORTA=0
    348. PORTB=0
    349. PowerDown
    350. End
    351. '-------------------------------------------------------------------------------


    LG,
    Bruno
    ^^ ich glaube das der C-Compiler die Division schon selbst in Bit-Shiften ändert.

    Also das Problem (Float) ist gefunden, aber ein Ersatz müsste her. hmm...
    Ein AVR hat ein 10bit ADC -> 1024.
    ein 8Bit-ADC hätte nur 256 Werte.
    Hab dein Code überflogen da ich dieses BASCOM Basic mühsam zum lesen finde (C sieht einfach hübscher aus ^^)

    Aber jetzt sehe ich es :O (facepalm)
    ich ändere im Code die Zeile 73 zu: ADCNUM = ((ADCNUM * 50) / 1023) * 3;
    So komm ich mit einem "integer" gut davon =)

    Mal Probieren ob das geht...

    EDIT:// :o mein Code ist nun nur ca. 350B gross. Mission Complete =). Thx an alle =D

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „gfcwfzkm“ ()

    gfcwfzkm schrieb:

    Ein AVR hat ein 10bit ADC -> 1024.
    ein 8Bit-ADC hätte nur 256 Werte.


    Richtig :D . Bin eingerostet :rolleyes: .
    Aber GLÜCKWUNSCH, dass Du die float-Lib nicht mehr brauchst - freu mich!

    Und wenn Du jetzt noch mehrere Messungen zusammenfasst wie ich das in der Schleife tue, dann wirds nicht so "zapplig".

    LG,
    Bruno

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „diylab“ ()