Fórum témák

» Több friss téma
Fórum » AVR - Miértek hogyanok
 
Témaindító: pakibec, idő: Márc 11, 2006
Témakörök:
WinAVR / GCC alapszabályok:
1. Ha ISR-ben használsz globális változót, az legyen "volatile"
2. Soha ne érjen véget a main() függvény
3. UART/USART hibák 99,9% a rossz órajel miatt van
4. Kerüld el a -O0 optimalizációs beállítást minden áron
5. Ha nem jó a _delay időzítése, akkor túllépted a 65ms-et, vagy rossz az optimalizációs beállítás
6. Ha a PORTC-n nem működik valami, kapcsold ki a JTAG-et
Bővebben: AVR-libc FAQ
Lapozás: OK   828 / 840
(#) Istvanpisti válasza Sick-Bastard hozzászólására (») Márc 7, 2022 /
 
Szia!

Nem vagyok benne biztos, hogy a
  1. DEBUGGER_UART_TXFS((const unsigned char*)strmx[4]);

sorból a forditó olyan kódot fordit, ami a flash-ből veszi az adatot.

Én igy szoktam csinálni és ez működik is:
  1. #include <avr/pgmspace.h>
  2. const char c0[]  PROGMEM ="valami1\0";         
  3. const char c1[]  PROGMEM ="valami2\0";         
  4. const char c2[]  PROGMEM ="valami3\0";         
  5. const char c3[]  PROGMEM ="valami4\0"
  6.  
  7. #define COMMAND_NUMBER 4
  8.  
  9. char Buffer[32];
  10.  
  11. AVR studio 4.19-ben igy csináltam ->
  12.  
  13. PGM_P commands[COMMAND_NUMBER] PROGMEM = {c0,c1,c2,c3};
  14. strcpy_P(Buffer,(PGM_P)pgm_read_word(&commands[i]));
  15.  
  16. Ekkor a Buffer változóban van a commands tömb, i-edik elemének tartalma, amit ki lehet küldeni pl. a sororportra
  17.  
  18. Microchip studióban (7.0.132) igy->  
  19.  
  20. const char* const commands[COMMAND_NUMBER] PROGMEM = {c0,c1,c2,c3};
  21. strcpy_P(Buffer,(char*)pgm_read_word(&commands[i]));
  22.  
  23. Ekkor a Buffer változóban van a commands tömb, i-edik elemének tartalma

Nézd meg a mellékleteket!
A hozzászólás módosítva: Márc 7, 2022
(#) Sick-Bastard válasza Istvanpisti hozzászólására (») Márc 7, 2022 /
 
Üdv!

A tömb célzott "megcímzésével" nincs baj.
  1. DEBUGGER_UART_TXFS((const unsigned char*)strmx[4]);

Ez mindig jól működik.

  1. DEBUGGER_UART_TXFS((const unsigned char*)strmx[i]);

Ezzel van a baj. Ha változót használok a címhez, és a cím nagyobb mint 3 (for loopban i < 4), akkor jön a "szemetelés".
(#) lazsi válasza tufatofu hozzászólására (») Márc 8, 2022 /
 
Nos, ez is egy megoldás...
Egyébként van itt mellettem egy olyan AMD K6-os gép, amibe még beletehető 3 db ISA kártya. Cserélhető winchivel: ha akarom XP, ha akarom 98SE.
(Ha sok időm lesz, csinálok DOS-os winchit is, mert miért ne... )

De ezek szerint nincs megoldás a MicroChip Studio + AT90S.... problémájára...
(#) Panhard válasza lazsi hozzászólására (») Márc 8, 2022 /
 
Vmware. Olyan oprendszert futtattok benne, amilyet akartok.
(#) Istvanpisti válasza Sick-Bastard hozzászólására (») Márc 8, 2022 /
 
Szia!
Nézd meg az .lss fájlban (ott van, ahol a .hex is) milyen utasitást találsz
  1. DEBUGGER_UART_TXFS((const unsigned char*)strmx[4]);
ennél a sornál.
Ha nincsen benne olyan, ami a flash-ből olvas (LPM mnemonic [Load Program Memory]) akkor az a hiba.

lss.jpg
    
(#) rolandgw válasza Sick-Bastard hozzászólására (») Márc 8, 2022 /
 
Nem olvas a flash-ből, ha nincs pgm_read. Írd át a te verziódra és látni fogod. Lpm, ahogy Istvanpisti írta.
Bővebben: Link
(#) Sick-Bastard válasza rolandgw hozzászólására (») Márc 8, 2022 /
 
Üdv!

Nem általánosságban van bajom a flash-ben tárolt string kiolvasásával.
A pgm_read_byte-ot használom és a .lss-ben is megvan a lpm utasítás.

  1. #define DEBUGGER_UART_TXFS(string)                      USART0_TX_Flash_String(string)
  2.  
  3. void USART0_TX_Flash_String(const unsigned char* text)
  4. {
  5.         while(pgm_read_byte(text)>0)
  6.         {
  7.                 USART0_TXD(pgm_read_byte(text++));
  8.         }
  9. }
  10.  
  11. ------------------------------------------      .lss    ------------------------------------------
  12. void USART0_TX_Flash_String(const unsigned char* text)
  13. {
  14.     20f0:       cf 93           push    r28
  15.     20f2:       df 93           push    r29
  16.     20f4:       ec 01           movw    r28, r24
  17.         while(pgm_read_byte(text)>0)
  18.     20f6:       ce 01           movw    r24, r28
  19.     20f8:       fe 01           movw    r30, r28
  20.     20fa:       24 91           lpm     r18, Z                                                          //      <<<< lpm !!!
  21.     20fc:       21 11           cpse    r18, r1
  22.     20fe:       03 c0           rjmp    .+6             ; 0x2106 <USART0_TX_Flash_String+0x16>
  23.         {
  24.                 USART0_TXD(pgm_read_byte(text++));
  25.         }
  26. }
  27.     2100:       df 91           pop     r29
  28.     2102:       cf 91           pop     r28
  29.     2104:       08 95           ret
  30.                 USART0_TXD(pgm_read_byte(text++));
  31.     2106:       21 96           adiw    r28, 0x01       ; 1
  32.     2108:       fc 01           movw    r30, r24
  33.     210a:       84 91           lpm     r24, Z                                                          //      <<<< lpm !!!
  34.     210c:       0e 94 2a 0f     call    0x1e54  ; 0x1e54 <USART0_TXD>
  35.     2110:       f2 cf           rjmp    .-28            ; 0x20f6 <USART0_TX_Flash_String+0x6>
  36. ------------------------------------------      .lss    ------------------------------------------


Ez jó ez működik:
  1. DEBUGGER_UART_TXFS((const unsigned char*)strmx[4]);


Ez nem:
  1. DEBUGGER_UART_TXFS((const unsigned char*)strmx[változó]);


Csak akkor van baj, ha strmx[változó]-t használok for() ciklusban.

Most már egyik for() loop sem megy.
És az UART-hoz használt egyik rutin is vacakol inicializálás során. Úgy viselkedik, mintha csomagot kapott volna és válaszol.
Ez a két jelenség nem lehet hogy arra utal, hogy a címzési hiba van a háttérben? Elfogy a RAM/túlcsordul? A fordításkor 13KB(76%)-os a kihasználtság.

SB

uart_dump.txt
    
(#) Sick-Bastard válasza Sick-Bastard hozzászólására (») Márc 8, 2022 /
 
Üdv!

A kódomban a változót megváltoztattam, ahol eddig (const unsigned char*)strmx[i] szerepelt, ott most a (const unsigned char*)esp8266_cmd_ptr[i].cmd_ptr vette át a helyét.

Megnéztem az lss-filet, amikor működik, és akkor amikor nem.
Ezt a filet még eddig nem használtam, vizsgáltam úgy igazából szóval csak tippelek:

Úgy vélem, hogy a fordító, a működő kódban, ahol i < 4, ott nem valódi for() ciklust használ, hanem 4x futtatja le a kódot:
  1. DEBUGGER_UART_TXFS(esp8266_cmd_ptr[i].cmd_ptr);        
  2.     a762:       8f e1           ldi     r24, 0x1F       ; 31
  3.     a764:       92 e0           ldi     r25, 0x02       ; 2
  4.     a766:       0e 94 78 10     call    0x20f0  ; 0x20f0 <USART0_TX_Flash_String>
  5.                 DEBUGGER_UART_TX_String(enter_txt);
  6.     a76a:       83 e1           ldi     r24, 0x13       ; 19
  7.     a76c:       93 e1           ldi     r25, 0x13       ; 19
  8.     a76e:       0e 94 50 10     call    0x20a0  ; 0x20a0 <USART0_TX_String>


Amíg a nem működő kódban, ahol i < 6, ott már valóban egy ciklust hoz létre:

  1. DEBUGGER_UART_TXFS(esp8266_cmd_ptr[i].cmd_ptr);        
  2.     a76a:       88 81           ld      r24, Y
  3.     a76c:       99 81           ldd     r25, Y+1        ; 0x01
  4.     a76e:       0e 94 78 10     call    0x20f0  ; 0x20f0 <USART0_TX_Flash_String>
  5.                 DEBUGGER_UART_TX_String(enter_txt);
  6.     a772:       83 e1           ldi     r24, 0x13       ; 19
  7.     a774:       93 e1           ldi     r25, 0x13       ; 19
  8.     a776:       0e 94 50 10     call    0x20a0  ; 0x20a0 <USART0_TX_String>
  9.         for(u8b i = 0; i < 6; i++)
  10.     a77a:       24 96           adiw    r28, 0x04       ; 4
  11.     a77c:       80 e0           ldi     r24, 0x00       ; 0
  12.     a77e:       c4 3a           cpi     r28, 0xA4       ; 164
  13.     a780:       d8 07           cpc     r29, r24
  14.     a782:       99 f7           brne    .-26            ; 0xa76a <MXA_Test+0x18>


Mellékeltem a két lss-t.
Ez nevezhető fordító hibának?

SB
(#) Kovidivi válasza Sick-Bastard hozzászólására (») Márc 9, 2022 /
 
Régebben próbálkoztam vele, és volt, amikor típuskonverzió kellett a "változó"-ra, ebben a sorban (vagy a tartalmára!) pl:
DEBUGGER_UART_TXFS((const unsigned char*)strmx[változó]);
Oka, hogy a tömb címzéséhez egész szám kellene, talán az se mindegy, hogy byte, integer, unsigned vagy signed a változó típusa. Egyikkel működött, másikkal nem. Ilyen úton indulj el, próbálgatással akár. Vagy használj ideiglenes változót, amibe átraksz értékeket (pl. változó), és ennek az ideiglenes változónak próbálgasd a típusát változtatni (először használhatsz konstantot is). Nekem így sikerült egy komplex dolgot megoldanom, ha jól emlékszem, integer típussal működött csak.
(#) Istvanpisti válasza Sick-Bastard hozzászólására (») Márc 9, 2022 /
 
Szia!
Mivel az első két hozzászólásodban nem mutattad meg a DEBUGGER_UART_TXFS függvény belsejét, emiatt gondoltam arra, amire.
Most talán annyi ötletem lenne, hogy próbáld meg a ciklusban stringgé alakitani a flashben lévő karaktersorozatot és utána átadni a módositott DEBUGGER_UART_TXFS fv-nek, az alábbiak szerint:
  1. char buffer[32];
  2. void USART0_TX_Flash_String(const unsigned char* text)
  3. {
  4.        register uint8_t *p = text;
  5.         while(*p)
  6.         {
  7.                 USART0_TXD(*p);
  8.                 p++;
  9.         }
  10. }
  11.  
  12. for(u8b i = 0; i < 6; i++)
  13. {
  14.     strcpy_P(buffer,(char*)pgm_read_word(&strmx[[i]));
  15.     USART0_TX_Flash_String(buffer);
  16. }
A hozzászólás módosítva: Márc 9, 2022
(#) Sick-Bastard válasza Istvanpisti hozzászólására (») Márc 11, 2022 /
 
Üdv!

Nem ment.
Ha a USART0_TX_Flash_String()-et módosítom, akkor az AVR az inicializálást sem tudja elvégezni (UART error).
Ha strcpy_P()-t használok, a for() ciklusban, akkor egy végtelen dump jön létre, amit a wdt szakit meg, AVR restart-al. Ergo ez is egy rossz végtelen ciklus.

Kipróbáltam mindent ami eszembe jutott a esp8266_cmd_ptr[i].cmd_ptr helyén:
  1. esp8266_cmd_ptr[i].cmd_ptr
  2. esp8266_cmd_ptr[(int)i].cmd_ptr
  3. esp8266_cmd_ptr[(const int)i].cmd_ptr
  4. esp8266_cmd_ptr[(unsigned int)i].cmd_ptr
  5. esp8266_cmd_ptr[(const unsigned int)i].cmd_ptr
  6. esp8266_cmd_ptr[(const signed int)i].cmd_ptr
  7. esp8266_cmd_ptr[(char)i].cmd_ptr
  8. ...

Semmi sem jött be.

A for() ciklusba még megpróbáltam egy cím összehasonlítás is végezni, valahogy igy:
  1. for(u8b i = 0; i < 6; i++)
  2. {
  3.         if(esp8266_cmd_ptr[i].cmd_ptr == esp8266_cmd_ptr[4].cmd_ptr)
  4.         {
  5.                 Print_Value_DEC("Cim eggyezés itt:", i);
  6.         }
  7.         if(&esp8266_cmd_ptr[i].cmd_ptr == &esp8266_cmd_ptr[4].cmd_ptr)
  8.         {
  9.                 Print_Value_DEC("Cim eggyezés itt:", i);
  10.         }
  11.         ....
  12. }


Semmi. A címek/értékek nem egyeztek.

9000 évvel később:

Szóval hosszas szenvedés után észrevettem, hogy az a másik for() ciklus, amire ezt alapoztam, nem PROGMEM-es változót használ.

Az a ciklus azért megy mert a tömb RAM-ban van tárolva nem pedig Flash-ben.
Kivettem a változó elől a const és a PROGMEM-et (attribútumnak hívjuk?)
  1. erről: const td_esp8266_cmd_ptr esp8266_cmd_ptr[ESP8266_CFAMAP_CNT] PROGMEM = {...};
  2. erre:   td_esp8266_cmd_ptr esp8266_cmd_ptr[ESP8266_CFAMAP_CNT] = {...};

és a for() ciklus már megy is....... De mégis miért?

Egy egy csúnya "patch"-mivel így a kívánt tömböm, nem a Flashben van hanem RAM-ban van(ram pazarlás).

A szituáció nem hagyott nyugodni, így a MXA_Test()-et átírtam, hogy készítsek róla egy részletes LOG-ot, amit mellékelek.

Az eredmény még mindig nem hagy nyugodni.
A DEBUGGER_UART_TXFS(string) simán visszaadja mind a Flash-ben, mind a RAM-ban tárolt tömb(tömbben tárolt címek) értékeit. Igen IS-IS. Miért, hogyan?

Csak 1 módon nem kapom vissza(az eredeti probléma):
Ha a Flash adatot akarok bármilyen ciklussal kiolvasni:
  1. for(i = 0; i < 6; i++)
  2.         {
  3.                 Print_Value_DEC("esp8266_cmd_flash_ptr[i].cmd_ptr:      ", i);
  4.                 DEBUGGER_UART_TXFS(esp8266_cmd_flash_ptr[i].cmd_ptr);
  5.                 DEBUGGER_UART_TX_String(enter_txt);    
  6.         }

Igen még más ciklusokkal is próbálkoztam, while(i < 3), do while(i < 3)...

Még egy tesztet végrehajtok, mégpedig a compilert cserélem le a mostani:
avr-gcc (GCC) 11.1.0 innen
egy régebbire, 10.2 vagy 9.2-re. Hátha.

SB
(#) majkimester válasza Sick-Bastard hozzászólására (») Márc 11, 2022 /
 
A stack méretét próbáltad növelni?
Hátha, csak az csordul túl.
(#) Sick-Bastard válasza majkimester hozzászólására (») Márc 11, 2022 /
 
Üdv!

Azt nem tudom, hogy kell. Neten is csak annyit találtam, hogy az avr-gcc elvileg alapértelmezetten a maximumot engedélyezi.
Hirtelen csak annyit tudtam csinálni, hogy létrehoztam egy másik projektet, amibe csak annyit raktam bele, ami feltétlen ehhez a kódhoz kellett, de a hiba így is fennáll.

SB
(#) Istvanpisti válasza Sick-Bastard hozzászólására (») Márc 11, 2022 /
 
Szia!

Még az jutott eszembe, hogy ebben
  1. void USART0_TX_Flash_String(const unsigned char* text)
  2. {
  3.         while(pgm_read_byte(text)>0)
  4.         {
  5.                 USART0_TXD(pgm_read_byte(text++));
  6.         }
  7. }


próbáld lecserélni a
  1. pgm_read_byte
sort a
  1. pgm_read_word
-re. Én ezt használom és működik
(#) majkimester válasza Sick-Bastard hozzászólására (») Márc 12, 2022 / 1
 
Oké nem ez az oka. De játszottam vele egy kicsit és rájöttem.
Ha flash-be teszel string-et, akkor azt a pgm_read_byte-tal tudod kivenni, ezt meg is teszed, viszont te a flash-ben lévő string-ekre mutató pointerek tömbjét is a flash-be teszed. Annak kiolvasása pedig így menne:

  1. for(u8b i = 0; i < 10; i++)
  2.         {
  3.                 DEBUGGER_UART_TXFS((PGM_P)pgm_read_word(&(strmx[i])));
  4.                 DEBUGGER_UART_TX_String(enter_txt);
  5.         }


Azaz meghatározod az i. elem címét, és onnan pgm_read_word-del kiveszed a flash-ben lévő string-ed címét.

Ezek után persze nem tudom megmagyarázni, hogy a

  1. DEBUG_STR_F((PGM_P)strmx[5])


például miért is működik.
(#) Kovidivi válasza majkimester hozzászólására (») Márc 12, 2022 /
 
Esetleg mert a "strmx[5]" egyenértékű a tárolt elem címével (nem az értékével!) ? Pontosan ezért tudsz egy tömböt túlcímezni, mert a strmx[i++] akár random memóriacímeket is el tud érni! Ezzel szórakoztam sokat. A tömb az alapból mint egy cím működik, sima változónál a változót kell csillaggal címmé változtatni, meg persze a vissza irány is működik. Tömbnél ha átadod, akkor címet adsz át, ha az egész tömböt akarod egy függvénynek átadni, akkor még az elemszám is kell, mert különben a fv. nem tudhatja, mennyi eleme van a tömbnek.
A hozzászólás módosítva: Márc 12, 2022
(#) rolandgw válasza Kovidivi hozzászólására (») Márc 12, 2022 /
 
Nem erről szól a probléma. A stringek és a rájuk hivatkozó 16 bites mutató tömb is flash-ben van tárolva. Ha hozzá akarsz férni a pgm_read_word vagy a pgm_read_ptr jöhet szóba.
Bővebben: Link
  1. str1:
  2.         .string "egy"
  3. str2:
  4.         .string "ketto"
  5. str3:
  6.         .string "harom"
  7. array:
  8.         .word   str1
  9.         .word   str2
  10.         .word   str3
(#) Gery78 hozzászólása Márc 12, 2022 /
 
Sziasztok!
Egy kávéőrlő elektronikát javítok éppen, amelyben elszállt a mikrovezérlő. A panelon van egy gomb ami nem működik, nem reagál semmire, de egyébként a kontroller működik, csak ez az egy bemenete nem jó, amire a gomb kapcsolódik. A panelon mindent kimértem, csak az Atmel mikrovezérlő lehet a rossz. Egy Atmega 88V kontroller van a panelon. Az volna a kérdésem, hogy kimenthető-e belőle a program, illetve hogyan, és mi kell hozzá? Van egy jó panel is, ha az segít, arról is le lehetne menteni a programot, ha megoldható.
A hozzászólás módosítva: Márc 12, 2022
(#) vargham válasza Gery78 hozzászólására (») Márc 12, 2022 /
 
Általában be szokták kapcsolni a kiolvasás védelmet, de egy próbát megér.
(#) Gery78 válasza vargham hozzászólására (») Márc 12, 2022 /
 
Igen, erre én is gondoltam, ha be van kapcsolva, akkor annyi, de mégis, hogyha nem, akkor hogyan lehet kiolvasni a programját, illetve mi kell hozzá?
(#) majkimester válasza majkimester hozzászólására (») Márc 12, 2022 /
 
Ha megnézzük mi is a fordítás eredménye akkor mindjárt minden világos lesz:

  1. 00000062 <strmx>:
  2.   62:   a4 00 a1 00 97 00 91 00 88 00 83 00 7e 00 79 00     ............~.y.
  3.  
  4. ....
  5.  
  6.             DEBUG_STR_F((PGM_P)strmx[5]);
  7.  16c:   83 e8           ldi     r24, 0x83       ; 131
  8.  16e:   90 e0           ldi     r25, 0x00       ; 0
  9.  170:   0e 94 6d 00     call    0xda    ; 0xda <DEBUG_str_P>


Ha közvetlen számmal indexelek, akkor a fordító fordítási időben ezt kiszámolja, és valójában az index által kiválasztott string flash-ben lévő címével hivja fel a soros küldést.


  1. DEBUG_STR_F((PGM_P)strmx[i]);
  2.  174:   88 81           ld      r24, Y
  3.  176:   99 81           ldd     r25, Y+1        ; 0x01
  4.  178:   0e 94 6d 00     call    0xda    ; 0xda <DEBUG_str_P>


Ha változót használunk indexre, akkor (ez már -O1 optimalizációval) az Y regiszter a strmx első elemére mutató cím a flash-ben (0x0062). Majd ezt növelgeti a ciklusban.
De az ld és ldd utasításokkkal nem a flash-ből, hanem a RAM-ból olvassa ki a string címét, ami vak szerencse, hogy a 0..4 indexekre működött.

  1. DEBUG_STR_F((PGM_P)pgm_read_word(&(strmx[i])));
  2.  17c:   fe 01           movw    r30, r28
  3.  17e:   85 91           lpm     r24, Z+
  4.  180:   94 91           lpm     r25, Z
  5.  182:   0e 94 6d 00     call    0xda    ; 0xda <DEBUG_str_P>


Itt pedig Y-ban lévő címet (ami a strmx i. elemére mutat) átteszi a Z-be, majd a Z-vel ténylegesen a program memóriából, azaz az strmx-ből olvas az lpm utasításokkal.
(#) vargham válasza Gery78 hozzászólására (») Márc 12, 2022 /
 
Kell hozzá egy programozó, például egy Atmel ICE
(#) Sick-Bastard válasza majkimester hozzászólására (») Márc 12, 2022 /
 
Igazad van! Így már megy.

Ami valóban a nagy zavart okozza, hogy ez mitől megy jól for()-on kivül:
  1. DEBUGGER_UART_TXFS(esp8266_cmd_flash_ptr[i].cmd_ptr);

akár csak ez:
  1. DEBUGGER_UART_TXFS(esp8266_cmd_flash_ptr[5].cmd_ptr);


Nem találom az eredeti C/C++ vs Pointersverziót, imaging. De, akkor is, miért???
(#) oszitrek hozzászólása Márc 14, 2022 /
 
Sziasztok,
Szükségem lenne valakire, aki fel tudna nekem programozni pár darab ATTINY24-et.
Van itt rá vállalkozó személy? Jutalom forintban sörben csokiban sütiben
(#) vladcepes hozzászólása Márc 24, 2022 /
 
Sziasztok!
Remélem jó helyre rakom fel a kérdést.
Van egy ilyen programozóm. A kérdésem az lenne hogy van egy ATmega 16 és ezen a programozón keresztül melyik programmal érdemes felrakni rá a Hex. fájlt. Néztem videót és használ benne még egy ledet meg egy ellenállást, de hogy melyik lábra köti a led polaritást, meg az ellenállás milyen értékű legyen azt nem értettem. Esetleg erről valami infót ha kaphatnék.
Megköszönöm!
(#) vargham válasza vladcepes hozzászólására (») Márc 24, 2022 /
 
AVRDUDE
(#) vladcepes válasza vargham hozzászólására (») Márc 28, 2022 /
 
Köszi!
Néztem még egy pár videót ott 2 db 100nF kondit, és egy 10K ellenállást használ. Nem tudom melyik az aktuális, vagyis melyik a jó. Vagy mindkettő?
(#) vladcepes válasza vargham hozzászólására (») Márc 30, 2022 /
 
Köszi!
Ha jól értelmezem itt úgy van mint a PIC Programozón, hogy a pozitív ,negatívot megkapja az USB-ről? ,vagy külön kell adni neki +; - 5V-ot?
(#) pipi válasza vladcepes hozzászólására (») Márc 30, 2022 /
 
Szerintem ez egyszerűbb mint az avrdude:
https://www.fischl.de/usbasp/
ha megnézed a kapcsi rajzot van egy táp jumper... de mérd ki a te kínai paneleden hová megy a tüskesor 2-ről a kanóc...
Vagy ha avrdude, akkor kattogtatós felület: https://blog.zakkemble.net/avrdudess-a-gui-for-avrdude/
Következő: »»   828 / 840
Bejelentkezés

Belépés

Hirdetés
XDT.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem