Assembler na C

[Ania30]

Witam
Jak ponizszy kod w Assemmbler przerobić na kod w j.C .
Jak wyglądał by ten kod w j.C ?
Pozdrawiam
Ania

kod:

.nolist
.include "tn2313adef.inc"
;.include "m32def.inc"
.list
.cseg
.equ fosc = 8 ;czestotliwosc kwarcu w MHz
.org 0x0000
rjmp ResetProcessor

ResetProcessor:
; ldi r16, high(RAMEND) ; init stack pointer
; out SPH, r16
ldi r16, low (RAMEND) ; init stack pointer
out SPL, r16

ldi r16, 0xff
out ddrd, r16
out portd, r16

ldi r18, 0xff
ldi r19, 0xff
ldi r20, 0xa1
ldi r21, 0x07

main:
ldi r16, 0b1010_1010
out portd, r16
nop
nop
rcall del_64s
ldi r16, 0b0101_0101
out portd, r16
rcall del_64s
rjmp main

del_64s:
MOVW R24, R20
Coarse:
MOVW R30, R18 ;
Loop:
SBIW R30, 0x01 ;
BRNE Loop ;
SBIW R24, 0x01 ;
BRNE Coarse ;

ldi r28, 0xfd
ldi r29, 0x1f
Fine:
SBIW R28, 0x01 ;
BRNE Fine

ret
.exit

[Ania30]

r-mik, zaproponował taki kod jaki podaję poniżej,ale on się nie kompiluje wywala error na nop
kod:
main()
{
DDRB = 0xFF;
while(1)
{
nop();
nop();
PORTB = 0xF0;
_delay_ms(64000);
PORTB = 0x0F;
_delay_ms(64000); **
}
}

[Ania30]

Udało mi się wstawić 2 x nop do j.C ,kod się skompilował i działa,jest 64 /64 sek,z kwarcem 8 MHz.
Teraz przydało by mi się, aby na priwa fachowiec stwierdził czy te 2x nop działa w moim kodzie.

[r-mik]

Teraz przydało by mi się, aby na priwa fachowiec stwierdził czy te 2x nop działa w moim kodzie.

Skoro piszesz

Udało mi się wstawić 2 x nop do j.C ,kod się skompilował i działa,jest 64 /64 sek,z kwarcem 8 MHz.

to chyba oznacza, że działa.

Pokaż rozwinięcie asm to da się stwierdzić czy są nop-y.

[Ania30]

Czytałam,że w kodzie C odpowiednikiem nop jest ,if(warunek);
else instrukcja;
Tylko jak go wstawić do mojego kodu zamiast nop, i co napisać aby działał.
Dałam ,us(520000000);,przy kwarcu 8MHz daje to około 64 sek.
Zrobiłam go też w ASM,ale listig jest baaardzo dłuuugi,a potem jak mówił ACeK trzeba ręcznie poprawiać,co ja nie potrafię.
Czy w tym kodzie dać ,unsigned int licznik1; ,i gdzie ?.


https://pl.wikipedia.org/wiki/Instrukcja_pusta

kod:

#include <avr/io.h>
#include <util/delay.h>
int main (void)
{

DDRB = (1<<PB1)|(1<<PB2);
PORTB|=(1<<PB1);
while(1)
{
asm("nop");
asm("nop");

PORTB ^= (1<<PB1)|(1<<PB2);
_delay_us(520000000);

}
}

[r-mik]

Czytałam,że w kodzie C odpowiednikiem nop jest ,if(warunek);
else instrukcja;

Chyba tylko na YT takie głupoty można wyczytać.

Tylko jak go wstawić do mojego kodu zamiast nop, i co napisać aby działał.
Dałam ,us(520000000);,przy kwarcu 8MHz daje to około 64 sek.

_delay_us i _delay_ms nie sa zbyt dokładne, dokładne będą timery.

Zrobiłam go też w ASM,ale listig jest baaardzo dłuuugi,a potem jak mówił ACeK trzeba ręcznie poprawiać,co ja nie potrafię.
Czy w tym kodzie dać ,unsigned int licznik1; ,i gdzie ?.

najprostszy program

#include <avr/io.h>
#include <util/delay.h>
int main (void)
{

DDRB = (1<<PB1)|(1<<PB2);
PORTB|=(1<<PB1);
while(1)
{
PORTB ^= (1<<PB1)|(1<<PB2);
_delay_us(520000000);
}
}

