[SDCC] Kompilator języka C dla mikrokontrolerów C51

Kącik dla elektroniki retro - układy, urządzenia, podzespoły, literatura itp.
Awatar użytkownika
gaweł
Geek
Geek
Posty: 1321
Rejestracja: wtorek 24 sty 2017, 22:05
Lokalizacja: Białystok

[SDCC] Kompilator języka C dla mikrokontrolerów C51

Postautor: gaweł » piątek 26 sty 2018, 00:44

O niekomercyjnym pakiecie SDCC, kompilatora C dla mikrokontrolerów, pisałem już w temacie [SDCC] Kompilator języka C dla Z80 (skąd pobrać, jak zainstalować, jak użyć dla mikroprocesorów Z80). Ponieważ w mojej szufladzie wala się kilkaset mikrokontrolerów z rodziny C51, pomyślałem sobie, że warto by zawalczyć i opanować używanie w/w narzędzia do tworzenia programów dla tych procków. W końcu jakoś je trzeba zużyć, bo przecież zupy z nich nie będę gotować.
W odróżnieniu od procesora Z80, tu sprawa użycia staje się trochę bardziej złożona. Wynika to z większej różnorodności wariantów rozwiązań sprzętowych (o ile w kwestii peryferali nie ma to istotnego znaczenia, o tyle w kwestii rozwiązań wewnętrznej pamięci RAM ma istotny wpływ na generowany kod). Tu warto pamiętać, że podstawowy, standardowy model mikrokontrolera (o oznaczeniu 8031/8051) ma 128 bajtów wewnętrznej pamięci RAM. Pierwsza wersja rozwojowa tego mikrokontrolera, o oznaczeniu 8052 ma 256 bajtów pamięci wewnętrznej, co stanowi bardzo istotną różnicę. W obrębie samego miktokontrolera 8051 istnieje możliwość dołączenia zewnętrznej pamięci RAM nawet do wielkości 64kB (plus rzecz jasna wewnętrzna pamięć RAM).
Ta różnorodność musi w jakiś sposób mieć swoje odbicie w „zaklęciach” dla kompilatora, by wygenerował kod spełniający „zachcianki” programisty. W tym celu kompilator posługuje się pojęciem modelu pamięci. Dla procków z rodziny C51 oferowane są następujące modele pamięci (w dokumentacji znajduje się informacja, że w przypadku, gdy program jest zawarty w kilku plikach, każdy z nich musi być kompilowany ze wskazaniem na jednakowy model pamięci):
  • --model-small – generuje kod programu lokując zmienne w wewnętrznej pamięci RAM, ten model pamięci jest domyślnym,
  • --model-medium – generuje kod dla „średnich” modeli pamięci i oznacza użycie zewnętrznej pamięci RAM,
  • --model-large – generuje kod dla „dużych” modeli pamięci i oznacza użycie zewnętrznej pamięci RAM,
  • --model-huge – generuje kod dla „ogromnych” modeli pamięci (nie będę się tym na razie zajmować).
Wymienione modele pamięci oznaczają jedynie miejsce lokacji zmiennych programu oraz mają implikacje w zastosowanych instrukcjach maszynowych pozwalających sięgać do tych zmiennych.
Ze względu na różne rozmiary pamięci RAM i różne przestrzenie adresowe, by „zmusić” kompilator do zamierzonego potraktowania zmiennych, należy użyć odpowiedniego zaklęcia przy deklaracji zmiennej. Kompilator SDCC oferuje następujące zaklęcia:
  • __data – zmienna należy do obszaru wewnętrznej pamięci RAM o wielkości 128 bajtów,
  • __idata – zmienna należy do obszaru wewnętrznej pamięci RAM o wielkości 256 bajtów,
  • __pdata – zmienna należy do obszaru zewnętrznej pamięci RAM o wielkości 256 bajtów o początkowym adresie 0 (adresy z przedziału 0..255),
  • __xdata – zmienna należy do obszaru zewnętrznej pamięci RAM o dowolnej lokacji,
  • __code – zmienna położona jest w przestrzeni kodu programu (trudno tu użyć określenia „zmienna”, dotyczy to stałych obszarów zmiennych).
No to nadszedł czas na pierwsze starcie. Królik doświadczalny to następujący program:

Kod: Zaznacz cały

unsigned char GloblVar ;

main ( )
{
  unsigned char j ;
  /*---------------------------------------------------*/
  while ( 1 )
  {
    GloblVar = 1 ;
    for ( j = 0 ; j < 4 ; j++ )
    {
      GloblVar = GloblVar << 1 ;
    } /* for */ ;
  } /* while */ ;
} /* main */
Do kompilacji powstaje makropolecenie (CC.BAT) o następującej zawartości:
e:\sdcc\bin\sdcc -mmcs51 --model-small test1.c
Kompilacja przebiega bezboleśnie.
test1_ilu01.png
Wygenerowany kod program jest zapisany w pliku o nazwie test1.ihx. By obejrzeć, co nawyczyniał kompilator, zastosowany jest program AVSIM51. Wykonując program krokowo, dochodzimy do pewnej dziwności.
test1_ilu02a.PNG
Kompilator wygenerował kod do wyzerowania wewnętrznej pamięci RAM o wielkości 256 bajtów, pomimo że miał zadany model small. Sądzę, że dla samego procka nie będzie miało to istotnego znaczenia, gdyż wystąpią operacje zapisu do nieistniejących obszarów pamięci. Jednak symulator AVSIM51 taką sytuację wykrył no i się odpowiednio wyraził. Zanim zacząłem urągać kompilatorowi, to zastanowiłem się nad zjawiskiem. Zamiast szukać wad u innych w pierwszej kolejności warto przyjrzeć się własnemu postępowaniu. Przy lekturze dokumentacji powstała myśl, że może należy podać wielkość obszaru pamięci.
Korekta makropolecenia CC.BAT do następującej postaci:
e:\sdcc\bin\sdcc -mmcs51 --model-small --iram-size 128 test1.c
i ponowna kompilacja daje właściwy wynik:
test1_ilu03a.PNG
Tym razem zerowany jest obszar pamięci RAM o właściwej wielkości. Dalsza symulacja program doprowadza do realizacji instrukcji zawartych w programie napisanym w języku C (do tej pory to był startup).
test1_ilu04a.PNG
Realizując program krokowo, nasuwa się wniosek, że kompilator zrobił to właściwie. Nawet można wywnioskować, że zmienna programu GlobalVar ma adres 8 w przestrzeni adresowej (symbol R0' na ekranie symulatora odpowiada adresowi 8). Ma to swoje potwierdzenie w dokumencie test1.map:
Value Global Global Defined In Module
----- -------------------------------- ------------------------
00000008 _GloblVar test1
Na sztuki wszystko się teraz zgadza. Pierwsze starcie zakończyło się powodzeniem, udało się dogadać z kompilatorem i przekazać mu precyzyjne informacje dotyczące generacji kodu programu.
Nie masz wymaganych uprawnień, aby zobaczyć pliki załączone do tego posta.

Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse

Awatar użytkownika
gaweł
Geek
Geek
Posty: 1321
Rejestracja: wtorek 24 sty 2017, 22:05
Lokalizacja: Białystok

Re: [SDCC] Kompilator języka C dla mikrokontrolerów C51

Postautor: gaweł » piątek 26 sty 2018, 12:05

Drugie starcie z kompilatorem dotyczyło lokacji zmiennych w zewnętrznej pamięci RAM. Program do celów badawczych został zmodyfikowany do następującej postaci:

Kod: Zaznacz cały

__xdata unsigned char GloblVar ;

main ( )
{
  unsigned char j ;
/*---------------------------------------------------*/
  while ( 1 )
  {
    GloblVar = 1 ;
    for ( j = 0 ; j < 4 ; j++ )
    {
      GloblVar = GloblVar << 1 ;
    } /* for */ ;
  } /* while */ ;
} /* main */

W programie żądane jest utworzenie jednobajtowej zmiennej w zewnętrznej pamięci RAM (zaklęcie __xdata). Do kompilacji utworzone zostaje makropolecenie CC.BAT o następującej treści:
e:\sdcc\bin\sdcc -mmcs51 --model-large --iram-size 128 test2.c
Kompilacja przebiega bezproblemowo. Uruchomienie programu w symulatorze mikrokontrolera potwierdza, że kod programu został wygenerowany zgodnie z oczekiwaniami.
test2_ilu01a.PNG
Zmienna globalna zastosowana w programie ma przydzielony adres 0x0001 w pamięci zewnętrznej RAM. Tą samą informację można znaleźć w pliku test2.map wygenerowanym przez pakiet SDCC.
Value Global Global Defined In Module
----- -------------------------------- ------------------------
D: 00000001 _GloblVar test2

Rodzi się jedynie pytanie: dlaczego zmienna ma adres 0x0001 zamiast spodziewanego 0x0000? No cóż, na razie pozostaje to tajemnicą.
Symulując program pewien ciąg instrukcji w obszarze startup sugerował, że kompilator wygenerował ciąg instrukcji do wyzerowania obszaru pamięci. No tak, w kompilatorach języka C w generacji kodu występuje coś, co jest określane jako segment BSS (segment danych nie zainicjowanych w sposób jawny). Sugestię należy sprawdzić. W tym celu zostaje zmodyfikowany tekst programu do następującej postaci:

Kod: Zaznacz cały

__xdata unsigned char AnyArray1 [ 16 ] ;
__xdata unsigned char GloblVar ;
__xdata unsigned char AnyArray2 [ 16 ] ;

main ( )
{
  unsigned char j ;
/*---------------------------------------------------*/
  while ( 1 )
  {
    GloblVar = 1 ;
    for ( j = 0 ; j < 4 ; j++ )
    {
      GloblVar = GloblVar << 1 ;
    } /* for */ ;
  } /* while */ ;
} /* main */
Kolejna kompilacja i uruchomienie programu w symulatorze:
test2_ilu02a.PNG
Widać, że jest pobierana do rejestru R0 wielkość obszaru (?), która by się zgadzała z tekstem programu, bowiem sumaryczna zajętość zmiennych globalnych wynosi 33 (21 hex). Dodatkowo z kodu programu wynika, że wielkość zerowanego segmentu jest badana, czy nie wynosi ona 0 i ewentualnie występuje obskok instrukcji zerujących pamięć RAM. W wyniku wykonana zaznaczonych na powyższej ilustracji instrukcji został wyzerowany obszar pamięci o wymaganej wielkości. Po tym eksperymencie wzrósł apetyt na kolejne badania. W programie zostały utworzone zmienne, których sumaryczna wielkość przekroczyła 256 bajtów.
Tekst programu:

Kod: Zaznacz cały

__xdata unsigned char AnyArray1 [ 16 ] ;
__xdata unsigned char GloblVar ;
__xdata unsigned char AnyArray2 [ 15 ] ;
__xdata unsigned char AnyArray3 [ 256 ] ;

main ( )
{
  unsigned char j ;
/*---------------------------------------------------*/
  while ( 1 )
  {
    GloblVar = 1 ;
    for ( j = 0 ; j < 4 ; j++ )
    {
      GloblVar = GloblVar << 1 ;
    } /* for */ ;
  } /* while */ ;
} /* main */
Ponowna kompilacja i uruchomienie programu w symulatorze:
test2_ilu03a.PNG
Kompilator zrobił wszystko jak trzeba. No, to budzi apetyt na więcej.
Nie masz wymaganych uprawnień, aby zobaczyć pliki załączone do tego posta.

Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse

Awatar użytkownika
gaweł
Geek
Geek
Posty: 1321
Rejestracja: wtorek 24 sty 2017, 22:05
Lokalizacja: Białystok

Re: [SDCC] Kompilator języka C dla mikrokontrolerów C51

Postautor: gaweł » piątek 26 sty 2018, 15:29

Kwestia używania zewnętrznej pamięci RAM jest już opanowana. Wiadomo jakiego zaklęcia należy użyć, by zmanipulować kompilator do własnej woli. Jednak jest jeszcze w tym temacie kilka kwestii do zbadania. Po pierwsze, nie ma żadnej gwarancji, że przyłączona zewnętrzna pamięć RAM będzie widziana w przestrzeni adresowej poczynając od adresu 0. Przecież możliwe jest dowolne zbudowanie dekodera adresowego, którego zadaniem jest wypracowanie sygnałów typu CHIP SELECT dla pamięci, i wcale nie musi być ona umieszczona na początku przestrzeni adresowej. Zagadnienie raczej należy do linkera (nie kompilatora) i on jest odpowiedzialny za te działania. Lektura odpowiedniej dokumentacji sugeruje użycie odpowiednich parametrów w wywołaniu programu do generowania kodu wynikowego. Utworzony zostaje program testowy:

Kod: Zaznacz cały

__xdata unsigned short GloblVar ;

main ( )
{
  unsigned char j ;
/*---------------------------------------------------*/
  while ( 1 )
  {
    GloblVar = 1 ;
    for ( j = 0 ; j < 4 ; j++ )
    {
      GloblVar = GloblVar << 1 ;
    } /* for */ ;
  } /* while */ ;
} /* main */

Tym razem makropolecenie do kompilacji ma następującą postać (po dodaniu parametru –xram-loc <wartość>):
e:\sdcc\bin\sdcc -mmcs51 --model-large --iram-size 128 --xram-loc 0x8000 test3.c
Kompilacja przebiega bez problemów. Prawdę o wynikach generacji wyraża symulator AVSIM51.
test3_ilu01a.PNG
Wykonanie instrukcji pierwszego podstawienia w funkcji main, jest zrealizowane jako operacja zapisu do pamięci zewnętrznej pod adres 0x8000, zgodnie z oczekiwaniami.
W parze z opcją --xram-loc <wartość> występuje opcja --xram-size <wartość>. Ciekawe jakie będą efekty jej zastosowania. Powstaje program diagnozujący narzędzie SDCC o następującej treści:

Kod: Zaznacz cały

__xdata unsigned char Table [ 512 ] ;
__xdata unsigned short GloblVar ;

main ( )
{
  unsigned short j ;
/*---------------------------------------------------*/
  while ( 1 )
  {
    for ( j = 0 ; j < 512 ; j ++ )
      Table [ j ] = 0x2A ;
    GloblVar = 0x5AA5 ;
    for ( j = 0 ; j < 4 ; j++ )
    {
      GloblVar = GloblVar << 1 ;
    } /* for */ ;
  } /* while */ ;
} /* main */
oraz do kompilacji zostaje użyte następujące polecenie:
e:\sdcc\bin\sdcc -mmcs51 --model-large --iram-size 128 --xram-loc 0x8000 --xram-size 1024 test3a.c
Kolejna kompilacja i symulacja wygenerowanego kodu:
test3_ilu02a.PNG
Tu mamy realizację pętli wypełniającej tablicę odpowiednią stałą. W dalszej kolejności jest kod realizujący następne podstawienie:
test3_ilu03a.PNG
Wszystko na sztuki się zgadza. To nadszedł czas by przykręcić śrubę dla kompilatora. Tekst programu zostaje nieznacznie zmieniony (zwiększona zostaje wielkość tablicy). Ponowna kompilacja i …
test3_ilu04.PNG
tym razem również pakiet SDCC stanął na wysokości zadania i nie dał się wprowadzić w maliny. Coraz bardziej go lubię :) .
Nie masz wymaganych uprawnień, aby zobaczyć pliki załączone do tego posta.

Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse

Awatar użytkownika
gaweł
Geek
Geek
Posty: 1321
Rejestracja: wtorek 24 sty 2017, 22:05
Lokalizacja: Białystok

Re: [SDCC] Kompilator języka C dla mikrokontrolerów C51

Postautor: gaweł » sobota 27 sty 2018, 19:16

Po dotychczasowych sukcesach nadszedł czas na to, co jest najistotniejsze w prockach: obsługa przerwań. Konieczne jest wykombinowanie takiego programu, który w prosty sposób potwierdzi poprawność. Wybór padł na wbudowany w mikrokontroler zespół zegara/licznika (z oferowanych dwóch peryferali wybrany został zegar/licznik 0). Ponieważ licznik generuje przerwanie po wykonaniu określonej liczby cykli zegarowych, może okazać się, że „dosymulowanie” w pracy krokowej do tego momentu może być … mało ciekawe. Gdyby puścić program „na żywioł” i gdzieś obserwować skutki tego żywiołu to byłoby OK. Symulator na ekranie pokazuje zawartość początku obszaru wewnętrznej pamięci RAM, więc tam należy ulokować licznik, który będzie inkrementowany w funkcji obsługi przerwania.
Do obsługi przerwań należy odpowiednio zgłosić właściwą funkcję. Odpowiednie „zaklęcie” informuje kompilator, że dana funkcja jest przeznaczona do obsługi przerwania (ma to istotne znaczenie, gdyż obsługa przerwania wymaga ochrony każdego rejestru użytego w funkcji oraz specjalnej funkcji do zakończenia obsługi przerwania). Powiązanie funkcji ze ściśle określonym przerwaniem jest realizowane poprzez podanie numeru przerwania (numeru wektora przerwania) jako liczby umieszczonej w nawiasach tuż za słowem kluczowym __interrupt. W dokumentacji do samego mikrokontrolera są umieszczane informacje o numerach wektorów przerwań. Przeglądając dostępny w pakiecie SDCC plik nagłówkowy dla mikrokontrolera 8051, można dostrzec, że są tam zdefiniowane stałe identyfikujące wektory przerwań. Zamiast pisać numerki, można posiłkować się odpowiednią stałą, co znacząco podnosi czytelność zamiarów autora programu.
Powstaje prosty program diagnostyczny o następującej treści (test4.c):

Kod: Zaznacz cały

#include <8051.h>

__data volatile unsigned char IRQCounter ;

void Timer0InterruptService ( void ) __interrupt ( TF0_VECTOR )
{
  /*-------------------------------------------------------*/
  IRQCounter ++ ;
} /* Timer0InterruptService */


static void InitHardware ( void )
{
  /*-------------------------------------------------------*/
  TMOD = 0x02 ;
  TCON = 0x10 ;
  TH0 = 0xC0 ;
  TL0 = 0 ;
} /* InitHardware */


main ( )
{
  /*-------------------------------------------------------*/
  IRQCounter = 0 ;
  InitHardware ( ) ;
  IE = 0x82 ;
  while ( 1 )
  {
  } /* while */ ;
} /* main */
W tym programie zmienna (będąca licznikiem przerwań) powinna mieć adres 8 w wewnętrznej przestrzeni pamięci RAM. To przypuszczenie ma potwierdzenie w pliku testr4.map.
Value Global Global Defined In Module
----- -------------------------------- ------------------------
00000008 _IRQCounter test4

Do kompilacji służy następujące polecenie,
e:\sdcc\bin\sdcc -mmcs51 --model-small --iram-size 128 test4.c
która przebiegła bez jakichkolwiek problemów.
Nadszedł czas na symulacyjną weryfikację programu. Po załadowaniu wygenerowanego programu do symulatora mikrokontrolera, zostaje puszczony on „na żywioł” i zatrzymany po kilku sekundach. W tym czasie program doliczył się 65 hex przerwań od zegara/licznika.
test4_ilu01a.PNG
No, można uznać, że sztuka obsługi przerwań została opanowana.
Nie masz wymaganych uprawnień, aby zobaczyć pliki załączone do tego posta.

Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse

Awatar użytkownika
photin
Posty: 16
Rejestracja: niedziela 08 paź 2023, 12:43
Lokalizacja: Klaudyn-Pruszkow
Kontaktowanie:

Re: [SDCC] Kompilator języka C dla mikrokontrolerów C51

Postautor: photin » środa 05 cze 2024, 09:35

Informacje po polsku o programowaniu MCS-51 8051 w tym w SDCC:
http://staff.uz.zgora.pl/mkoziol/mcs51/mcs51.html

Awatar użytkownika
photin
Posty: 16
Rejestracja: niedziela 08 paź 2023, 12:43
Lokalizacja: Klaudyn-Pruszkow
Kontaktowanie:

Re: [SDCC] Kompilator języka C dla mikrokontrolerów C51

Postautor: photin » poniedziałek 10 mar 2025, 19:02

Super strona z info o pisaniu kodu do 8051 i debugowaniu go!
https://bit.kuas.edu.tw/~8051/

Awatar użytkownika
photin
Posty: 16
Rejestracja: niedziela 08 paź 2023, 12:43
Lokalizacja: Klaudyn-Pruszkow
Kontaktowanie:

Re: [SDCC] Kompilator języka C dla mikrokontrolerów C51

Postautor: photin » czwartek 18 wrz 2025, 13:23

