Mam takie pytanko:
Jak wymusić na C określony sposób przekazywania parametrów do asm, kiedyś trochę hakowałem małe programy w C na intelu to raczej zawsze szło przez stos z C (C raczej znałem tylko po łebkach wtedy).
Tutaj widzę (zaglądałem do .dump w asm) że wszystko jest pchane przez rejestry, głównie r24 i r25, a ja bym chciał tak prościutko wołać w C np. RS232_wyslij(12); zamiast ładować r24 i wołać - tak, oczywiście, to w asm czytam r24, ale czy zawsze to będzie r24? - o to chodzi, można chyba przekazać adres zmiennej z C do ASM, no ale - ale co z tym stosem? - to mnie ciekawi.
Ogólnie ten r24 mi nie przeszkadza, ale chciałbym by to (kompilacja) działało na więcej niż jednym kompie (i kompilatorze).
Ale może od początku (tak sobie to kompiluję (linux, avrdude,avr-gcc,avr-libc)
UWAGA! - wersje "mocno robocze", takie "tysiąc razy" poprawiane/testowane :
[syntax=bash]#!/bin/bash
#
PRG='ladowarka-ctc2'
rm $PRG.o 2>/dev/null
rm $PRG.hex 2>/dev/null
rm $PRG.bin 2>/dev/null
rm $PRG.elf 2>/dev/null
echo '-------*** KOMPILOWANIE ***-------'
echo '---ASM-----'
avr-gcc -g -c -Os -mmcu=attiny13 -DF_CPU=1200000UL $PRG.S -o $PRG-s.o -Wa,--gstabs
echo '----C-----'
avr-gcc -g -c -Os -Wall -mmcu=attiny13 -DF_CPU=1200000UL $PRG.c -o $PRG-c.o
echo '---LINK---'
avr-gcc -mmcu=attiny13 -Wl,-Map=tst13,--cref -o $PRG.elf $PRG-c.o $PRG-s.o
STAT=$?
if [ "$STAT" == "0" ];then
avr-objdump -C -d ./$PRG.elf >$PRG.dump
avr-objcopy -S -O ihex $PRG.elf $PRG.hex
avr-objcopy -S -O binary $PRG.elf $PRG.bin
#wgranie do scalaka
avrdude -p t13 -c usbasp-clone -B20 -U flash:w:${PRG}.hex
fi
echo '-------**** KONIEC ****-------'[/syntax]
no i mam sobie w asm takie wysyłanie przez RS232 (sciągniete z noty ATMELA i prrzerobione na AVR-GCC) "ladowarka-ctc2.S" (duże ".S" !):
[syntax=asm]#define __SFR_OFFSET 0
#include <avr/io.h>
#define BV(bit) (1 << (bit))
;Global register variables, UWAGA dla DEFINE (preprocesowa) stosowac komentarze (za) wg. składni C
#definebitcntr16// bit counter
#definetempr17// temporary storage register
#defineTxbyter18// Data to be transmitted
#defineRxbyter19// Received data
.equ RxD,3;Receive pin is PD0
.equ TxD,4;Transmit pin is PD1
.equb,17;9600 bps @ 1.2 MHz crystal
.equsb,1;Number of stop bits (1, 2, .. )
.global RS_putchar
.global RS_getchar
.global RS_forever
.global RS_reset
.section .text
;.org 0x0
;rjmpreset
;***************************************************************************
;*
;* "putchar"
;*
;* This subroutine transmits the byte stored in the "Txbyte" register
;* The number of stop bits used is set with the sb constant
;*
;* Number of words:14 including return
;* Number of cycles:Depens on bit rate
;* Low registers used:None
;* High registers used:2 (bitcnt,Txbyte)
;* Pointers used:None
;*
;***************************************************************************
.func RS_putchar
RS_putchar:
ldibitcnt,9+sb;9+sb
comTxbyte;Inverte everything
sec;Start bit
putchar0:
brccputchar1;If carry set
cbiPORTB,TxD; send a '0';cbi_SFR_IO_ADDR(PORTB),TxD; send a '0'
rjmpputchar2;else
putchar1:
sbiPORTB,TxD; send a '1'
nop
putchar2:
rcallUART_delay;One bit delay
rcallUART_delay
lsrTxbyte;Get next bit
decbitcnt;If not all bit sent
brneputchar0; send next
;else
ret; return
.endfunc
;***************************************************************************
;*
;* "getchar"
;*
;* This subroutine receives one byte and returns it in the "Rxbyte" register
;*
;* Number of words:14 including return
;* Number of cycles:Depens on when data arrives
;* Low registers used:None
;* High registers used:2 (bitcnt,Rxbyte)
;* Pointers used:None
;*
;***************************************************************************
.func RS_getchar
RS_getchar:
ldi bitcnt,9;8 data bit + 1 stop bit
getchar1:
sbic PINB,RxD;Wait for start bit
rjmp getchar1
rcallUART_delay;0.5 bit delay
getchar2:
rcallUART_delay;1 bit delay
rcallUART_delay
clc;clear carry
sbic PINB,RxD;if RX pin high
sec;
dec bitcnt;If bit is stop bit
breq getchar3; return
;else
ror Rxbyte; shift bit into Rxbyte
rjmp getchar2; go get next
getchar3:
ret
.endfunc
;***************************************************************************
;*
;* "UART_delay"
;*
;* This delay subroutine generates the required delay between the bits when
;* transmitting and receiving bytes. The total execution time is set by the
;* constant "bps":
;*
;*3xb + 7 cycles (including rcall and ret)
;*
;* Number of words:4 including return
;* Low registers used:None
;* High registers used:1 (temp)
;* Pointers used:None
;*
;***************************************************************************
; Some b values: (See also table in Appnote documentation)
;
; 1 MHz crystal:
; 9600 bps - b=14
; 19200 bps - b=5
; 28800 bps - b=2
;
; 2 MHz crystal:
; 19200 bps - b=14
; 28800 bps - b=8
; 57600 bps - b=2
; 4 MHz crystal:
; 19200 bps - b=31
; 28800 bps - b=19
; 57600 bps - b=8
; 115200 bps - b=2
; ---------------------moje------------------
; b = ((f/baudrate)-23)/6 -> ((1000000/9600)-23)/6 == 13.53, dla 1.2Mhz i 9600 == równiutko 17.000
UART_delay:
lditemp,b
UART_delay1:
dectemp
brneUART_delay1
ret
;***** Program Execution Starts Here
;***** Test program (uwaga, nie wysylac ciagu - zwroci co 2gi znak bo to half-duplex)
.func RS_reset
RS_reset:
sbiPORTB,TxD;Init port pins
sbiDDRB,TxD
ldiTxbyte,12;Clear terminal
rcallRS_putchar
.endfunc
.func RS_forever
RS_forever:
rcallRS_getchar
movTxbyte,Rxbyte
rcallRS_putchar;Echo received char
rjmpRS_forever
.endfunc[/syntax]
Przepraszam - wersja robocza ze śmieciami, działa na Attiny13A (przynajmnie jeszcze niedawno hehe) - transmisja 9600n bodów, 8N1.
Tutaj mam kawałek funkcji w C:
[syntax=c]void nadawaj(void) {
RS_putchar(1);
RS_putchar(2);
RS_putchar(3);
RS_putchar(1);//version
RS_putchar(licznikEE);
RS_putchar(myflags);
RS_putchar(deltaV);
RS_putchar(pomiar);
RS_putchar(charge_start);
RS_putchar(charge_start>>8);
RS_putchar(charge_end);
RS_putchar(charge_end>>8);
....
ret[/syntax]
No a teraz dump (asm):\
[syntax=asm]00000094 <nadawaj>:
94:81 e0 ldir24, 0x01; 1
96:85 d0 rcall.+266 ; 0x1a2 <RS_putchar>
98:82 e0 ldir24, 0x02; 2
9a:83 d0 rcall.+262 ; 0x1a2 <RS_putchar>
9c:83 e0 ldir24, 0x03; 3
9e:81 d0 rcall.+258 ; 0x1a2 <RS_putchar>
a0:81 e0 ldir24, 0x01; 1
a2:7f d0 rcall.+254 ; 0x1a2 <RS_putchar>
a4:80 91 62 00 ldsr24, 0x0062
a8:7c d0 rcall.+248 ; 0x1a2 <RS_putchar>
aa:80 91 6e 00 ldsr24, 0x006E
ae:79 d0 rcall.+242 ; 0x1a2 <RS_putchar>
b0:80 91 60 00 ldsr24, 0x0060
b4:76 d0 rcall.+236 ; 0x1a2 <RS_putchar>[/syntax]
(EDIT 18.02.2016) Taka jeszcze uwaga do powyższego (akurat nie złapałem zapisu ze zmiennych 16 bit, te widoczne są uint8_t).
[syntax=c]extern RS_putchar(uint8_t);
#define lo8(x) ( *((uint8_t*)&x) )
#define hi8(x) ( *((uint8_t*)&x+1) )
//i
RS_putchar( lo8(zmienna16t) );
RS_putchar( hi8(zmienna16t) );[/syntax]
Daje to mniejszy kod wynikowy w ASM względem RS_putchar( zmienna16t ) - to ładuje r24 i r25; RS_putchar( zmienna16t>>8 ) - to ładuje r24 i r25 + przepisuje r25 do r24; RS_putchar( lo8(zmienna16t) ) daje tylko ładowanie r24 (lds r24, 0xadres-zmienna16t-pierwszy-bajt).
Choc nie wiem czy dałoby się to zapisać ładniej (w C programuję mało i okazjonalnie = słabo pamiętam).
(END)
Mam jeszcze w C takie coś:
[syntax=c]register unsigned char r18 asm("r18");//nadawany z RS232
register unsigned char r19 asm("r19");//odebrany z RS232
register unsigned char r24 asm("r24");//testujemy C[/syntax]
Jeżeli "zarejestrowałem" w C rejest r24 to podczas kompilacji dostaję ostrzeżenia o wykorzystywaniu R24 przez C - całkiem nieźle - ale dla wiedzącego o co kaman.
A jak wymusić przekazanie przez stos?
.. przez zdefiniowanie czegoś w C inline asm? (przyznam nawet nie próbowałem tego tykać).
Czy może jest inny sposób? - zasada np. taka, zrzuca mi na stos, ja zrzucam na stos jeszcze robocze, przestawiam wskaźnik SP -(+) X bajtów parametrów, odczytuje do roboczych parametry ze stosu, robię, pobieram ze stosu wart. roboczych i wracam z procedury.
Tylko stos trochę mały
64 RAM uff.Przepraszam za chaotyczność wypowiedzi. Ciut późno skończyłem.
Statystyki: Napisane przez kenubi — 16 lut 2016, o 01:53
]]>