nie potrzebuje nop, bo stan portu jest negowany. Nop-y byłby potrzebne, gdyby porty były ustawiane po czym po delay zerowane.

[Ania30]

Czy w tym kodzie można dać us zamiast ms,jak to zrobić.
Co przydało by się w tym kodzie poprawic ?.
Czy unsigned int licznik1; ,jest w dobrym miejscu i czy jest tam potrzebny,bez niego też działa,ale czy on coś usprawnia,porawia.

kod:

#include <avr/io.h>
#include <util/delay.h>

uint32_t licznik;


int main (void)
{

unsigned int licznik1;

DDRB = (1<<PB1)|(1<<PB2);
PORTB|=(1<<PB1);
for(;;){

licznik++;
if(!(licznik%64000))PORTB ^= (1<<PB1);
if(!(licznik%64000))PORTB ^= (1<<PB2);
if(licznik==64000)licznik=0;//maksymalnie 64000ms

}
}

[r-mik]

Tu się nie da nic poprawić, to się nadaje tylko do
CTRL+A
CTRL+X

if(!(licznik%64000))PORTB ^= (1<<PB1);
if(!(licznik%64000))PORTB ^= (1<<PB2);
spowoduje, że pomiędzy zmianą PB1 i PB2 będzie przesunięcie

licznik wystarczy aby był typem 16 bit bez znaku. AVR to nie ARM, gdzie typ 32bit często działa szybciej niż 16bit, w AVR działa wolniej. Tu nie ma to specjalnie dużego znaczenia ale dobrych nawyków trzeba się uczyć od początku przygody z uC.

[Ania30]

Teraz lepiej ?
kod:

#include <avr/io.h>
#include <util/delay.h>

uint16_t licznik;

int main(void)
{
unsigned int licznik1;

/* Wszystkie linie portu B będą wyjściami */
DDRB = 0xFF;

/* Początek nieskończonej pętli */
for(;;){
_delay_ms(1);
licznik++;
if(licznik%64000==0)PORTB ^= 0x01; //PinB0 zmienia swój stan co 64000ms
if(licznik%64000==0)PORTB ^= 0x02; //PinB1 zmienia swój stan co 64000ms
//itd...
if(licznik==64000)licznik=0;//maksymalnie 64000ms

}
}

[r-mik]

A co sie zmieniło? Po skompilowaniu czy 0x01, czy 1 czy _BV(PB1),czy (1<<B1) da #1.

[Ania30]

To jak ma byc aby było dobrze ?

[r-mik]

Najlepiej użyć timera i generować przebieg komplementarny. Jeśli taki "partyzancki" kod, to oba porty muzą być zmieniane(zapisywane) jednym rozkazem. To narzuca aby oba wyprowadzenia były na tym samym porcie. Aby byc pewnym, że jest ok, trzeba obejrzeć rozwinięcie asselerowe.

[Ania30]

Odpowiedzi ,pomoc,w tym forum i poprzednich, niedostateczna,zbyt ogólnikowa i niepomocna dla nowicjusza, te informacje rady są dla znawców,a znawca ich niepotrzebuje bo widzi,że wprowadzają na manowce.

[r-mik]

Odpowiedzi ,pomoc,w tym forum i poprzednich, niedostateczna,zbyt ogólnikowa i niepomocna dla nowicjusza, te informacje rady są dla znawców,a znawca ich niepotrzebuje bo widzi,że wprowadzają na manowce.

1. Skoro na wszystkich forach nie potrafią pomóc, gdzie leży problem? W forach czy w użytkowniku?
2. Nauka kosztuje. Aby się uczyć trzeba płacić. Zapraszam na korepetycje, jedyne 100zł za godzinę (lekcyjną oczywiście)
3. Można nauczyć się samemu, trzeba tylko chcieć i poczytać podstawy, który widać, że wyraźnie brakuje.
4. Można zlecić wykonanie projektu. Orientacyjny koszt: http://kuna.pl/2018/08/09/wycena-projektu/ To jest prosty projekt, więc można przyjąć 1500zł za program, plus (jeśli trzeba) 1500zł za sprzęt.


