[AVR]Memory Overflow - Programmcode verkleinern

gfcwfzkm · 6. Februar 2014, 18:31

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

/*
* Voltmeter_ATTINY13.c
*
* Created: 06.02.2014 09:42:38
* Author: gespa1
*
* Beschreibung: Ein Voltmeter mit dem ATTINY, die über 1 Shiftregister
* und 2 7SEG/LCD-Treiber auf 7Segment-Anzeigen ausgegeben werden.
*
* Schaltung:
*
* +1.2-12V VOUT
* X----o---------------X
* |
* | ___6.6k ___3.3k
* '----|___|--o--|___|-.
* +5V | |
* X-o-----. .---' GND
* | | |
* .-.10k |8 |3
* | | .-----------. .--------------------.
* | | | |5 CLK| |
* '-' | |-----------| |
* | 1| |6 SER| CD4015BE |
* '--| |-----------| 4bit Shift Register|
* | |7 | |
* | ATTINY 13 |--------. '--------------------'
* | MCU |2 | |4bit BUS
* | |---. | | 7SEG Anzeige
* | | | | .-------. .-----------.
* | | | | |CD4511 | ___220R | LED |
* | | | | CS1| |---|___|--------|---->|-----|------.
* '-----------' | '---------------| |---|___|--------|---->|-----|------o
* |4 | | |---|___|--------|---->|-----|------o
* | | | |---|___|--------|---->|-----|------o
* GND | | |---|___|--------|---->|-----|------o
* | | |---|___|--------|---->|-----|------o
* | | |---|___|--------|---->|-----|------o
* | | | | | |
* | '-------' '-----------' |
* | |4bit BUS GND
* | |
* | .-------. .-----------.
* | |CD4511 | ___220R | LED |
* | CS2| |---|___|--------|---->|-----|------.
* '--------------------| |---|___|--------|---->|-----|------o
* | |---|___|--------|---->|-----|------o
* | |---|___|--------|---->|-----|------o
* | |---|___|--------|---->|-----|------o
* | |---|___|--------|---->|-----|------o
* | |---|___|--------|---->|-----|------o
* | | | | |
* '-------' '-----------' |
* GND
*/
#include <avr/io.h>
char E1, E2 = 0;
float ADCNUM = 0;
void Segment_OUT(char SEG1, char SEG2);
void SerialOUT(char num);
int main(void)
{
DDRB |= (1<<PB0) | (1<<PB1) | (1<<PB2) | (1<<PB3);
while(1)
{
ADMUX |= (1<<MUX1);
ADCSRA |= (1<<ADEN) | (1<<ADPS2) | (1<<ADSC);
while (ADCSRA & (1<<ADSC));
ADCNUM = ADC;
ADCNUM = ((ADCNUM * 5) / 1023) *3;
E1 = ADCNUM / 1;
E2 = (int)ADCNUM % 1;
Segment_OUT(E1, E2);
}
}
// Zahl ausgeben
void Segment_OUT(char SEG1, char SEG2)
{
SerialOUT(SEG1);
asm volatile ("sbi 0x18,2 \n\t"
"nop \n\t"
"cbi 0x18,2 \n\t");
SerialOUT(SEG2);
asm volatile ("sbi 0x18,3 \n\t"
"nop \n\t"
"cbi 0x18,3 \n\t"); // hat _delay_us(10) ersetzt
}
// Daten seriell ausgeben
void SerialOUT(char num)
{
for (char i = 0; i < 4; i++)
{
if (num & (1<<i)) PORTB |= (1<<PB1);
PORTB |= (1<<PB0);
asm volatile ("nop"); // hat _delay_us(10) ersetzt
PORTB &=~ (1<<PB0) | (1<<PB1);
}
}

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

thx & mfg

gfc

thefiloe · 6. Februar 2014, 18:38

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

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

Kannste in

Quellcode

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

ändern.

gfcwfzkm · 6. Februar 2014, 18:42

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

RodFromGermany · 7. Februar 2014, 08:15

gfcwfzkm schrieb:

C-Quellcode

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.

gfcwfzkm · 7. Februar 2014, 09:59

