ATNEL tech-forum 2018-06-20T18:47:25+01:00 https://forum.atnel.pl/feed.php?f=4&t=20892&mode 2018-06-20T18:47:25+01:00 2018-06-20T18:47:25+01:00 https://forum.atnel.pl/viewtopic.php?t=20892&p=209129#p209129 <![CDATA[Re: generacja sygnału dshot]]> JarekB napisał(a):

Code:
00000098 <main>:
 98:    12 be           out    0x32, r1    ; 50
    ...                                                                      // tu wielki kompilator zrobił numer
  a6:    82 b7           in    r24, 0x32    ; 50                    // dołożył tyle pustych linijek ile jest nop-ów
  a8:    80 93 00 01     sts    0x0100, r24    ; 0x800100 <_edata>  // różnica między 98 a a6



A na czym konkretnie polega ten numer kompilatora? ;)
To nie są puste linijki. Pod tymi adresami pomiędzy 0x98 i 0xA6 są właśnie instrukcje NOP.

Można oczywiście ustawić wyższy poziom Debug Info, ale i tak zapewne nie wszystkie instrukcje będą widoczne w pliku *.lss.

Za to w Atmel Studio podczas symulacji w oknie Disassembly kod wygląda tak:
Code:
int main( void ) {
    TCNT0 = 0;
00000048  OUT 0x26,R1      Out to I/O location
    asm( "nop" );
00000049  NOP       No operation
    asm( "nop" );
0000004A  NOP       No operation
    asm( "nop" );
0000004B  NOP       No operation
    asm( "nop" );
0000004C  NOP       No operation
    asm( "nop" );
0000004D  NOP       No operation
    asm( "nop" );
0000004E  NOP       No operation
    czas = TCNT0;
0000004F  IN R24,0x26      In from I/O location
00000050  STS 0x0100,R24      Store direct to data space


Poza tym dostępne jest okienko o nazwie Processor Status, w którym jest całe mnóstwo przydatnych informacji, jak np. adres aktualnie wykonywanej instrukcji (PC counter), wskaźnik stosu, licznik cykli wykonanych podczas wykonywania instrukcji, Stop Watch przeliczający wykonane instrukcje na czas (na podstawie zadanej przez nas częstotliwości taktowania).

Trudno tu opisać wszystkie możliwości symulatora, ale bardzo łatwo w takich właśnie sytuacjach przetestować, co wygenerował kompilator. Oczywiście symulator nie jest w stanie zasymulować wszystkiego (np. pracy UARTa), czasami potrzebny jest debugger sprzętowy, ale i tak dużo funkcji naszego programu można przetestować.

Dlatego osobiście podpisałbym się pod radą kolegi micky:
micky napisał(a):

A może spróbuj symulatora software'go w Atmel Studio do policzenia czasu wykonywania twoich procedur?

Oczywiście wymaga to nie tylko zainstalowania Atmel Studio. Trzeba się jeszcze nauczyć obsłużyć taki symulator, ale myślę, że na potrzeby tak prostego programu dużo się uczyć nie trzeba...

Z drugiej strony trochę się obawiam, że mnie kolega Mirek zruga za promowanie ("kociego") Atmel Studio ;)

Statystyki: Napisane przez andrews — 20 cze 2018, o 18:47

]]> 2018-06-20T12:00:32+01:00 2018-06-20T12:00:32+01:00 https://forum.atnel.pl/viewtopic.php?t=20892&p=209118#p209118 <![CDATA[Re: generacja sygnału dshot]]> [syntax=c]#include <avr/io.h>
#include <util/delay.h>
uint8_t czas;
int main( void ) {
TCNT0 = 0;
asm( "nop" );
asm( "nop" );
asm( "nop" );
czas = TCNT0;
while ( 1 ) {
}
}[/syntax]