PS
Warto by poprawić błędy i trzymać się zasad pisania dokumentów (po znaku interpunkcyjnym spacja itp).

[Ania30]

#define F_CPU 8000000UL
#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
/* Wszystkie linie portu B będą wyjściami */
DDRB = 0xFF; /* 0xFF binarnie 1111 1111 */

/* Początek nieskończonej pętli */
while(1)
{
asm("nop");
asm("nop");

PORTB = 0xaa; /* 0xaa binarnie 1010 1010 */
/* opóźnienie 64 sek. */
_delay_us(520000000);
PORTB = 0x55; /* 0x55 binarnie 0101 0101 */
/* opóźnienie 64 sek. */
_delay_us(520000000);
}
}

[r-mik]

Wygląda ok. Aby sie upewnić czy liczba nop jest odpowiednia trzeba zobaczyć rozwinięcie asm.

[Ania30]

To jest ostatni kod w j.C sprowadzony do asm,ucięty znacznie ,bo cały nie wszedł tutaj.
Nop pokazuje się 4 razy.
Czy to jest rozwinięcie asm ?

+00000000: C012 RJMP PC+0x0013 Relative jump
+00000001: C019 RJMP PC+0x001A Relative jump
+00000002: C018 RJMP PC+0x0019 Relative jump
+00000003: C017 RJMP PC+0x0018 Relative jump
+00000004: C016 RJMP PC+0x0017 Relative jump
+00000005: C015 RJMP PC+0x0016 Relative jump
+00000006: C014 RJMP PC+0x0015 Relative jump
+00000007: C013 RJMP PC+0x0014 Relative jump
+00000008: C012 RJMP PC+0x0013 Relative jump
+00000009: C011 RJMP PC+0x0012 Relative jump
+0000000A: C010 RJMP PC+0x0011 Relative jump
+0000000B: C00F RJMP PC+0x0010 Relative jump
+0000000C: C00E RJMP PC+0x000F Relative jump
+0000000D: C00D RJMP PC+0x000E Relative jump
+0000000E: C00C RJMP PC+0x000D Relative jump
+0000000F: C00B RJMP PC+0x000C Relative jump
+00000010: C00A RJMP PC+0x000B Relative jump
+00000011: C009 RJMP PC+0x000A Relative jump
+00000012: C008 RJMP PC+0x0009 Relative jump
+00000013: 2411 CLR R1 Clear Register
+00000014: BE1F OUT 0x3F,R1 Out to I/O location
+00000015: E5CF LDI R28,0x5F Load immediate
+00000016: E0D4 LDI R29,0x04 Load immediate
+00000017: BFDE OUT 0x3E,R29 Out to I/O location
+00000018: BFCD OUT 0x3D,R28 Out to I/O location
+00000019: D002 RCALL PC+0x0003 Relative call subroutine
+0000001A: C022 RJMP PC+0x0023 Relative jump
+0000001B: CFE4 RJMP PC-0x001B Relative jump
+0000001C: EF8F SER R24 Set Register
+0000001D: BB87 OUT 0x17,R24 Out to I/O location
+0000001E: EA9A LDI R25,0xAA Load immediate
+0000001F: E585 LDI R24,0x55 Load immediate
+00000020: 0000 NOP No operation
+00000021: 0000 NOP No operation
+00000022: BB98 OUT 0x18,R25 Out to I/O location
+00000023: E524 LDI R18,0x54 Load immediate
+00000024: E63D LDI R19,0x6D Load immediate
+00000025: E543 LDI R20,0x53 Load immediate
+00000026: E259 LDI R21,0x29 Load immediate
+00000027: 5021 SUBI R18,0x01 Subtract immediate
+00000028: 4030 SBCI R19,0x00 Subtract immediate with carry
+00000029: 4040 SBCI R20,0x00 Subtract immediate with carry
+0000002A: 4050 SBCI R21,0x00 Subtract immediate with carry
+0000002B: F7D9 BRNE PC-0x04 Branch if not equal
+0000002C: C000 RJMP PC+0x0001 Relative jump
+0000002D: C000 RJMP PC+0x0001 Relative jump
+0000002E: 0000 NOP No operation
+0000002F: BB88 OUT 0x18,R24 Out to I/O location
+00000030: E524 LDI R18,0x54 Load immediate
+00000031: E63D LDI R19,0x6D Load immediate
+00000032: E543 LDI R20,0x53 Load immediate
+00000033: E259 LDI R21,0x29 Load immediate
+00000034: 5021 SUBI R18,0x01 Subtract immediate
+00000035: 4030 SBCI R19,0x00 Subtract immediate with carry
+00000036: 4040 SBCI R20,0x00 Subtract immediate with carry
+00000037: 4050 SBCI R21,0x00 Subtract immediate with carry
+00000038: F7D9 BRNE PC-0x04 Branch if not equal
+00000039: C000 RJMP PC+0x0001 Relative jump
+0000003A: C000 RJMP PC+0x0001 Relative jump
+0000003B: 0000 NOP No operation
+0000003C: CFE3 RJMP PC-0x001C Relative jump
+0000003D: 94F8 CLI Global Interrupt Disable
+0000003E: CFFF RJMP PC-0x0000 Relative jump
+0000003F: FFFF ??? Data or unknown opcode
+00000040: FFFF ??? Data or unknown opcode