Leider ja, benötige den Wert nach dem Komma um die Spannung richtig anzuzeigen.

diylab · 7. Februar 2014, 10:20

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

..

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

gfcwfzkm · 7. Februar 2014, 14:32

=) 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

diylab · 7. Februar 2014, 14:49

gfcwfzkm schrieb:

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

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

'******************************************************************************
'******************************************************************************
'** **
'** ENTLADER mit ATtiny26 & LED-Anzeige **
'** ------------ **
'** Version: 1.1 - 10.09.2006 **
'** **
'** 6 bis 32 Zellen, 0,7V bis 1,3V, Abschaltung über 40,9V **
'** **
'******************************************************************************
'******************************************************************************
'==============================================================================
'COMPILER
'==============================================================================
$Device = Tiny26
$Stack = 32
$Clock = 4
$Source = On
'------------------------------------------------------------------------------
'==============================================================================
' INIT
'==============================================================================
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Dim Result As Word
Dim ADCin As Word
Dim Summe As Word
Dim abschalt As Word
Dim hunderter As Byte
Dim zehner As Byte
Dim einer As Byte
Dim stelle As Byte
Dim bcd_aus As Byte
Dim ausgang As Byte
Dim zellen As Byte
Dim cutoff As Byte
Dim CutoffMin As Byte
Dim tcounter As Byte
Dim dp As Byte
Dim i As Byte
Dim Ok As Bit
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Declare Interrupt Ovf0()
Declare Sub einlesen()
Declare Sub tasten()
Declare Sub separieren()
Declare Sub Sek()
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~
DDRA = &B11111111
DDRB = &B10101111
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~
'~ KOMPARATOR ~~~~~~~~~~~~~~~
ACSR = &B10000000 'OFF - spart Strom!
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~
'~ TIMER0 ~~~~~~~~~~~~~~~~~~~
TIMSK = &B00000010 'Timer0 Overflow IRQ=ON
TCCR0 = &B00000011 'Prescaler=64
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~
'~ TIMER1 ~~~~~~~~~~~~~~~~~~~
TCCR1A = &B00100001
TCCR1B = &B00001001 '1000Hz
OCR1C = 255 'Upper Limit
OCR1B = 0 'Compare for OSC1B Outputs
PLLCSR.1 = 1 'To use Asyn PLL, 64mhz clock source
WaitMs 150
PLLCSR.2 = 1
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~
'~ ADC ~~~~~~~~~~~~~~~~~~~~~~
ADMUX = &B01000000 'externe Referenzspannung
ADCSR = &B11000111 'ADC=ON, Start Wandlung, FreeRunning=OFF, ADC-IRQ=OFF, Prescaler=128
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~
'Enable Interrupts 'Interrupts global einschalten
'-------------------------------------------------------------------------------
Ok = 0
dp = 0 'Dezimalpunkt AUS
'===============================================================================
' SETUP
'===============================================================================
'- 3x CEL BLINKEN LASSEN -------------------------------------------------------
For i=1 To 3
'--------------
Disable Interrupts
PORTA=0
PORTB=0
'--------------
WaitMs 255
Enable Interrupts 'Interrupts global einschalten
'--------------
hunderter = 13 '"CEL" darstellen
zehner = 11
einer = 14
'--------------
WaitMs 255
Next i
'-------------------------------------------------------------------------------
tcounter = ReadEE(&H10)
Sek() '1Sek
'-ZELLENZAHL EINSTELLEN---------------------------------------------------------
While Ok = 0
tasten()
If tcounter < 6 Then tcounter = 6 'Zellen zwischen 6 und 30 begrenzen
If tcounter > 32 Then tcounter = 32
Result = tcounter * 10
separieren() 'einzelne Stellen separieren für die Anzeige
WaitMs 150
Wend
zellen = tcounter 'Anzahl Zellen in Var "zellen" ablegen
WriteEE(&H10,zellen)
'-------------------------------------------------------------------------------
'- 3x CUT BLINKEN LASSEN -------------------------------------------------------
For i=1 To 3
'--------------
Disable Interrupts
PORTA=0
PORTB=0
'--------------
WaitMs 255
Enable Interrupts 'Interrupts global einschalten
'--------------
hunderter = 13 '"CUT" darstellen
zehner = 15
einer = 12
'--------------
WaitMs 255
Next i
'-------------------------------------------------------------------------------
tcounter = ReadEE(&H20)
Sek() '1Sek
'----------------------
While ADCin < 900
tasten()
Wend
'----------------------
'-CUT OFF SPANNUNG EINSTELLEN---------------------------------------------------
dp = 1 'Dezimalpunkt an 1. Stelle
'ab 7 Zellen ist die CutOff-Spannung 0,7V, bei 6 Zellen 0,9V
CutoffMin = 70
If Zellen = 6 Then CutOffMin = 90
While Ok = 0
tasten()
If tcounter < CutoffMin Then tcounter = CutoffMin 'Spannungsanzeige begrenzen
If tcounter > 130 Then tcounter = 130
Result = tcounter * 10
separieren() 'einzelne Stellen separieren für die Anzeige
WaitMs 150
Wend
cutoff = tcounter 'CUT-OFF Spannung in Var "cutoff" ablegen
WriteEE(&H20,cutoff)
'-------------------------------------------------------------------------------
dp = 0 'Dezimalpunkt AUS
'--------------
hunderter = 16 '"run" darstellen
zehner = 17
einer = 18
'--------------
'===============================================================================
' Hauptprogramm
'===============================================================================
einlesen()
If Summe > 4090 Then GoTo schlafen
'--------------------------
abschalt = zellen * cutoff 'Abschaltschwelle berechnen
'--------------------------
'--------------------------
For i = 0 To 255 'Last langsam von 0 bis 100% PWM hochfahren
OCR1B = i
WaitMs 20
Next i
'--------------------------
OCR1B = 255
dp = 2 'Dezimalpunt an 2. Stelle
'-Anfang Hauptschleife-
Do
einlesen()
'----------------------------------
'Wenn Abschaltspannung erreicht -> raus
If Summe <= abschalt Then GoTo raus
'Überspannungsschutz
If Summe > 4090 Then GoTo schlafen
'----------------------------------
'----------------------------------
Incr tcounter 'Anzeige zwischen Soll- und Istwert alterieren
If tcounter > 20 Then
tcounter = 0
Do
dp = 2
Result = abschalt
separieren()
WaitMs 255
dp = 0
hunderter = 20
zehner = 20
einer = 20
WaitMs 255
Incr tcounter
Loop While tcounter <> 2
tcounter = 0
Else
dp = 2
Result = Summe
separieren()
End If
'----------------------------------
Loop
'-Ende Hauptschleife-
'-------------------------------------------------------------------------------
'===
End
'===
'===============================================================================
' ISR - Ausgabe 7-Segment Anzeige und PWM
'===============================================================================
Interrupt Ovf0(), Save 2
TCNT0 = 194
PORTA = 0 'Alle Ziffern aus, ansonsten gibt es "Geister" Anzeigen
If stelle = 3 Then stelle = 0 'bestimmt die auszugebende Ziffer (1 bis 3)
Incr stelle
Select Case stelle 'welche Ziffer soll angesteuert werden?
Case 1
PORTB = &B011
If dp = 1 Then PORTB.5 = 1
bcd_aus = hunderter
If dp = 0 Or dp = 2 Then
If bcd_aus = 0 Then bcd_aus = 20 'Nullen unterdrücken
End If
Case 2
PORTB = &B110
If dp = 2 Then PORTB.5 = 1
bcd_aus = zehner
If dp = 0 And bcd_aus = 0 Then bcd_aus = 20 'Nullen unterdrücken
Case 3
PORTB = &B101
bcd_aus = einer
End Select
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Select Case bcd_aus '7-Segmentcode f. gem. Katoden
'--> Ziffern
Case 0 : PORTA = &B11100111 '0
Case 1 : PORTA = &B10000010 '1
Case 2 : PORTA = &B01110011 '2
Case 3 : PORTA = &B11010011 '3
Case 4 : PORTA = &B10010110 '4
Case 5 : PORTA = &B11010101 '5
Case 6 : PORTA = &B11110101 '6
Case 7 : PORTA = &B10000011 '7
Case 8 : PORTA = &B11110111 '8
Case 9 : PORTA = &B11011111 '9
'--> Sonderzeichen
Case 11 : PORTA = &B01110101 'E
Case 12 : PORTA = &B00100101 'T
Case 13 : PORTA = &B01100101 'C
Case 14 : PORTA = &B01100100 'L
Case 15 : PORTA = &B11100110 'U
Case 16 : PORTA = &B00110000 'r
Case 17 : PORTA = &B11100000 'u
Case 18 : PORTA = &B10110000 'n
Case 19 : PORTA = &B11110010 'd
Case 20 : PORTA = &B00000000 'BLANK
End Select
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
End Interrupt
'-------------------------------------------------------------------------------
'===============================================================================
' ADC
'===============================================================================
Sub einlesen()
Summe = 0
For i=1 To 16
ADCin = Adc(7)
WaitMs 16
Summe = summe + ADCin
Next i
Shift(Right, 2, Summe) '/4
End Sub
'-------------------------------------------------------------------------------
'===============================================================================
' Stellen separieren
'===============================================================================
Sub separieren()
hunderter = 0
zehner = 0
einer = 0
While result >= 1000
result = result - 1000
Incr hunderter
Wend
While result >= 100
result = result - 100
Incr zehner
Wend
While result >= 10
result = result - 10
Incr einer
Wend
End Sub
'-------------------------------------------------------------------------------
'===============================================================================
' Tastenauswertung
'===============================================================================
Sub tasten()
ADCin = Adc(9)
WaitMs 5
ADCin = Adc(9)
WaitMs 5
Ok = 0
If ADCin > 50 And ADCin < 100 Then Decr tcounter
If ADCin > 200 And ADCin < 300 Then Incr tcounter
If ADCin > 550 And ADCin < 750 Then Ok = 1
End Sub
'-------------------------------------------------------------------------------
'===============================================================================
' Verzögerungszeit * 255ms
'===============================================================================
Sub Sek()
WaitMs 255
WaitMs 255
WaitMs 255
WaitMs 255
End Sub
'-------------------------------------------------------------------------------
'===============================================================================
' raus - Ausstieg, wenn Abschaltschwelle erreicht ist
'===============================================================================
raus:
OCR1B = 0
For i = 1 To 100
dp = 0
'--------------
hunderter = 11 '"End" darstellen
zehner = 18
einer = 19
'--------------
Sek() '1Sek
dp = 2
Result = abschalt 'Abschaltspannung darstellen
separieren()
Sek() '1Sek
Next i
'-------------------------------------------------------------------------------
'===============================================================================
' Schlafen gehen..
'===============================================================================
schlafen:
OCR1B = 0
Disable Interrupts
PORTA=0
PORTB=0
PowerDown
End
'-------------------------------------------------------------------------------

LG,
Bruno

gfcwfzkm · 7. Februar 2014, 15:07

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...

diylab · 7. Februar 2014, 15:14

gfcwfzkm schrieb:

Also das Problem (Float) ist gefunden, aber ein Ersatz müsste her. hmm...

Was denn für Ersatz?
Ein 8-Bit ADC hat 1024 Werte.
Da brauchst Du doch keinen float um zentel-Volt anzuzeigen.
Hast Du Dir mein Programm nicht angesehen?

LG,
Bruno

gfcwfzkm · 7. Februar 2014, 15:25

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

diylab · 7. Februar 2014, 17:53

gfcwfzkm schrieb:

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

Richtig

. 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

[AVR]Memory Overflow - Programmcode verkleinern

[AVR]Memory Overflow - Programmcode verkleinern

C-Quellcode

Quellcode

Quellcode

gfcwfzkm schrieb:

C-Quellcode

gfcwfzkm schrieb:

gfcwfzkm schrieb:

VB.NET-Quellcode

gfcwfzkm schrieb:

gfcwfzkm schrieb:

Tags

Ähnliche Themen

4 Benutzer haben hier geschrieben