- D1Rect: Nagy "hülyétkapokazapróktól" topik
- Luck Dragon: Asszociációs játék. :)
- Steven: Sokat utazó kávéfüggők ide!
- eBay-es kütyük kis pénzért
- sziku69: Fűzzük össze a szavakat :)
- droidic: EA GAMES – élő emberrel a supportban 2025 ben
- Magga: PLEX: multimédia az egész lakásban
- btz: Internet fejlesztés országosan!
- M0ng00se: Hardvert áruhitelre?
- sziku69: Szólánc.
Új hozzászólás Aktív témák
-
tototos
addikt
Én több hibát is látok. Először is ha egy tömb elemét akarod címezni akkor nem () kell hanem []
Valamint az strlen nem fogja megmondani neked a tömb méretét, csak egy string hosszát. Tömb méretet belekódolod a programba, mivel itt statikus foglalásról van szó teljesen járható út.
Másik hiba hogy az if után ha nem blokkosítod az utasításokat, akkor az összes kapacitást ki fogja írni, mert az if csak a névre lesz hatásra.main fv:
beolvas(&tomb(i)); helyett beolvas(&tomb);nagyobb fv:
void nagyobb(Pendrive *tomb, int size)
{
int i;for(i = 0; i < size; i++)
{
if(tomb(i).kapacitas > 2)
{printf("%s",tomb(i).nev);
printf("%i",tomb(i).kapacitas);
}
}
} -
izsom
újonc
Sziasztok valaki tudna esetleg segíteni hogy ebben mi lehet a hiba mert nem tudok rájönni!!
#include<stdio.h>
typedef struct{
char nev[51];
double kapacitas;
}Pendrive;void beolvas(Pendrive *adat)
{
printf("Adja meg a nevet: ");
gets(adat->nev);
printf("Adja meg a kapacitast: ");
scanf("%f", adat->kapacitas);
}void nagyobb(Pendrive tomb[])
{
int i;for(i = 0; i < (strlen(tomb)-1); i++)
{
if(tomb.kapacitas > 2)printf("%s",tomb(i).nev);
printf("%i",tomb(i).kapacitas);
}}
int main(void)
{
Pendrive tomb[2];
int i;for(i = 0; i < 2; i++)
{beolvas(&tomb(i));
}
// nagyobb(tomb);
return 0;
} -
buherton
őstag
válasz
alapz@j
#4796
üzenetére
Fordító speicifikus parancs/címke.
Például az avr-gcc-ben hogyha te egy karakter tömböt a flash-be akarsz letenni, akkor nem elég csak a const-t elérni, hanem külön meg kell mondani a fordítónak, hogy tegye oda (PROGMEM-et kell használni). De hogy a példánál maradjunk mostanában egy STM8-ra fejlesztek (a fordtó nevére nem emlékszem), ahol @-al kezdődő szavak fordító specifikus direktívák. Például, ha azt mondom a függvényre, hogy @near, akkor a lehető legközelebb fogja rakni a hívás helyéhez.
-
#4795
axioma
veterán
lockdown90
#4794
axioma
veterán
válasz
lockdown90
#4794
üzenetére
mert a j%3=9%3=0, azaz hamis; csokkenti, es a kov. forduloban jut csak el a print sorig.
-
#4793
axioma
veterán
lockdown90
#4792
axioma
veterán
válasz
lockdown90
#4792
üzenetére
A while(int) mukodese a kerdes? Az int i==0 az hamisat ero ertek, az osszes pozitiv egesz meg igaz. Ez eleg? Kicsit alulspecifikaltnak erzem a magyarazasi feladatot...
-
#4792
lockdown90
senior tag
lockdown90
senior tag
sziasztok! valaki esetleg el tudná magyarázni, hogy hogy jön ki az eredmény?
#include <stdio.h>
int main()
{
int i=9, j=1;
do{
j=i;
while(j%3){
printf("%d",j);
j--;
};
i--;
}while(i);
printf("\n"); system("pause"); return 0;
} -
buherton
őstag
A memcpy-nál, hogy ha ugyanazon memória területen másolok, akkor az működőképes lehet? Hogy érthetőbb legyen itt egy példa:
memcpy(&foo[0], &foo[1], (sizeof(foo) - 1));
MOD: a szabvány ezt mondja:
memmove is required to work correctly even if the source and destination
overlap, while memcpy can assume non-overlapping operands and be optimized accordingly.Akkor a memmove az én barátom.
-
tototos
addikt
válasz
kmisi99
#4786
üzenetére
hát itt van elég sok gond.
Ha egy függvény mutatót kér paraméternek akkor hiába írod oda, hogy double* még nem fogja átadni a változó címét.
Másrészt dekralálsz változókat a main-ben min és max néven. Majd ezeknek a címét akarod átadni a függvénynek, a függvényen belül meg ezeket a címeket akarod átírni a tömb elemeinek címére?
Döntsd el, hogy a maxot és mint szeretnéd külön tárolni, vagy elég ha a tömb bizonyos elemeire mutatnak a pointerek. -
#4788
axioma
veterán
lockdown90
#4784
axioma
veterán
válasz
lockdown90
#4784
üzenetére
Ezt ki a fene talalta ki? Baromsag ilyenekkel szivatni az embereket, sima egy valtozonal tudja az ertek es cim szerinti atadas kozti kulonbseget (na mondjuk azt se egy darab vegeredmeny eltalalasaval lehet ellenorzni), es maris felkeszult az eldontesere, hogy melyiket hasznalja. De ennek itt eppen semmi ertelme. Ilyet se irni, se olvasni nem fog senki valos kornyezetben, es sztem aki erti a ketto kozti kulonbseget, az is igen jo esellyel belehibazik foleg a fejben szamontartasba...
-
-
kmisi99
addikt
Lenne egy programom egy tömbben megadott számoknak kiírja a maximumát és a minimumát. A main függvény szinte teljesen adott volt. A minmaxot kellett megadni. A hiba az, hogy "too few arguments to function" az utolsó printf előtti sorban van ez a hiba, de pont annyi argumentum van amennyi kell szeirntem. Mi lehet a gond mit írjak át, hogy jó legyen? Itt a program #include<stdio.h>
void minmax( double tomb[10], double* mini , double* maxi) {
int i;
mini=&tomb[0];
maxi=&tomb[0];
for(i=1; i<10; i++){
if(tomb[i]>*maxi){
maxi=&tomb[i];
}
if(tomb[i]<*mini){
mini=&tomb[i];
}
}
}
int main(void) {
double t[] = {1.2, 2.3, 6.1, -3, -2.7, 2.7, 11.11, -20, 0.23, 4.1};
double min, max;
minmax(t, double* min, double* max);
printf("%lf\n%lf\n", min, max);
return 0;
} -
#4785
k.kristof
őstag
lockdown90
#4784
k.kristof
őstag
válasz
lockdown90
#4784
üzenetére
Az f() függvény egy paraméter értékével és kettőnek a címével dolgozik. Így lesz egy lokális másolata 4 értékkel, ezt megnöveli eggyel, és lesz két hivatkozása az x-re, amit csökkent eggyel, kétszer is. Ha jobban olvashatóan akarnád írni, akkor így nézne ki:
return i*(*k)*(*j);
-
#4784
lockdown90
senior tag
lockdown90
senior tag
sziasztok! tudnátok segíteni elmagyarázni, hogy itt a 2,20 hogyan jön ki?
#include <stdio.h>
int f(int i, int *j, int *k){
i++; (*k)--; (*j)--;
return i**k**j;
}
int main(){
int x = 4, y; y = f(x, &x, &x);
printf("%d,%d",x,y);
printf("\n"); system("PAUSE"); return 0;
}Köszönöm!
-
Doze
aktív tag
válasz
buherton
#4780
üzenetére
Jelentkezem megint (köszi a segítséget)
Am egyetemi feladat (nem progmatos az is biztos
), de most meg nem ír ki semmit?, a program lefut... az a baj nem vágom teljesen, szal holnapi vizsgára is agyig rakott puskával megyek...#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int matr[10][10];
void main (void)
{ int i,j,o,s;
clrscr();
printf("Adja meg a m trix sorjainak a sz m t: \n");
scanf("%d", &o);
printf("Adja meg a m trix oszlopainak a sz m t: \n");
scanf("%d", &s);
randomize();
for (i=0; i<o; i++)
for (j=0; j<s; j++)
matr[i][j]=random(100);
for (i=0; j<o; i++)
{
for (j=0; j<s; j++)
{
if ((matr[i][j]%2)==0)
{
printf("%d ",matr[i][j]);
}
}
}
printf("A matrix: \n");
for (i=0; i<o; i++)
{ printf("\n");
for (j=0; j<s; j++)
printf("%5d",matr[i][j]);
}
getch();
} -
dabadab
titán
"Adott egy M mátrix a nagyságát én adom meg, az elemeit pedig random töltöm fel... eddig el is jutottam"
Igazából nem. Lefoglalsz egy fix nagyságú mátrixot, aztán ha valaki egy nagyobbat ad meg, akkor simán felülírsz mindenféle memóriaterületet. malloc()-ról még nem volt szó?
"a páratlan elemeit ki kéne íratnom egy külön sorba..."
És ezen hol akadtál el? Nem tudtad eldönteni, hogy melyik páratlan?
szerk: ahogy látom, mások már mind megírták ezt
-
buherton
őstag
-
k.kristof
őstag
Igen. Elég, ha tizenegyet írok be, és máris túlindexeltem a tömböt, ami miatt segfaultolni fog.
#Karma: igazad van, ha a feladat megmondja, mi a maximális érték, akkor nem okoz bajt, de jó ha tudja, hogy mikre kell készülnie a való életben. Saját tapasztalat, hogy nagyon figyelni kell az ilyenekre
-
Karma
félisten
-
k.kristof
őstag
Szerintem:
for (i = 0; i < o; i++)
{
for (j = 0; j < s; j++)
{
if ((matrix[I][j] % 2) != 0)
{
printf("%d ",matrix(i)[j]);
}
}
}Végigmész a mátrix elemein balról-jobbra, fentről lefelé, és ha páratlan az elem, kiírod egy szóközzel. A kódban egyébként van egy komoly hiba: mi van, ha a felhasználó nagyobb számot ír be, mint a mátrix előre lefoglalt mérete?
-
Doze
aktív tag
Sziasztok! kéne egy kis segítség
Van egy feladatom amit meg kéne oldanom, de mivel elég sík vagyok hozzá elakadtam.
Adott egy M mátrix a nagyságát én adom meg, az elemeit pedig random töltöm fel... eddig el is jutottam, viszont a páratlan elemeit ki kéne íratnom egy külön sorba...
Itt a progi:
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int matr[10][10];
void main (void)
{ int i,j,o,s;
clrscr();
printf("Adja meg a m trix sorjainak a sz m t: \n");
scanf("%d", &o);
printf("Adja meg a m trix oszlopainak a sz m t: \n");
scanf("%d", &s);
randomize();
for (i=0; i<o; i++)
for (j=0; j<s; j++)
matr[j]=random(100);
printf("A matrix: \n");
for (i=0; i<o; i++)
{ printf("\n");
for (j=0; j<s; j++)
printf("%5d",matr(i)[j]);
}
getch();
} -
don_peter
senior tag
Sajnos azt kell mondanom, hogy nem.
Én is úgy akartam kezdeni mint ahogy leírtad és sorra szívtam vele...
Ezért is írtam, hogy magamból kiindulva ajánlom a saját környezet megépítését.
Egy meglévő nyákot nehezebb kiismerni és kötöttebb rá programozni..
De ezt úgy is csak az fogja megérteni aki foglalkozik vele.Én például ilyet készítettem:
-
tototos
addikt
Kicsit csatlakoznék mint informatikus diplomával rendelkező emberke. Tény, hogy az ember akkor tanul a legjobban ha tudja is mire írja programot mi hogyan működik. De sztem az arduinonak és más hasonló ilyen áramkörnek az a lényege, hogy kis efforttal már tudsz ledet villogtatni, anélkül hogy mindenféle kapcsolást megnéztél volna. Van olyan ember aki itt megáll, csak kipróbáűlta. Aki jobban érdekel a dolog az neki fog állni és kiegészítő saját kis áramkörrel, vagy elkezdi megismeri pontosan mi is van a nyákon és miért.
Én anno önálló laborként csak beágyazott szoftverfejlesztéssel foglalkoztam. Semmi hardver, tisztán csak szoftver használtam a gyári könyvtárakat és hittem a fejlesztőknek hogy jól csináltak mindent. Szakdogának már nyákot terveztem 0 előzetes tudással.
Amit én ajánlok az arduino mellé és sztem árban is nagyon baráti az egy Nucleo board
Kicsit drágább de nagyobb tudású vezérlővel: stm32f4-discovery
és már kijelzővel is ellátott csúcs stm32 mikrovezérlő: stm32f429i-discoveryFejlesztőkörnyezetnek lehet eclipse+gcc+openocd. De ahol ez összeintegrálva megtalálható az a CooCox környezetben. 1 éve használom és eddig minden szükséges dolgot megtaláltam benne.
-
Karma
félisten
válasz
don_peter
#4768
üzenetére
De nem egyszerűbb, ha az emberfia először lát egy ilyen rendszert működésben, amin a beágyazott programozás alapjait illetve egyszerűbb elektronikai illesztéseket gyakorolhatja? Aztán ha elég stabilnak érzi a talajt, lemásolja a kapcsolási rajzát vagy saját kútfőből épít sajátot?
dabadab egyébként jól megfogta az egyik gondolatom lényegét
Pont arra gondoltam. A szoftveres "luxus" hiánya (OS, driverek, stb.) szerintem gyorsan megugorható, fel se merült bennem, hogy valaki úgy akarna uC-t programozni. -
don_peter
senior tag
Az a baj, hogy ha valaki ilyen fejlesztői környezeten akar tanulni vagy dolgozni akkor minimum tisztába kell lennie egy pár alap elektronikai kérdéssel amelyek alapot adnak a további kiegészítésekhez melyek aztán szerepet játszanak majd a bonyolultabb fejlesztésekben.
buherton, itt is szépen leírta milyen egyéb alkatrészeket lehet beépíteni a tanuló nyákra, de én javaslom az elsőt úgy megépíteni, hogy a szükséges élesztésen kívül csak a felhasználható I/O lábak legyen kihozva tüskesorra.
Aztán későbbiekben bármit rá lehet aggatni könnyedén. -
don_peter
senior tag
válasz
dabadab
#4766
üzenetére
Szerintem buherton emiatt is említette, hogy az adatlapok nagyon jó olvasmányok és segítenek az ilyen kérdésekben is, de ha még sem, akkor még midig itt vagyunk mi
Egyébként már kevés olyan kapcsolás van amihez ne lenne segédletet találni a neten, hogy miként érdemes bekötni, milyen ellenállással vagy esetleg szűrőkondikkal.
De nem lenne akkor is: itt vagyunk mi vagy aki tud segíteni (ezért vannak az ilyen fórumok ) -
dabadab
titán
válasz
buherton
#4765
üzenetére
Szerintem Karmanak nem a driverekkel van problemaja, hanem azzal, hogy teljesen random* helyekre ellenallasokat, kondenzatorokat meg egyeb bigyokat kell kotni es ezeket mindenki olyan termeszetesnek veszi, mint a levegovetelt (es ennek megfeleloen nem is nagyon emlitik a szuksegesseguket)
*: nyilvan nem, meg en is szigorlatoztam elektronikabol, de ha barmikor szentte akarnak avatni, akkor azt a harmast nyugodtan felsorolhatjak a csodateteleim kozott
-
buherton
őstag
Az a baj, hogy ha beírod a gugliba, hogy ARM/NXP/ST/AVR/PIC development board-ra, akkor szívszédülést fogsz kapni az árak miatt. Egy kb semmit se tudó fejlesztő board 20-30-40-50k huf. Emiatt nagyon sokan adják a fejüket saját elkészítésére. Például. Viszont az való igaz, hogy elektronikát meg kell tanulni, mert enélkül hardveres problémákba ütközhet a programozó, mert itt mindent neked kell írni. Nincsenek driverek
. Kezdésnek ha megkérsz valakit, hogy építsen neked, akkor ilyen 10k huf alatti összegből kijössz. A hobbielektronika.hu-n jobban foglalkoznak ilyesmivel.MOD: és OS sincs, ami ütemezné a taskjaidat
![;]](//cdn.rios.hu/dl/s/v1.gif)
. Persze lehet ráírni. -
Karma
félisten
válasz
buherton
#4762
üzenetére
(És egyben don_peternek is válasz.)
Ez villamosmérnök végzettséggel (de gondolom már műszerész/villanyszerelő szakmával szintén) biztosan nem nagy kunszt; de tisztán szoftveres háttérrel, no meg esetemben az informatikus diplomámmal, azzal az egy félévnyi elektronika tárggyal és egy darab mérés laborral - ahol kész sablon alapján össze kellett pakolni breadboardon két áramkört -, azért nem ennyire triviális.
Nyilván meg lehet tanulni a digitális áramkör építést is, jó szakirodalommal vagy mondjuk kompetens ismerőssel. Én csak annyit akartam mondani, hogy szerintem nem ördögtől való, ha kulcsrakész hobbi platformot vesz.
Ha meg élesben is ezzel akar foglalkozni, akkor a Ti hozzáállásotok követendő, természetesen.
-
don_peter
senior tag
Két kis kezeddel, nekiállsz és megtervezed megépíted magadnak a hardvert.
Ennyire egyszerű..
Ott a nyáktervező csak vonalakat kell húzni....
Ami meg nem megy megkérdezi, mit hogyan kössön be.
Aztán ha elkészítette még mindig be tudja ide tenni, hogy ellenőrizzük, hogy nincs e elkötés.
Én is megépítettem 0 hozzáértéssel és sok segítséggel.
Ha nincs ennyi szorgalom akkor ne is haragudj, de felesleges elkezdeni.
Magamról tudom, hogy nagyon sokat kellett olvasnom minden egyes kis dolog után, hogy megértsem annak működését és még így is marad fekete folt.
Amit meg nagyon nem értek rákérdezek, még ha ostoba is a kérdés.Annyi előnye van, hogy van tapasztalata C programozásban.
Nekem az sem volt -
buherton
őstag
Az uC-re úgy kell tekinteni, mint egy mezei digitális áramkörre kapcsolás tervezésnél. Ha speciális interfészeit akarod használni, akkor az adatlapban megtalálsz mindent. A legnehezebb a próba panel esetén, hogy mi kerüljön rá? Aztán a tervezés már nem probléma. Amit ajánlani szoktam az a 2-3 kapcsoló, 2-3 nyomógomb (természetesen Schmitt triggerelve), LCD kijelző, 2 7 szegmenses (ezt én shift regiszterrel szoktam meghajtani, amit aztán SPI-al hajtok meg), 8 LED, RS-232, I2C-s EEPROM, SPI-s hőmérséklet érzékelő, Egy LED az egyik PWM kimenetre, a másik PWM-re pedig egy Darlington-ba kötött transzisztor pár, 32 kHz-es kvarc az RTC-nek, egy poti az egyik ADC-re. Ha tud az uC USB-t, akkor értelemszerűen azt is kivezetm. Ahogy a kolléga mondta, minden uC lábat tüskesorozni kell. Ahogy látod ezenek a nagy része sima GPIO lábra kerül, csak az EEPROM, SPI és a soros port a speciális, mert azok kommunikációs lábakra kerülnek.
Tessék olvasgatni az adatlapokat.
-
don_peter
senior tag
válasz
Dave-11
#4753
üzenetére
Magamból kiindulva azt tanácsolom, hogy ne használj semmilyen előre legyártott kittet.
Kezdésnek szerezz minimum annyi tapasztalatot, hogy saját magadnak megépíts egy olyan gyakorló nyákot amelyen a Mikrochip minden használható lábát kivezetsz tüske sorra.
Természetesen úgy kell megépíteni, hogy az azonnal éleszthető legyen tehát az egyéb áramköröket és programozói felületet integrálnod kell az elején.
Én mint kezdő ezt tanácsolom, nagy segítség a tanulásban illetve a fejlesztéseknél és már megismerkedsz a PORT-okkalCsak, hogy ajánljak is valamit ami olcsó és jó az a PIC...
Ingyenes nyáktervező: Sprint Layout
-
Karma
félisten
válasz
buherton
#4758
üzenetére
"Bármi is legyen a döntésed a használt program nyelv a C legyen. Van Basic meg Arduino, meg mit tudom én mi, de az igazi beágyazott rendszer fejlesztő C-ben dolgozik..."
Az Arduino is C, nem írtak hozzá külön nyelvet, csak van egy kezdőbarátabb bootloader és alapkönyvtár. Igazából technikai akadálya nincs annak, hogy valaki átflashelje és nyersen használja.
-
buherton
őstag
válasz
Dave-11
#4753
üzenetére
Szia!
Az első és legfontosabb dolog az angol nyelvtudás. A nélkül csak a magyar fórumokra és cikkekre hagyatkozhatsz, ami nem túl sok.
El kell döntened, hogy hobbi célból vagy komolyabban szeretnél-e ezzel foglalkozni.
Ha komolyan akarsz ezzel foglakozni, akkor csak is az ARM jöhet szóba. Ezt csak ajánlani tudom, mert amit megírsz az menni is fog. Ezen kívül még annyi költség merül fel, hogy a perifériákat megvedd. A NYÁK-on minden elő van készítve, így ha pl. Ethernetet akarsz rákötni, akkor csak a csatlakozó kell. Az USB dettó. Van rajta minden ami kellhet. Sőt a debuggerrel bármilyen NXP ARM-t programozhatsz! Van hozzá gcc fordító fork, és egy Eclipse CDT IDE fork. Mind a kettő ingyenes.
Ha hobbi szinten szeretnél foglakozni, akkor három gyártó jöhet szóba. A Parallax, Atmel, és a Microchip. A Parallax-nak azaz érdekessége, hogy 8 mag van benne. Egyáltalán nem bonyolult, de sajnos saját nyelve van, illetve kevésbé ismert. Az Atmel és a Microchip nagyjából egyszinten van. Van amiben egy jobb, van amiben a másik. A hobbielektronikán elég sok hsz-n keresztül ment a flame war, hogy melyik a jobb.
Az Atmel-t választottam, mert nem vagyok fordítóhoz, és fejlesztő környezethez kötve. Ugyanis az AVR-nek ugyanúgy van gcc forkja, és azt bármilyen univerzális fejlesztő környezetben használni. LUFA project néven készült egy AVR ISP mkii klón, ami szinte teljesértékű a gyári programozóval. Továbbá az Atmel biztosította, hogy otthon is utána építhető lehessen az AVR JTAG, amivel már debuggolni is lehet a cuccot. A Microchip pozitívuma, hogy bárhol beszerezhető, és a PICkit 2 elég sok mident tud debuggolni. Ami viszont nem tetszik, hogy a fordítóval nincsenek jó emlékeim, és még gcc fork sincs belőle (nem véletlenül?), az IDE viszont nem rossz, de szinte esélyed sincs másikat használni annyira egybe integrálták az egészet. Ez is a PIC-el a legnagyobb problémám, hogy teljesen zárt. Nincs semmilyen szabadságod.
Bármi is legyen a döntésed a használt program nyelv a C legyen. Van Basic meg Arduino, meg mit tudom én mi, de az igazi beágyazott rendszer fejlesztő C-ben dolgozik, és ha a jövőben ebben szeretnél dolgozni, akkor ebben kell majd.
MOD: Az AVR-nél mindent meg lehet otthon építeni, de szerintem ugyanez vonatkzoik a Microchipre is. Ha drágállod a gyári megoldásokat, akkor érdemes az eBay-en körül nézni a klónok után
.MOD2: Minden gyártó ad ki egy adatlapot a termékéhez. Abban minden fontosabb infót megtalálsz. Természetesen angolul íródtak. Rengeteg példa kód elérhető a neten.
-
Karma
félisten
válasz
Dave-11
#4753
üzenetére
Van valami konkrét elképzelésed, hogy milyen platformmal szeretnél dolgozni, vagy milyen végcéllal?
Mert ha például csak hobbicélból, akkor az Arduino projekt (AVR) elég népes közösséggel és mindenféle alaplappal, kiegészítővel és libek tengerével rendelkezik.
Rengeteg webshop is foglalkozik vele, úgyhogy rendelni nagyon sok helyről lehet. Itthon a FabLabról tudok csak, de külföldön a SparkFun, SeeedStudio, Adafruit, stb. mind elég jó szerintem.
Ezek a boltok általában saját/közös leírásokkal, blogokkal is rendelkeznek, úgyhogy mindenképp megéri böngészni ismeretszerzés gyanánt is.
-
Dave-11
tag
Bocsi ha terhelem ezt a topikot, de itt írogattatok ezzel kapcsolatban, meg nem tudom hogy itt PH-n belül hol kérdezhetném meg még ezt máshol. Szóval:
Nyáron ha lesz egy kis időm szeretnék elkezdni kicsit foglalkozni a mikrokontrollerekkel, és ehhez szeretnék egy kis segítséget kérni. Hol tudok ilyen cuccokat vásárolni/rendelni, hol tudok valami tényleg hasznos anyagot hozzá olvasni, vagy ha videó akkor nézni.
Programozási ismereteim vannak már C-ben és C++-ban is, de így gyakorlatban még nem raktam össze semmi hasonló cuccot.
Előre is köszi! -
don_peter
senior tag
Srácok, írt már valamelyikőtök korrekciós programot egy hőelem korrekciójára?
Omega K típusú szenzorom van aminek a jelét digitálisan egy MAX6675 IC dolgozza fel és továbbítja számomra is értelmezhető formában. (12bit)A kérdésem az lenne milyen elven tudnék korrekciós programot írni, hogy pontosabb mérést kapjak kisebb hőtartományban is?
Csak az elmélet érdekelne a programot megírom én...
Van ötletetek? -
dabadab
titán
válasz
alapz@j
#4750
üzenetére
Az a pont, ahol egy kifejezes teljesen ki van ertekelve, a Wikipediaban van konkret lista illetve a C FAQ-ban egy reszletesebb magyarazat.
-
buherton
őstag
Több példa is van, ahol a szabvány ezzel foglalkozik pl.:
sum = sum * 10 - '0' + (*p++ = getchar()); ennél a példánál sem egyértelmű, hogy mikor fog inkrementálódni a p mutató. Az okot nem írja csak a szekvencia pontokra hivatkozik.Az ilyenek valóban kerülendők, ezért sem találkoztam még soha ilyen warning üzenettel.
(#4747) Jester01: Sose próbáltam lefordítani, de ez tök jó, hogy a fordító figyelmeztet. gcc?
-
axioma
veterán
válasz
buherton
#4746
üzenetére
Akkor nekem anno hulyeseget tanitottak... en ugy tudtam, hogy az i++ azt jelenti, hogy az adott sorban levo minden mas muvelet utan kell az i=i+1-et erteni, a ++i-nel meg ugyanezt az (ezen muvelettol megfosztott) sor ele. Ez siman eldontene a dolgot ebben az esetben is (azt ertem, hogy csak a ketszer i-nek ertekadasnal van gond, altalanos esetben igaz lesz). Igazabol nem is tudom elkepzelni, hogy mi az az indok, amiert a ford.pr-nak jobb ha nem tartja ezt ebben a spec. esetben is be, de biztos oka van.
Mas kerdes, hogy nem tunik amugy se jo gyakorlatnak semmi olyan kodsort leirni, ami nem ranezesre egyertelmu, hogy mit fog csinalni. Raadasul ez csak 2 sort von ossze egybe, nem egy nagy kaland kiirni, biztositani az elkepzeleseknek megfelelo sorrendet. -
buherton
őstag
válasz
buherton
#4730
üzenetére
Majd elfelejtettem.
Előre bocsátom, hogy ez az egyik legszemetebb teszt kérdés a C-ben. Ugyanis ehhez jól kell ismerni a C szabványt, mert abban van leírva, hogy "két szekvencia pont között ha egy változónak egynél többször adunk értéket, akkor nem definiált a működés", azaz nem tudjuk biztosra megmondani, hogy mi lesz az eredmény, mert fordító függő lesz.
Ismerősöm állás interjún kapott egy ilyen feladatot, de volt ám meglepetés, amikor elkezdte mondani a fentebbi szöveget, ugyanis az interjúztató nem tudott erről
. Így nem kell bánkódni azoknak akik nem tudták. Egy évvel ezelőtt én se tudtam volna a helyes választ. -
buherton
őstag
A lényeg azaz lenne, hogy egy egyszerű mikrokontrolleres környezetet akartam kialakítani a PC-n, hogy ne a a hardveren kelljen szenvedni. Viszont nem rossz ötlet, csak kérdés, hogy Linux engedi-e, hogy egyszerre két program kezelje a soros portot (windowson biztosan nem), de ez már más topic.
-
Karma
félisten
válasz
buherton
#4742
üzenetére
Ilyenről szabványos környezetben nem tudok, de ha a soros portig eljutás kell csak, irányítsd Windowson a comX-re a forgalmat, Linuxon meg a /dev/ttySX-re (ahol X a port száma).
Keresgéltem még egy kicsit, egyre inkább úgy tűnik, hogy a FILE*-ot nem lehet csak úgy helyettesíteni, ez valami avr-gcc sajátosság.
-
buherton
őstag
A probléma egy kicsit összetettebb, mert az avr-gcc, ezt tudja:
static FILE mystdout = FDEV_SETUP_STREAM(usart_putchar_printf, NULL, _FDEV_SETUP_WRITE);
int main( void )
{
stdout = &mystdout;
printf("Hello world");
}
void usart_putchar_printf(char data, FILE *stream)
{
bájt küldése soros porton
}és ezt szerettem volna elérni a PC-n is, hogy végül egy függvényt hívjon minden karakter kiíráskor.
-
-
alapz@j
tag
-
alapz@j
tag
Egy érdekes problémába botlottam, ami három különböző fordítóval is előjön, szóval a kódban lehet a hiba, de nem tudom, hogy mi.
#include <stdio.h>
int main(void) {
char date[] = "2014/05/01";
int year, mon, day;
int res = sscanf(date, "%i/%i/%i", &year, &mon, &day);
printf("%i\n", res);
return 0;
}Ez így jól működik, a res-be három kerül, mert három értéket sikerült beolvasnia a sscanf-nak. De ha a hónapot átírom 08 vagy 09-re akkor azt már nem ismeri fel. Minden más értékre működik. Ha sima 8-at vagy 9-et írok, megint működik. Szerintetek?
-
-
buherton
őstag
válasz
don_peter
#4728
üzenetére
A watchdog használata nem a kód minőségétől függ, hanem a életben előforduló véletlenektől. Ha biztosra szeretnél menni a programod működése szempontjából, akkor használsz watchdogot, mert nem tudhatod, hogy az adott eszköz milyen behatásoknak lesz kitéve, illetve mikor fog az uC tévedni. Ezekre a kihatásokra csak részben lehet felkészülni szoftveres és hardveres oldalról, és a watchdog sem jelent mindenre megoldást, de az legalább a nagy részét lefedi.
-
don_peter
senior tag
válasz
dabadab
#4727
üzenetére
Lesznek még félreérthető kérdéseim...
Nézzétek el nekem.
Tanulok belőlük.. (legalább is remélem )buherton:
watchdog-ot én is ismerem, és úgy kell megírjam a programot, hogy ezt ne keljen alkalmazni.
És természetesen úgy kell majd megterveznem és megépítenem, hogy ne legyen semmilyen olyan zavar ami kiválthatna egy akadást.
Tehát nem szabad beakadnia a program futásának, főként nem akkor amikor forraszt majd a gép.
Atom biztosan kell mennie. -
buherton
őstag
válasz
don_peter
#4725
üzenetére
Örülök, hogy meg lett. Nem ez lesz az utolsó memória elírásod. Sajnos ez tapasztalat
.Viszont ha már szóba került, akkor a watchdogot tényleg állítsd be. A watchdog egy speciális timer, ami ha lejár, akkor pl. csinál egy szoftver reset-et és ezzel újraindul az uC. Ez akkor jön jól, ha pl. viharban kap egy tüskét a cucc és beakasztja a futást. Ekkor a timer lejár és már reseteli is. Többféle alkalmazási technikája is van a WD-nek, de az általános azaz, hogy induláskor inicializálod a WD-t, majd valamelyik ciklikus "task"-ban reseteled a timer-t, ezzel megakadályozod, hogy lejárjon a timer.
-
don_peter
senior tag
Igen, igen igazad van.
Erre gondoltam én is, csak rosszul fejeztem ki maga.
A lényeg az, hogy az eredmény (arra amire nekem kellene) értékelhetetlen lenne az utóbbi megoldást használva.buherton:
Közben rájöttem, hogy a memória címzés miatt csúszott el durván az egész beírás.
Most már megy szépen minden oda ahová kell.
2óra debug kihozta a hibát -
don_peter
senior tag
válasz
buherton
#4712
üzenetére
Igen PIC18F4550-et használok amelynek azért tágasabb a felhasználható memóriája..
A régebben felmerülő tömb problémát megoldottam már szóval az oké..."SSPCON1"
Azért írtam meg bitenként a beállítást, hogy megtanuljam és mindig, ha vissza keressem értsem mit miért állítottam be.
Nekem így átláthatóbb mint ha egy sorba a 8bit-et állítom.
Ezek a beállítások egy init() függvényen belül vannak így nem zavarnak programozás közben, csak ide az átláthatóság miatt másoltam be...
De, ha már nem lesz rá szükség akkor 1bájtos parancsként fogom én is megírni a beállításokat."Az a probléma hogy a for cikluson belül olvas ki több lapot, vagy a while cikluson belül?"
Ezt a kérdést nem értem.
A kiolvasással nincs gond..még
A beírás nem oké.
A kiolvasásnál én állítom be mennyi sor olvasson ki az szerintem jól működik, de a beírás...A következőket vettem észre még tegnap esete:
Kíváncsiságból vissza olvastattam 100x32 byte-nyi területet és a következőket tapasztalom: (hátha rávilágít a hibára)
Minden 256-odik byte címzésénél 1 byte-tal kevesebbet írt be a memóriába és (32*8)*32 == (8192)byte után válik teljesen üres a memória.
Fura....Kipróbálom ez a "*(pbuf+i)=spi_io(0x00);" verziót.
Az a baj, hogy még a mutatókat nem látom át teljesen. -
buherton
őstag
válasz
don_peter
#4711
üzenetére
Bocsánat, nem tudtam, hogy ilyen PIC-et használsz. Valamiért egy PIC16 rémlett. 32 kB flash, 2 kB RAM már jobban mutat.
Pár észrevétel:
- SSPCON1 regisztert illetve a társait valahogy el lehet érni bájtként, és akkor nem bitekkel kell majmolni. Nem mellesleg ha jó a fordító, akkor ezeket nem optimalizálja ki és mindenegyes sor egy 2 bájtos parancs.
- *pbuf++=spi_io(0x00); -> ez így elég meredek. Inkább így
for (i=0; i < PMEMBLOCK; i++) {
*(pbuf+i)=spi_io(0x00);
}
és már mehet is a const az argumentumba és biztonságosabb is így, mert a memória címe nem változik.
- while(!SSPSTATbits.BF); -> lehet ilyeneket használni, de akkor tegyél bele watchdogot (ez önmagában ajánlott), vagy timeout-t, mert ezek nélkül a jövőben okozhat problémát.Az a probléma hogy a for cikluson belül olvas ki több lapot, vagy a while cikluson belül?
-
don_peter
senior tag
Uraim, kérnék egy kis segítséget, hátha észreveszitek azt amin én már simán átsiklok.
Hardver: (PIC18F4550 és 25LC640 memória IC)Csatoltam egy leegyszerűsített forrás fájlt.
KB. 3 napja kínlódom vele és nem jövök rá mért nem azt csinálja amit szeretnék.
A lényeg, hogy a memóriába szeretnék 1 32bájtos lapot beírni és ahelyett, hogy csak 1db 32bájtos lapot írna be a memória területre teleszemeteli a következő x*32bájtos területeket is.
Azért mondom, hogy következő x*32bájtos területeket, mert szabályosan emelve a memória címzést kiolvasható ugyan az mint amit elmentettem a 0-ás címre.
(8x32bájtig (256) egyformák a kiolvasott értékek, de mikor ugrik a 9x32bájtos (288) területre ott már 1bájtot csúszik visszafelé a memória címzés.)
Utóbbit csak említettem, de nem érdekes most.
Valaki esetleg látja azt a hibát ami ezt okozza?
Előre is köszi../*********************************************
+ K¸lsı f·jlok beemelÈse
**********************************************/
#include <p18F4550.h> //PIC be·llt·sa
#include <stdio.h>
#include <delays.h> //KÈsleltetÈsek
#include <stdlib.h>
#include "header.h" //¡lltal·nos header be·llÌt·sok
#include "p18f4550_pindef.h" //P18F4550 saj·t definiciÛim
#include "lcd.c" //LDC meghajt·s f¸ggvÈnyei
/*********************************************
+ DefinciciÛk deklar·l·sa
**********************************************/
//-------------------------- DefinciciÛk ----------------------------//
//PIC18F4550 SPI l·bkioszt·sa
//7. (RA5)[SS - SPI m·sodlagos input v·lasztÛ]
//33.(RBO)[SDI - SPI adat bemenet]
//34.(RB1)[SCK - szinkron Ûra be/ki SPI mÛdban]
//26.(RC7)[SDO - SPI adat kimenet]
#define SPI_CS_TRIS TRIS_A5 //A5 chip v·laszt·s
#define SPI_CS LAT_A5 //A5 chip v·laszt·s
#define SPI_SO_TRIS TRIS_B0 //B0-·s bit
#define SPI_SCK_TRIS TRIS_B1 //B1-es bit Ûrajel
#define SPI_SI TRIS_C7 //C7 adat ki
//-- A 25LC640 EEPROM ·ltal elfogadott parancsok
#define CMD_WRSR 0x01 //St·tuszregiszter Ìr·sa
#define CMD_WRITE 0x02 //Õr·s a megadott cÌmtıl kezdıdıen
#define CMD_READ 0x03 //Olvas·s a megadott cÌmtıl kezdıdıen
#define CMD_WRDI 0x04 //Letiltja az Ìr·st
#define CMD_RDSR 0x05 //St·tuszregiszter olvas·sa
#define CMD_WREN 0x06 //EngedÈlyezi az Ìr·st
#define PMEMBLOCK 32
/*********************************************
+ Union deklar·l·sa
**********************************************/
/*- 16bit-es UNION - (SPI memÛria cÌmzÈshez Ès 2 b·jtos (16bit-es) adatok t·rol·s·hoz kell)*/
typedef union _union16 {
unsigned int value;
struct {
unsigned char low;
unsigned char high;
};
} union16;
/*********************************************
+ PrototÌpusok
**********************************************/
void main(void); //Main()
unsigned char spi_io(unsigned char adat); //SPI Ìr·s olvas·s
void waitFor25LC640(void); //V·rakoz·s a SPI memÛri·ra
void memWrite25LC640(union16 MemCim, unsigned char *pbuf); //MemÛria Ìr·sa
void memRead25LC640(union16 MemCim, unsigned char *pbuf); //Meria olvas·sa
void main(void){
/*********************************************
+ V·ltozÛk deklar·l·sa
**********************************************/
union16 MemCim, ReadCim, AlsoFutes;
unsigned char Membuffer[PMEMBLOCK+1] = {0};
unsigned char x=0, i=0, z=0;
/*********************************************
+ LCD inicializ·l·s
**********************************************/
TRISD = 0;
lcd_init(); // Az LCD modulinicializ·l·sa
stdout = _H_USER; // Az LCD legyen a standard kimenetnt
/****************************LCD*************************************/
/*********************************************
+ SPI init
**********************************************/
SPI_CS_TRIS = 0; //A5-es l·b kimenet
SPI_CS = 1; //A5 l·b magas szinten
SPI_SO_TRIS = 1; //B0 l·b SDI bemenet
SPI_SCK_TRIS = 0; //B1 l·b SCK kimenet
SPI_SI = 0; //C7 l·b SI kimenet
SSPSTATbits.SMP = 0; //MintavÈtelezÈs idızÌtÈse Master mÛd esetÈn 1: mintavÈtelezÈs a kimeneti idı vÈgÈn, 0: mintavÈtelezÈs a kimeneti idı kˆzepÈn). Slave mÛdban kˆtelezıen null·ba kell ·llÌtani.
SSPSTATbits.CKE = 0; //”rajel f·zis·nak be·llÌt·sa (1: az adatkimenet be·llÌt·sa akkor tˆrtÈnik,amikor az Ûrajel aktÌv ·llapotbÛl tÈtlenre v·lt, 0: az adatkimenet be·llÌt·sa akkor tˆrtÈnik, amikor az Ûrajel tÈtlen ·llapotbÛl aktÌv szintre v·lt)
SSPSTATbits.BF = 0; //A buffer foglalts·g·t jelzı ·llapotbit (1: az adat·tvitel lezajlott, SSPBUF kiolvashatÛ, 0: az adatbuffer ¸res)
SSPCON1bits.WCOL = 0; //‹tkˆzÈs detekt·l·s Ìr·sn·l (1: Ìr·st/adatk¸ldÈst kÌsÈrelt¸nk meg, amikor nem lehetett, 0: nincs ¸tkˆzÈs)
SSPCON1bits.SSPOV = 0; //VÈteli t˙lcsordul·s-jelzı (1: ˙jabb b·jt Èrkezett, de SSPBUF meg nincs kiolvasva, 0: nincs t˙lfoly·s)
SSPCON1bits.SSPEN = 1; //Master Szinkron Soros Port engedÈlyezÈse (1: engedÈlyezve, 0: letiltva)
SSPCON1bits.CKP = 0; //”rajel polarit·sa (1: aktÌv ·llapotban alacsony szint, 0: aktÌv ·llapotban magas szint)
SSPCON1bits.SSPM0 = 0;
SSPCON1bits.SSPM1 = 1;
SSPCON1bits.SSPM2 = 0;
SSPCON1bits.SSPM3 = 0;
//BeÌ·r·s ut·n ki kell kommentelni-------------------------------------
/*Membuffer[0] = '#';
Membuffer[1] = 'D';
Membuffer[2] = 'P';
Membuffer[3] = 'T';
Membuffer[4] = 'P';
Membuffer[5] = ' ';
Membuffer[6] = ' ';
Membuffer[7] = ' ';
Membuffer[8] = ' ';
Membuffer[9] = ' ';
Membuffer[10] = ' ';
Membuffer[11] = ' ';
Membuffer[12] = ' ';
Membuffer[13] = ' ';
Membuffer[14] = ' ';
Membuffer[15] = ' ';
Membuffer[16] = ' ';
Membuffer[17] = ' ';
Membuffer[18] = 60;
Membuffer[19] = 61;
Membuffer[20] = 120;
Membuffer[21] = 62;
Membuffer[22] = 160;
Membuffer[23] = 63;
Membuffer[24] = 200;
Membuffer[25] = 64;
Membuffer[26] = 220;
Membuffer[27] = 65;
Membuffer[28] = 250;
Membuffer[29] = 66;
AlsoFutes.value = 500;
Membuffer[30] = AlsoFutes.low;
Membuffer[31] = AlsoFutes.high;
Membuffer[32] = '\0';
//2 memÛria blokk feltˆltÈse
MemCim.value = 0;
memWrite25LC640(MemCim, Membuffer);
//MemCim.value += PMEMBLOCK; //32
//memWrite25LC640(MemCim, Membuffer);
memset(Membuffer, 0, sizeof(Membuffer)); //Null·zzuk Membuffer-t
//BeÌ·r·s ut·n ki kell kommentelni------------------------------------
*/
//Kiolvassuk a memÛria tartam·t
MemCim.value = 0;
do{
memRead25LC640(ReadCim, Membuffer);
ReadCim.value += PMEMBLOCK;
for(i=0; i<PMEMBLOCK; i++){
if(Membuffer[i]=='#'){ z++; }
printf("%i - %02i - 0x%x ", x, ReadCim.value-PMEMBLOCK, ReadCim.value-PMEMBLOCK);
lcd_write(0xC0,0,1,1);
printf("Talalat(#): %i ", z);
lcd_write(0x94,0,1,1);
printf("H:%i - L:%i ", ReadCim.high, ReadCim.low);
lcd_write(0xD4,0,1,1);
printf("%i~%c ", i, Membuffer[i]);
lcd_write(0x80,0,1,1);
Delay10KTCYx(10);
}
memset(Membuffer, 0, sizeof(Membuffer));
x++;
}while(x<15); //Amennyi lapot akarunk, annyit olvasunk ki
Delay10KTCYx(100);
while(1);
}//main
/*********************************************
+ SPI 25LC640 memÛria
**********************************************/
unsigned char spi_io(unsigned char adat){
unsigned char tmp;
SSPSTATbits.BF = 0; // tˆrli foglalts·g jelzı ·lapot·t a st·tusz regiszterben
SSPCON1bits.WCOL = 0; // tˆrli az esetleges Ìr·s ¸tkˆzÈs hibajelzıt
tmp = SSPBUF; // tˆrli a BF jelzıbitet
SSPBUF = adat; // kirakja a kimenı adatot az SSPBUF regiszterbe
while(!SSPSTATbits.BF); // megv·rjuk a busz ciklus vÈgÈt
return (SSPBUF); // a vett b·jttal tÈr¸nk vissza
}
void waitFor25LC640(void) {
unsigned int flag;
do {
SPI_CS = 0; //kiadjuk a Chip Enable jelet
spi_io(CMD_RDSR); //St·tuszregiszter olvas·sa parancs
flag = spi_io(0x00); //Olvasunk, de valamit akkor is k¸ldeni kell!
SPI_CS = 1; //megsz¸ntetj¸k a Chip Enable jelet
} while (flag & 0x01);
}
void memWrite25LC640(union16 MemCim, unsigned char *pbuf) {
unsigned char i,flag;
waitFor25LC640(); //V·runk, ha az EEPROM elfoglalt
SPI_CS = 0;
WriteSPI(CMD_WREN); //Õr·s ˙jraengedÈlyezÈse
SPI_CS = 1;
Delay10KTCYx(1);
SPI_CS = 0;
spi_io(CMD_WRITE); //Adatblokk Ìr·sa
spi_io(MemCim.low);
spi_io(MemCim.high);
for (i=0; i < PMEMBLOCK; i++) {
spi_io(*pbuf++); //Az adatbuffer kiÌr·sa
}
SPI_CS = 1;
}
void memRead25LC640(union16 MemCim, unsigned char *pbuf) {
unsigned char i;
waitFor25LC640(); //V·runk, ha az EEPROM elfoglalt
SPI_CS = 0;
spi_io(CMD_READ); //Adatblokk olvas·sa
spi_io(MemCim.low);
spi_io(MemCim.high);
for (i=0; i < PMEMBLOCK; i++) {
*pbuf++=spi_io(0x00); //Olvasunk, de valamit akkor is k¸ldeni kell!
}
SPI_CS = 1;
} -
Karma
félisten
válasz
alapz@j
#4708
üzenetére
Szerintem az lenne a pláne, ha lenne const char *-os konstruktor (ez heapre másol) és egy char *-os ami átveszi a tulajdonjogot a stringről, és döntse el a kóder hogy melyik releváns.
De egyébként mi az C-ben, hogy konstruktor?
Ha tényleg C-ről van szó, akkor semmi se gátol meg abban, hogy a függvények neve is tükrözze hogy mit csinál a pointerrel. -
alapz@j
tag
válasz
buherton
#4707
üzenetére
Van egy string könyvtáram, ahol a String típus egy struktúra, amiben egy char* változó mutat a tényleges karaktersorozatra. Hogy a felhasználónak ne kelljen még plusz a memóriakezeléssel is bajlódnia, a sztringek mutable-ként működnek, úgy, hogy a függvények új memóriaterületet allokálnak az eredménynek, a régi területet pedig felszabadítják free-vel Ez ugye a felhasználó számára nem látszik, mert ő mindig ugyanazt a String változót látja. A konstruktor függvény első verziója egyszerűen felvette a felhasználó által megadott char* értéket. Ez viszont nem jó, mert ha a stack-en van a karaktersorozat (és nem static), akkor ugye az megsemmisül, ha char* x = "x" formában definiált volt, akkor az r/o memóriaterületen van és az első free-nél kiakad a rendszer, stb. Úgyhogy a jelenlegi konstruktor duplikálja a karaktersort a heap-re, ami csak annyiban rossz, hogy ha már eredetileg is ott volt, akkor kétszer annyi memóriát használ a program. Az lenne a legelegánsabb megoldás, ha a konstruktor érzékelné, hogy a paraméter a stack-re, r/o területre vagy a heap-re mutat és ennek megfelelő memóriafoglalási stratégiát választana.
-
buherton
őstag
válasz
alapz@j
#4706
üzenetére
Miről van szó amúgy? ARM-nál szintek vannak meghatározva, ahol a supervisor mindent megtehet, de ha egy user szintű akar oda írni, ahova nem lenne szabad, akkor ezt hard fault expection-nel köszöni meg a proci. Azaz itt az architektúra tartatja be a szabályokat. Továbbá az MPU-nak meg lehet mondani, hogy ki hova írhat, de az megint egy másik tészta.
Nem mellesleg a C standard nem beszél ilyenről, így ilyen nincs. Az, hogy az OS vagy az architektúra támogatja-e az már a C-n kívül álló dolog.
-
dabadab
titán
), de most meg nem ír ki semmit?, a program lefut... az a baj nem vágom teljesen, szal holnapi vizsgára is agyig rakott puskával megyek...
Pont arra gondoltam. A szoftveres "luxus" hiánya (OS, driverek, stb.) szerintem gyorsan megugorható, fel se merült bennem, hogy valaki úgy akarna uC-t programozni.
![;]](http://cdn.rios.hu/dl/s/v1.gif)
. Persze lehet ráírni.
Ha tényleg C-ről van szó, akkor semmi se gátol meg abban, hogy a függvények neve is tükrözze hogy mit csinál a pointerrel.Új hozzászólás Aktív témák
Hirdetés
● olvasd el a téma összefoglalót!
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- ÁRGARANCIA! Épített KomPhone Ryzen 7 9700X 32/64GB RTX 5070 12GB GAMER PC termékbeszámítással
- SzoftverPremium.hu
- HPE Apollo 4200 Gen9 2U rack szerver, 1x E5-2620v4, 64GB RAM, 24x3.5" 2U-ban! ÁFA-s számla, garancia
- ÁRGARANCIA!Épített KomPhone Ryzen 5 7600X 32/64GB RAM RX 7800 XT 16GB GAMER PC termékbeszámítással
- BESZÁMÍTÁS! ASUS H610M I5 12400F 32GB DDR5 512GB SSD X 4060 8GB SPIRIT OF GAMER CLONE 3 Chieftec600W
Állásajánlatok
Cég: Promenade Publishing House Kft.
Város: Budapest
Cég: CAMERA-PRO Hungary Kft
Város: Budapest