[r-mik]

C to nie asm, nie definiuj zegara w kodzie źródłowym tylko w projekcie.
Rozwinięcie asm wygląda tak:
Disassembly of section .text:
00000000 <__vectors>:
0: 12 c0 rjmp .+36 ; 0x26 <__ctors_end>
2: 17 c0 rjmp .+46 ; 0x32 <__bad_interrupt>
4: 16 c0 rjmp .+44 ; 0x32 <__bad_interrupt>
6: 15 c0 rjmp .+42 ; 0x32 <__bad_interrupt>
8: 14 c0 rjmp .+40 ; 0x32 <__bad_interrupt>
a: 13 c0 rjmp .+38 ; 0x32 <__bad_interrupt>
c: 12 c0 rjmp .+36 ; 0x32 <__bad_interrupt>
e: 11 c0 rjmp .+34 ; 0x32 <__bad_interrupt>
10: 10 c0 rjmp .+32 ; 0x32 <__bad_interrupt>
12: 0f c0 rjmp .+30 ; 0x32 <__bad_interrupt>
14: 0e c0 rjmp .+28 ; 0x32 <__bad_interrupt>
16: 0d c0 rjmp .+26 ; 0x32 <__bad_interrupt>
18: 0c c0 rjmp .+24 ; 0x32 <__bad_interrupt>
1a: 0b c0 rjmp .+22 ; 0x32 <__bad_interrupt>
1c: 0a c0 rjmp .+20 ; 0x32 <__bad_interrupt>
1e: 09 c0 rjmp .+18 ; 0x32 <__bad_interrupt>
20: 08 c0 rjmp .+16 ; 0x32 <__bad_interrupt>
22: 07 c0 rjmp .+14 ; 0x32 <__bad_interrupt>
24: 06 c0 rjmp .+12 ; 0x32 <__bad_interrupt>

00000026 <__ctors_end>:
26: 11 24 eor r1, r1
28: 1f be out 0x3f, r1 ; 63
2a: cf ed ldi r28, 0xDF ; 223
2c: cd bf out 0x3d, r28 ; 61
2e: 02 d0 rcall .+4 ; 0x34 <main>
30: 1a c0 rjmp .+52 ; 0x66 <_exit>

00000032 <__bad_interrupt>:
32: e6 cf rjmp .-52 ; 0x0 <__vectors>

00000034 <main>:
#include <util/delay.h>