AT89LP51ED2 to chyba jedno z ciekawych nowszych wcielen C51, o dosc duzych mozliwosciach. Niestety, sa problemy z zaprogramowaniem jego 64kB flash.
TL866 II + nie ma go na liscie wspieranych ukladow, a takze inne programatory nie wspieraja, AT89LP51ED2..

Peter opracowal sposob i udostepnil kod dla programowania bezpiecznikow i flasha przez Arduino.
https://petervanhoyweghen.wordpress.com ... n-arduino/

Jego sposob wciaz dziala na dolaczonych przykladach (Blink, KnightRider, skompilowanych SDCC) na Arduino Leonardo, podlaczonym do plytki 8051 devboard z AT89LP51ED2.
AVRDUDE programuje, i odczytuje poprawnie KnightRider.ihx, z Examples, natomiast niestety proba zaprogramowania wiekszego kodu z 32768 rozmiarem konczy sie "niemal zerowym" Flashem:
failed_flash_2025-09-18_12-03.png


Natomiast KnightRider.ihx programuje sie poprawnie (tylko ~222 bajty). Zgrany komenda:

Kod: Zaznacz cały

avrdude -C ../data/avrdude-at89lp.conf -P /dev/ttyACM3 -b 19200 -c stk500v1 -p lp51 -U flash:r:flash.bin:r


flash_OK_knight_rider_2025-09-18_12-04.png


Myslalem, ze cos pokrecilem, przy konwersji z BIN (zgrany, duzy EPROM 32768kb), na IHX, wiec sprobowalem roznych komend:

Kod: Zaznacz cały

srec_cat BIG.BIN -binary -o BIG.ihx -Intel

Kod: Zaznacz cały

avr-objcopy -I binary -O ihex BIG.BIN BIG.ihx

Kod: Zaznacz cały

objcopy -Ibinary -Oihex BIG.BIN BIG.ihx


ale test z 3-cia opcja objcopy z KnightRider.ihx -> BIN, generuje taki sam BIN, jak zgrany z Flasha AT89LP51ED2.

Pierwszy raz mam taka sytuacje, ze cos dziala na mniejszym pliku, a w wiekszym nie dziala.
Oczekiwalbym, ze przynajmniej cos sie zapisze ... no zapisuje sie, FF kazdy zostaje zmieniony na 00, tylko dlaczego nie na dane??


Kod: Zaznacz cały

avrdude -C ../data/avrdude-at89lp.conf -P /dev/ttyACM3 -b 19200 -c stk500v1 -p lp51 -U flash:w:BIG.ihx

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.04s

avrdude: Device signature = 0x1e6465 (probably lp51)
avrdude: NOTE: "flash" memory has been specified, an erase cycle will be performed
         To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file "BIG.ihx"
avrdude: input file BIG.ihx auto detected as Intel Hex
avrdude: writing flash (32768 bytes):

Writing | ################################################## | 100% 23.33s

avrdude: 32768 bytes of flash written
avrdude: verifying flash memory against BIG.ihx:
avrdude: load data flash data from input file BIG.ihx:
avrdude: input file BIG.ihx auto detected as Intel Hex
avrdude: input file BIG.ihx contains 32768 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 18.44s

avrdude: verifying ...
avrdude: verification error, first mismatch at byte 0x0000
         0x00 != 0x02
avrdude: verification error; content mismatch

avrdude: safemode: Fuses OK (E:FF, H:FF, L:FF)

avrdude done.  Thank you.



Tym bardziej, ze juz nawet pierwszy bajt jest zle zapisany w duzym pliku? Jak takie cos jest mozliwe w ogole??

Tutaj jest KnightRider.IHX:

Kod: Zaznacz cały

:03000000020006F5
:03005F0002000399
:0300030002006296
:200062007F008F068EF005F07401800225E0D5F0FBF4F590900064C0071200A6D0070FBFAA
:20008200080040DE1F8F068EF005F07401800225E0D5F0FBF4F590900064C0071200A6D099
:0400A2000780E122D0
:2000A600AE82AF837C007D00C3EC9EED64808FF063F08095F0501B7AD07B07EA24FFF8EBC3
:1300C60034FFF988028903E84970F00CBC00D90D80D6222E
:06003500E478FFF6D8FD9F
:200013007900E94400601B7A009000DD780075A040E493F2A308B8000205A0D9F4DAF27577
:02003300A0FF2C
:20003B007800E84400600A790075A040E4F309D8FC7800E84400600C7900904000E4F0A345
:04005B00D8FCD9FAFA
:0D0006007581071200D9E582600302000336
:0400D900758200220A
:00000001FF


a tutaj poczatek duzego ROM:


Kod: Zaznacz cały

:100000000204D9852B9010481D8002C2A84390039A
:10001000D228D24832FFFFFFFFFFFF02030EFFFF8F
:10002000FFFFFF0203B6C28C858A1D858C1CD28C13
:10003000C28DD2A930280574310204AB3274FFF5A9
:100040003990019DE0F522900050E0A21020E001DF
:10005000B3925EE492E7C0E0900054E0A21120E089
:1000600001B3925FD0E092E6F5382230320302010C
:100070004390004DE0FE90010C122A8890004EE063
:10008000B4042C74023010062012031201CA1201AB
:100090008F5004C212802190010C122A8874033000
:1000A00010063012031201CA12018FD212800930D9
:1000B00010031201CA12018F401420141B90004F2C
:1000C000E07004C2168003201610C210800C301499
:1000D00007201006D210D2169214900051E0FE9024
:1000E0000110122A88900052E0B4042C74023011DE
:1000F000062013031201CA12018F5004C21380217B
:10010000900110122A887403301106301303120173
:10011000CA12018FD21380093011031201CA1201D1


Kod IHX wygenerowany przez SDCC, ma zmienna ilosc bajtow w wierszu, ale to nie powinno miec znaczenia, bo ma rowniez dlugie wiersze po 20 bajtow, a kod IHX z BIG.BIN, ma wszystkie wiersze o stalej ilosci bajtow..

Moze ktos bardziej doswiadczony zasugeruje, gdzie moze tkwic blad i haczyk??

Dlaczego KnightRider.bin zgrany z flash, ma FF, czyli nie zapisywal poza zakresem, a blednie wgrany BIG.ihx, ma niemal same 00, az do konca 64kB zakresu?? (dolaczylem dump z proby wgrania BIG.ihx do flash jako flash.txt
Nie masz wymaganych uprawnień, aby zobaczyć pliki załączone do tego posta.

Awatar użytkownika
photin
Posty: 16
Rejestracja: niedziela 08 paź 2023, 12:43
Lokalizacja: Klaudyn-Pruszkow
Kontaktowanie:

Re: [SDCC] Kompilator języka C dla mikrokontrolerów C51

Postautor: photin » czwartek 18 wrz 2025, 14:02

Chyba, jako obejscie problemu z wgrywaniem kodu do Flash AT89LP51ED2 za posrednictwem Arduino, wyprobuje, czy mozna to zrobic przez Bootloader wlaczajacy sie po UART..

... ok, udalo sie uzyc FLIP do programowania Flash.
Kilka narzedzi, ale w koncu jest mozliwosc adaptacji i konfiguracji tego MCU.

flip_connection.png
Nie masz wymaganych uprawnień, aby zobaczyć pliki załączone do tego posta.


Wróć do „Retro”

Kto jest online

Użytkownicy przeglądający to forum: Obecnie na forum nie ma żadnego zarejestrowanego użytkownika i 16 gości