i teraz asembler
[syntax=c]00000098 <main>:
98: 12 be out 0x32, r1 ; 50
9a: 00 00 nop // instrukcje nop zajmują 1 takt zegara
9c: 00 00 nop
9e: 00 00 nop
a0: 82 b7 in r24, 0x32 ; 50
a2: 80 93 00 01 sts 0x0100, r24 ; 0x800100 <_edata>
a6: ff cf rjmp .-2 ; 0xa6 <main+0xe>[/syntax]

I teraz ciekawostka
[syntax=c]#include <avr/io.h>
#include <util/delay.h>

uint8_t czas;

int main( void ) {
TCNT0 = 0;
asm( "nop" );
asm( "nop" );
asm( "nop" );
asm( "nop" );
asm( "nop" );
asm( "nop" );
czas = TCNT0;
while ( 1 ) {
}
}[/syntax]
I asembler:
[syntax=c]00000098 <main>:
98: 12 be out 0x32, r1 ; 50
... // tu wielki kompilator zrobił numer
a6: 82 b7 in r24, 0x32 ; 50 // dołożył tyle pustych linijek ile jest nop-ów
a8: 80 93 00 01 sts 0x0100, r24 ; 0x800100 <_edata> // różnica między 98 a a6
ac: ff cf rjmp .-2 ; 0xac <main+0x14>[/syntax]

Statystyki: Napisane przez JarekB — 20 cze 2018, o 12:00

]]> 2018-06-20T11:31:06+01:00 2018-06-20T11:31:06+01:00 https://forum.atnel.pl/viewtopic.php?t=20892&p=209115#p209115 <![CDATA[Re: generacja sygnału dshot]]> aiwa napisał(a):

zaglądałem do asemblera i kompletnie nic nie zrozumiałem
Możesz włączyć dodawanie informacji z jakich linii kodu w C pochodzą te komendy asemblerowe :)

--
Pozdrawiam,
Robert

------------------------ [ Dodano po: kilkunastu sekundach ]

Masz na ten temat informacje tutaj topic3741.html

Statystyki: Napisane przez rskup — 20 cze 2018, o 11:31

]]> 2018-06-20T11:06:11+01:00 2018-06-20T11:06:11+01:00 https://forum.atnel.pl/viewtopic.php?t=20892&p=209113#p209113 <![CDATA[Re: generacja sygnału dshot]]> Statystyki: Napisane przez micky — 20 cze 2018, o 11:06

]]> 2018-06-20T09:39:03+01:00 2018-06-20T09:39:03+01:00 https://forum.atnel.pl/viewtopic.php?t=20892&p=209111#p209111 <![CDATA[Re: generacja sygnału dshot]]>
Faktycznie dobrym sposobem jest wykorzystanie timera, choć oczywiście nie do końca precyzyjnym.

Przemyślałem to i widzę następujące kwestie:

-sprawdziłem ile trwa przypisanie wartości z rejestru do zmiennej czas w poniższy sposób:
[syntax=c]TCNT0 = 0;
czas = TCNT0;[/syntax]
wyszło zero. Następnie dodałem kilka takich samych przypisań:
[syntax=c]TCNT0 = 0;
czas = TCNT0;
czas = TCNT0;
czas = TCNT0;[/syntax]
kazde przypisanie dodawało po 3 cykle zegara do wyniku. Skoro po jednym przypisaniu wyszło zero cykli, zakładam że nie będzie ono miało wpływu na wynik gdy już zmierzę "czas" wykonywania funkcji. :idea:

-praktycznie wszystkie instrukcje ładnie się dodają, "nopy" po jednym cyklu zegara, ustawienie wyjść dwa cykle itd.
Mimo to przy sterowaniu diodą WS2811 p. Mirek mówił, że w rzeczywistości sygnał jest bardziej zniekształcony, tj wydłużony.
Nawet jeśli tak się stanie z moim dshotem, to czy przy czasach od 625 do 1670 nanosekund będzie to miało znaczenie? Bo zawsze jest jakaś tolerancja, a tamta dioda WS2811 ma z kolei szybszą komunikację (np. 2,5 razy krótszy bit zera).

-zaglądałem do asemblera i kompletnie nic nie zrozumiałem :lol:
[syntax=c]000002c2 <main>:
2c2:89 9a sbi0x11, 1; 17
2c4:91 98 cbi0x12, 1; 18
2c6:85 ee ldir24, 0xE5; 229
2c8:93 e0 ldir25, 0x03; 3
2ca:91 9a sbi0x12, 1; 18
2cc:e3 ef ldir30, 0xF3; 243
2ce:f1 e0 ldir31, 0x01; 1
2d0:31 97 sbiwr30, 0x01; 1
2d2:f1 f7 brne.-4 ; 0x2d0 <main+0xe>
2d4:00 c0 rjmp.+0 ; 0x2d6 <main+0x14>
2d6:00 00 nop
2d8:91 98 cbi0x12, 1; 18
2da:ef e3 ldir30, 0x3F; 63
2dc:ff e1 ldir31, 0x1F; 31
2de:31 97 sbiwr30, 0x01; 1
2e0:f1 f7 brne.-4 ; 0x2de <main+0x1c>
2e2:00 c0 rjmp.+0 ; 0x2e4 <main+0x22>
2e4:00 00 nop
2e6:91 9a sbi0x12, 1; 18
2e8:e7 ee ldir30, 0xE7; 231
2ea:f3 e0 ldir31, 0x03; 3
2ec:31 97 sbiwr30, 0x01; 1
2ee:f1 f7 brne.-4 ; 0x2ec <main+0x2a>
2f0:00 c0 rjmp.+0 ; 0x2f2 <main+0x30>
2f2:00 00 nop
2f4:91 98 cbi0x12, 1; 18
2f6:ef e3 ldir30, 0x3F; 63
2f8:ff e1 ldir31, 0x1F; 31
2fa:31 97 sbiwr30, 0x01; 1
2fc:f1 f7 brne.-4 ; 0x2fa <main+0x38>
2fe:00 c0 rjmp.+0 ; 0x300 <main+0x3e>
300:00 00 nop
302:01 97 sbiwr24, 0x01; 1
304:00 97 sbiwr24, 0x00; 0
306:09 f7 brne.-62 ; 0x2ca <main+0x8>
308:91 9a sbi0x12, 1; 18
30a:87 ef ldir24, 0xF7; 247
30c:92 e0 ldir25, 0x02; 2
30e:01 97 sbiwr24, 0x01; 1
310:f1 f7 brne.-4 ; 0x30e <main+0x4c>
312:00 c0 rjmp.+0 ; 0x314 <main+0x52>
314:00 00 nop
316:91 98 cbi0x12, 1; 18
318:ef e3 ldir30, 0x3F; 63
31a:ff e1 ldir31, 0x1F; 31
31c:31 97 sbiwr30, 0x01; 1
31e:f1 f7 brne.-4 ; 0x31c <main+0x5a>
320:00 c0 rjmp.+0 ; 0x322 <main+0x60>
322:00 00 nop
324:f1 cf rjmp.-30 ; 0x308 <main+0x46>

00000326 <__vector_9>:
326:1f 92 pushr1
328:0f 92 pushr0
32a:0f b6 inr0, 0x3f; 63
32c:0f 92 pushr0
32e:11 24 eorr1, r1
330:10 92 64 00 sts0x0064, r1
334:0f 90 popr0
336:0f be out0x3f, r0; 63
338:0f 90 popr0
33a:1f 90 popr1
33c:18 95 reti[/syntax]

Jeśli jednak obliczenia przełożą się na praktykę, to chyba mam problem z głowy ;)

Statystyki: Napisane przez aiwa — 20 cze 2018, o 09:39

]]> 2018-06-19T13:36:13+01:00 2018-06-19T13:36:13+01:00 https://forum.atnel.pl/viewtopic.php?t=20892&p=209078#p209078 <![CDATA[Re: generacja sygnału dshot]]> Bym to widział tak:[syntax=c]#include <avr/io.h>
#include <util/delay.h>

uint8_t czas;

int main( void ) {
TCNT0 = 0;
// TWOJA FUNKCJA do zmierzenia
czas = TCNT0;

while ( 1 ) {
}[/syntax]
Każdy z czasów możesz w ten sposób zmierzyć
w pliku .lss masz komendy i możesz wyliczyć ile taktów co zajmuje:

[syntax=c]00000098 <main>:
98: 12 be out 0x32, r1 ; 50
9a: 82 b7 in r24, 0x32 ; 50
9c: 80 93 00 01 sts 0x0100, r24 ; 0x800100 <_edata>
a0: ff cf rjmp .-2 ; 0xa0 <main+0x8>[/syntax]

Czyli Twój czas to będzie ilość taktów zegara minus to co zajmuje ustawienie zegara i przepisanie wartości do zmiennej
z dokładnością to pojedynczych tyknięć zegara

Statystyki: Napisane przez JarekB — 19 cze 2018, o 13:36

]]> 2018-06-19T12:58:01+01:00 2018-06-19T12:58:01+01:00 https://forum.atnel.pl/viewtopic.php?t=20892&p=209074#p209074 <![CDATA[generacja sygnału dshot]]> mam pewien kłopot ze sprawdzeniem programu, który napisałem.
Próbuję stworzyć sygnał cyfrowy na podstawie protokołu DShot600 (do sterowników silników bezszczotkowych).
Posiłkowałem się programem do diod WS2811 (z bluebooka albo z bloga mk? nie pamiętam) i przerobiłem dwie funkcje do wysyłania bitów 0 i 1.
W załączeniu obrazek jak powinny wyglądać czasy trwania bitów.
[Na razie interesują mnie tylko dane, a nie CRC czy cała ramka.]
[syntax=c]static void motor_zero(){//1670ns
PORT(MOTOR_PORT) |= (1<<MOTOR_PIN);
asm("nop"); asm("nop"); asm("nop"); asm("nop");//625ns
asm("nop"); asm("nop"); asm("nop"); asm("nop");
PORT(MOTOR_PORT) &= ~(1<<MOTOR_PIN);
asm("nop"); asm("nop"); asm("nop"); asm("nop");//(=1670-625)ns
asm("nop"); asm("nop"); asm("nop"); asm("nop");
asm("nop"); asm("nop"); asm("nop"); asm("nop");
asm("nop");
}

static void motor_one(){//1670ns
PORT(MOTOR_PORT) |= (1<<MOTOR_PIN);
asm("nop"); asm("nop"); asm("nop"); asm("nop");//1250ns
asm("nop"); asm("nop"); asm("nop"); asm("nop");
asm("nop"); asm("nop"); asm("nop"); asm("nop");
asm("nop"); asm("nop"); asm("nop"); asm("nop");
asm("nop");
PORT(MOTOR_PORT) &= ~(1<<MOTOR_PIN);
asm("nop"); asm("nop"); asm("nop"); asm("nop");//(=1670-1250)ns
}[/syntax]

Pytanie tylko jak sprawdzić poprawność działania funkcji (czy czasy się zgadzają)?
Potrzebowałbym zapewne oscyloskopu minimum 25MHz :shock:
Jak widać program jest prosty ale bez narzędzi/pomysłu nigdy go nie zweryfikuję. :(


Obrazek
czas trwania bitów w protokole dshot600


@edit: stąd wziąłem wiedzę o protokole, stronka po angielsku:
https://blck.mn/2016/11/dshot-the-new-kid-on-the-block/

Statystyki: Napisane przez aiwa — 19 cze 2018, o 12:58

]]>