int main(void)
{
/* Wszystkie linie portu B będą wyjściami */
DDRB = 0xFF; /* 0xFF binarnie 1111 1111 */
34: 8f ef ldi r24, 0xFF ; 255
36: 87 bb out 0x17, r24 ; 23
while(1)
{
asm("nop");
asm("nop");

PORTB = 0xaa; /* 0xaa binarnie 1010 1010 */
38: 5a ea ldi r21, 0xAA ; 170
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
__asm__ volatile (
3a: 28 ec ldi r18, 0xC8 ; 200
3c: 30 e0 ldi r19, 0x00 ; 0
/* opóźnienie 64 sek. */
_delay_us(520000000);
PORTB = 0x55; /* 0x55 binarnie 0101 0101 */
3e: 45 e5 ldi r20, 0x55 ; 85
DDRB = 0xFF; /* 0xFF binarnie 1111 1111 */

/* Początek nieskończonej pętli */
while(1)
{
asm("nop");
40: 00 00 nop
asm("nop");
42: 00 00 nop

PORTB = 0xaa; /* 0xaa binarnie 1010 1010 */
44: 58 bb out 0x18, r21 ; 24
46: 8f ef ldi r24, 0xFF ; 255
48: 9f ef ldi r25, 0xFF ; 255
4a: f9 01 movw r30, r18
4c: 31 97 sbiw r30, 0x01 ; 1
4e: f1 f7 brne .-4 ; 0x4c <__SREG__+0xd>
__ticks = (uint16_t) (__ms * 10.0);
while(__ticks)
{
// wait 1/10 ms
_delay_loop_2(((F_CPU) / 4e3) / 10);
__ticks --;
50: 01 97 sbiw r24, 0x01 ; 1
__ticks = 1;
else if (__tmp > 65535)
{
// __ticks = requested delay in 1/10 ms
__ticks = (uint16_t) (__ms * 10.0);
while(__ticks)
52: d9 f7 brne .-10 ; 0x4a <__SREG__+0xb>
/* opóźnienie 64 sek. */
_delay_us(520000000);
PORTB = 0x55; /* 0x55 binarnie 0101 0101 */
54: 48 bb out 0x18, r20 ; 24
56: 8f ef ldi r24, 0xFF ; 255
58: 9f ef ldi r25, 0xFF ; 255
5a: f9 01 movw r30, r18
5c: 31 97 sbiw r30, 0x01 ; 1
5e: f1 f7 brne .-4 ; 0x5c <__SREG__+0x1d>
{
// wait 1/10 ms
_delay_loop_2(((F_CPU) / 4e3) / 10);
__ticks --;
60: 01 97 sbiw r24, 0x01 ; 1
__ticks = 1;
else if (__tmp > 65535)
{
// __ticks = requested delay in 1/10 ms
__ticks = (uint16_t) (__ms * 10.0);
while(__ticks)
62: d9 f7 brne .-10 ; 0x5a <__SREG__+0x1b>
64: ed cf rjmp .-38 ; 0x40 <__SREG__+0x1>

00000066 <_exit>:
66: f8 94 cli

00000068 <__stop_program>:
68: ff cf rjmp .-2 ; 0x68 <__stop_program>
Znajduje sie w pliku "*.lss".

[Ania30]

Czy mój ostatni kod w j.C, przerobiony na ASM, bedzie miał dokładniejsze duty 50%,jak w j.C ?
Czy w tym moim ostatnim kodzie,działają nop jak należy ?.
Kod który podałeś w poprzednim poście, nie kompiluje się, po usunięciu nop();, i gwiazdek na dole , kompiluje się, ale nie ma napięcia na jednej połowie, jest znikome, 6.5 mili volt,na jednej jest napiecie powyżej 4 Volt,jak zrobic aby napięcie było tak jak ta jedej połowie,tj powyżej 4 Volt. ?
Oto ten kod:
main()
{
DDRB = 0xFF;
while(1)
{
nop();
nop();
PORTB = 0xF0;
_delay_ms(64000);
PORTB = 0x0F;
_delay_ms(64000); **
}
}

[r-mik]

Czy mój ostatni kod w j.C, przerobiony na ASM, bedzie miał dokładniejsze duty 50%,jak w j.C ?

I w tym wątku i w kilku wcześniejszych dotyczących tego tematu, pisałem już, że najprościej negować stan GPIO. Wtedy nie ma znaczenia czas obiegu pętli, zawsze będzie 50% +/- jitter oscylatora.

Jeśli chcesz się bawić w "do cyklowanie" to albo masz dużo czasu, albo dużą wiedzę. Taki "docyklowany" kod, dobrze zadział na konkretnym uC i konkretnym kompilatorze. Zmiana uC czy kompilatora może wymagać kolejnej zabawy w "docyklowanie". To było dobre, 30 lat temu, gdy byłZX Spectrum, Atari 800 czy C-64. CPU, i inne peryferia były niezmienne. Teraz jest inaczej.
Widzisz, że delay_us czy _delay_ms są niedokładne. Chcesz dokładnie, zrób jak pisałem wcześniej i to KILKA RAZY - użyj timerów.