- Apple MacBook
- Kormányok / autós szimulátorok topikja
- Radeon RX 9060 XT: Ezt aztán jól meghúzták
- Milyen notebookot vegyek?
- Androidos tablet topic
- Fujifilm X
- Vezetékes FEJhallgatók
- Azonnali alaplapos kérdések órája
- Dual Mode-os IPS monitorral adott magáról életjelet a Gigabyte
- Szünetmentes tápegységek (UPS)
Új hozzászólás Aktív témák
-
pmonitor
aktív tag
válasz
dabadab
#6301
üzenetére
De pl. az egymásba ágyazott ciklusokból való kiugrást nem tudták goto nélkül megoldani. Pl. ez is változott, ha a nyelv jelentős mértékben nem is.
Meg nem véletlenül kezdi úgy a bevezetését, hogy a "sokat szidott goto utasítást". Már akkor sokat szidott volt. Még C-ben is!
-
pmonitor
aktív tag
válasz
dabadab
#6299
üzenetére
Mi nem érthető azon, hogy "Elméletileg a goto-ra soha sincs szükség, és gyakorlatilag majdnem mindig egyszerűen programozhatunk nélküle is."
És mikor írta ezt a könyvet?
Egyébként a ciklust is meg lehet írni goto nélkül(bár az azért 1 kicsit bonyolultabb, de megoldható). Pl. ezt sem vették figyelembe. Azóta már sok minden változott, még ha alap könyvről is van szó. -
pmonitor
aktív tag
válasz
dabadab
#6249
üzenetére
Ha a 300-301. sorban látod, hogy goto out; , akkor honnan tudod, hogy az hova ugrik? "Csak" 170 sort kell lejjeb "tekerned", hogy megtudd, hogy az out mit csinál. Addig csak sejtheted(a neve alapján).
@jattila48:
Nem csúsztattam. Az egyértelműen látszott, hogy dabadab mellett vagy. De az is igaz, hogy a #6216-ban ezt írtad:
A #6179 példa valóban jó, de dabadab kritikájában is van azért igazság, annál is inkább, hogy ennél az egyszerű szerkezetű példánál sokszor bonyolultabb a vezérlésszerkezet, amit nem lehet ilyen szépen struktúrálttá alakítani.Ezért nem csúsztatás, amit írtam. Ez nem az az eset, hogy túl finoman fogalmaztál, hanem egyértelműen elismerted, hogy ez egy szép, struktúrálttá alakított kód. Csak most változtattad meg a véleményed.
Egyébként nem csak téged nézett le, hanem a felsorolásból kihagytam Livius-t és nevemfel-t. Legalábbis itt a topic-on belül. Nézd meg légyszíves nevemfel #6199-es hsz-ét.
És ki tudja, hogy hány embert nézett le az olvasók között. -
pmonitor
aktív tag
válasz
dabadab
#6240
üzenetére
Az, hogy mennyire olvasható, az nagyon szubjektív dolog. A következő példát mondom rá:
#6216 hsz-ében jattila48 is elismerte, hogy a szóban forgó kód jobb, mint a tiéd. Pedig a te oldaladon állt, mert azt írta, hogy:
>A #6179 példa valóban jó, de dabadab kritikájában is van azért igazságEz egyértelműen tükrözi, amit az előbb írtam. Na ennyire szubjektív, hogy 1 kód mennyire "jó"(a te szavad járása szerint). Aki melletted van, még ő is azt mondta, hogy a szóbaforgó kód jó.
Zárójelben jegyzem meg, hogy szerintem ha csak az olvashatóságot nézzük, akkor az én 2 return-os kódom a legolvashatóbb. Mert a return egyértelműen jelzi, hogy itt nincs mese, kilépés van a függvényből.
De mint mondtam, ez nagyon szubjektív dolog.
-
pmonitor
aktív tag
-
pmonitor
aktív tag
válasz
dabadab
#6236
üzenetére
A fenti példád nem mutatta meg. Csak sajnos nem én mutattam rá(elkapkodtam a dolgot), hanem a munka oroszlánrészét #6172-ben Livius végezte el(ő használta legjobban a szürkeállományát). És #6179-ben nevemfel tette fel az i-re a pontot. Azt, hogy hogy kell az ilyent megcsinálni. A kódod azt mutatta meg, hogy hogyan ne.
-
pmonitor
aktív tag
válasz
dabadab
#6165
üzenetére
Stroustrup írta:
>A "soha ne tegyük ezt" alakú szabályokat haszontalannak tekintem.Ez általában igaz, viszont teljesen nem értek vele egyet. Hozzátenném, hogy azért nem ilyen sok van. 2 fő ökölszabály viszont biztos létezik a programozásban:
1.: SOHA ne használjunk gotot. A Szekvencia - Szelekció - Iterácó hármassal mindent meg lehet oldani. Nincs szükség goto-ra.
2.: Ha van egy típus, és létezik hozzá olyan függvény/metódus, hogy a konvertál(string s) az adott típusra alakítja a stringet, akkor ezt a konvertál() függvényt/metódust MINDIG használni kell, mielőtt műveletet végzünk vele. -
pmonitor
aktív tag
-
nevemfel
senior tag
válasz
dabadab
#6178
üzenetére
Ez se okés így? :
static int kvm_vcpu_check_block(struct kvm_vcpu *vcpu)
{
int ret = 0;
int idx = srcu_read_lock(&vcpu->kvm->srcu);
if (kvm_arch_vcpu_runnable(vcpu)) {
kvm_make_request(KVM_REQ_UNHALT, vcpu);
ret = -EINTR;
} else if (kvm_cpu_has_pending_timer(vcpu)) {
ret = -EINTR;
} else if (signal_pending(current)) {
ret = -EINTR;
}
srcu_read_unlock(&vcpu->kvm->srcu, idx);
return ret;
} -
pmonitor
aktív tag
válasz
dabadab
#6175
üzenetére
Így?
static int kvm_vcpu_check_block(struct kvm_vcpu* vcpu)
{
int ret = 0;
int idx = srcu_read_lock(&vcpu->kvm->srcu);
int ex = 0;
if (kvm_arch_vcpu_runnable(vcpu)) {
kvm_make_request(KVM_REQ_UNHALT, vcpu);
ret = -EINTR;
ex = 1;
}
if (!ex && kvm_cpu_has_pending_timer(vcpu))
{
ret = -EINTR;
ex = 1;
}
if (!ex && signal_pending(current))
{
ret = -EINTR;
}
srcu_read_unlock(&vcpu->kvm->srcu, idx);
return ret;
} -
pmonitor
aktív tag
válasz
dabadab
#6171
üzenetére
De sztem ki lehet az ilyeneket szervezni az ilyent külön függvénybe, és akkor tovább egyszerűsíthető. Azért a gyakorlatban ilyen nem nagyon fordul elő. A papír(vagy a monitor
) mindent elbír.Szerk.: ja látom Livius gyorsabb volt. Mondtam, hogy csak szervezés kérdése. Csak nem én szerveztem jól.
-
Livius
őstag
válasz
dabadab
#6169
üzenetére
Én ilyenkor inkább így szoktam:
static int kvm_vcpu_check_block(struct kvm_vcpu *vcpu)
{
int ret = 0;
int idx = srcu_read_lock(&vcpu->kvm->srcu);
if (kvm_arch_vcpu_runnable(vcpu)) {
kvm_make_request(KVM_REQ_UNHALT, vcpu);
ret = -EINTR;
}
if (kvm_cpu_has_pending_timer(vcpu))
{
ret = -EINTR;
}
if (signal_pending(current))
{
ret = -EINTR;
}
srcu_read_unlock(&vcpu->kvm->srcu, idx);
return ret;
}Persze ekkor az nincs lekezelve, hogy a többi if-et kihagyja a returnbe érés előtt, ez kérdés szabad-e ebben a Linux driverben.
-
pmonitor
aktív tag
válasz
dabadab
#6169
üzenetére
Ha minden igaz így hirtelen:
static int kvm_vcpu_check_block(struct kvm_vcpu *vcpu)
{
int ret = -EINTR;
int idx = srcu_read_lock(&vcpu->kvm->srcu);
if (kvm_arch_vcpu_runnable(vcpu)) {
kvm_make_request(KVM_REQ_UNHALT, vcpu);
srcu_read_unlock(&vcpu->kvm->srcu, idx);
return ret;
}
if (kvm_cpu_has_pending_timer(vcpu) || signal_pending(current)) {
srcu_read_unlock(&vcpu->kvm->srcu, idx);
return ret;
}
ret = 0;
srcu_read_unlock(&vcpu->kvm->srcu, idx);
return ret;
} -
pmonitor
aktív tag
válasz
dabadab
#6165
üzenetére
> vagy minden helyre külön odakopipészteled a felszabadítást, vagy mindenhonnan a végére gotozol.
Mindenképpen mindenhová kell kopipésztelned vagy a gotot, vagy a felszabadítást. De sztem. ha ilyenre sor kerül a gyakorlatban, ott nem jól tervezték meg a logikai hálózatot. Biztos vagyok benne, hogy a megfelelő if-ek megválasztásával ha nem is teljesen, de nagyon nagy mértékben megszüntethető a sok helyről történő kilépés a függvényből. Max. 2 helyre nyugodtan lehet kopizni a felszabadítást is. De az is lehet, hogy megfelelő szervezéssel még a 2 helyet is le lehet redukálni egyre(de erre a fejemet nem teszem).
-
Livius
őstag
válasz
dabadab
#6165
üzenetére
A mi C-ben írt CVI projektünkben egyelőre még ez a +10 év alatt jól volt kezelve az ilyen, hogy nincs szükség sehol calloc vagy malloc-ra és azok felszabadítására, tehát amit írsz példát nincs szükségünk rá nagyon, de ettől független láttam már benne go to-t olyan helyen, ahol csak a megértést nehezítette, de azt amit írsz előnyt semmit sem adott.
-
kovisoft
őstag
válasz
dabadab
#6092
üzenetére
Pont hogy akkor még akár jó is lehetne, mert ugyan a külső do...while-ra nincs szükség, de nem is okoz gondot, ha pontosan 1x lefut. És helyes for esetén egy while (i==999) feltétellel csak 1x futna le, mert mire ideér a vezérlés, az i értéke 1000 lesz, tehát kilép a do...while-ból.
Persze nyilván baromság így, írtam is, hogy fölösleges a do...while, csak arra akartam felhívni a figyelmét, hogy keveri az értékadást (=) és az egyenlőségvizsgálatot (==).
-
#6061
borisz1994
csendes tag
dabadab
#6059
borisz1994
csendes tag
válasz
dabadab
#6059
üzenetére
Köszönöm a válaszokat. Azt hiszem kezdem érteni. Mindenképp beleolvasok az ajánlott könyvbe hátha könnyebb megértenem.
A függvényeket a program elején dekralárni kell? Nekem ez jött még le abból a kevésből amin sikerült átrágnom magam.
Persze csak ha ez függvény deklaráció :)int pelda(int); -
CPT.Pirk
Jómunkásember
válasz
dabadab
#5786
üzenetére
Nem rossz gondolat, csak nem tudom miként lehet ezt megcsinálni a CooCox ide-ben.
stepboy: jó ötlet!
Amúgy sokfelé van hívva, ez minden időzítésnek az alapja. Az inlineolás jó kérdés, ahogy olvastam a gcc doksikat, azt O2-nél már magától csinálja, valamilyen logika alapján, független a kézi inline deklarálástól.
-
CPT.Pirk
Jómunkásember
válasz
dabadab
#5781
üzenetére
Az attribute-os sort picit más formában kellett megadnom __attribute__ ((naked)), de a GCC és a none-eabi arm-es gcc is ugyanazt fordítja a különböző opt. módokban, beteszi ami ott áll.
.cpu arm7tdmi
.fpu softvfp
.eabi_attribute 20, 1
.eabi_attribute 21, 1
.eabi_attribute 23, 3
.eabi_attribute 24, 1
.eabi_attribute 25, 1
.eabi_attribute 26, 1
.eabi_attribute 30, 6
.eabi_attribute 34, 0
.eabi_attribute 18, 4
.file "delac.c"
.text
.align 2
.global delay_loop
.type delay_loop, %function
delay_loop:
@ Function supports interworking.
@ Naked Function: prologue and epilogue provided by programmer.
@ args = 0, pretend = 0, frame = 0
@ frame_needed = 1, uses_anonymous_args = 0
@ 4 "delac.c" 1
1: sub r0, #1
@ 0 "" 2
@ 5 "delac.c" 1
bne 1b
@ 0 "" 2
@ 6 "delac.c" 1
bx 1r
@ 0 "" 2
.size delay_loop, .-delay_loop
.ident "GCC: (4.9.2-10+14~bpo8+1) 4.9.2"Hasonló a sima GCC kimenete is. Annyit még tudok mondani, hogy GCC4.8, 4.9 és 5.x alatt is azonos a helyzet azon a gépen, ahol dolgozom.
EQMontoya: kellene valaki, aki ért hozzá.
-
llaszlo
veterán
válasz
dabadab
#5721
üzenetére
Köszi
A wchar-ral már találkoztam valahol.
Mi a helyzet ezzel?
Nem pont ez az ami nekem kéne? Csak még nem értettem meg a működését és, hogy melyik kellene nekem innét. Mert itt van olyan amikor az ékezetes karaktert ékezet nélkülire kódolja. Hogyha jól értek mindent.
[link] -
bepken
veterán
válasz
dabadab
#5640
üzenetére
hogyaza....korábban puts("\n"); -val próbálkoztam a legvégén putchar('\n'); helyett és olyankor dupla soremelést tett a végére (ami nyilván hibás) - viszont ha meg csak putchar-ral zártam a végét, akkor a két hatos közé nem tett üres sort. innentől meg csak forgattam magam, hogy végülis a feladat is ezt várja. ráadásul ahogy bemásoltam ide is, parancssorban kiíratva a kimenet is teljesen azonos volt (jól sejtem, hogy a cmd tesz be automatikusan egy üres sort, ha hiányzik a fájl végéről és úgy írja ki a fájl tartalmát? mert akkor ez kavart be)
na lényeg, hogy végül ez volt a kínja. köszönöm szépen a segítséget!
(tudom, hogy nagy hiba, de windows alatt tanulom a C-t, itt meg hirtelen csak ilyen compare cuccot találtam. mondjuk itt is van sokféle kapcsoló, lehet találnék olyat, ami pontosabban megtalálja a különbséget)
-
bepken
veterán
válasz
dabadab
#5638
üzenetére
csak bemásoltam, hogy hogyan is kell kinéznie, de sorra megyezik a két kimenet (utolsó sor után nincs új sor, ahogy kéri is a feladatban) - vagy legalábbis én értelmezésem szerint ezt kéri a feladat.
és esküszöm nem értem, miért nem jó ez így, de file compare eredményt is tudok mutatni:
E:\program\2\Új mappa>fc /n out.txt out2.txt
Comparing files out.txt and OUT2.TXT
***** out.txt
1: ***
2: *
3: ***
4: * *
5: ***
6:
***** OUT2.TXT
1: ***
2: *
3: ***
4: * *
5: ***
6:
*****
***** out.txt
7: ****
8: *
9: *
10: ****
11: * *
12: * *
13: ****
***** OUT2.TXT
7: ****
8: *
9: *
10: ****
*****
***** out.txt
***** OUT2.TXT
11: * *
12: * *
13: ****
*****__________________________________________________
ez meg a két fájl egymás után:
E:\program\2\Új mappa>more out.txt
***
*
***
* *
***
****
*
*
****
* *
* *
****
E:\program\2\Új mappa>more out2.txt
***
*
***
* *
***
****
*
*
****
* *
* *
****
E:\program\2\Új mappa>bocsi, ha értetlenkedek, de nagyon idegesít a dolog és szeretném megérteni a problémát. én kétszer ugyanazt a kimenetet látom
szerk.: out.txt az enyém, OUT2.txt pedig a referencia
-
bepken
veterán
-
alapz@j
tag
válasz
dabadab
#5623
üzenetére
Na, a babakódom
#include <string.h>
char maganhangzok[] = "aeiouAEIOU";
char betuk[256];
void setup_betuk(void) {
memset(betuk, 0, 256);
size_t len = strlen(maganhangzok);
for (size_t x = 0; x < len; ++x) betuk[maganhangzok[x]] = 1;
}
inline char maganhangzo_e(char x) {
return betuk[x];
} -
aviator
tag
válasz
dabadab
#5585
üzenetére
Nem akartam untatni a népet a teljes feladattal, illetve én is csak egy részét próbáltam megcsinálni első körben. Arról van szó, hogy van egy függvény, ami bekér három koordinátát, azaz csúcsonként hármat, tehát egy for ciklussal feltölti a csucsok tömböt 3x3 koordinátával, majd ezután visszaadja a haromszog típusú triangle struktúra címét. (Ezért kell, hogy pointer legyen a tömb típusa.) Ezt a címet veszi át egy másik függvény, ami elvégzi a lefoglalt terület felszabadítását. Eközben a főfüggvényben meg kell még oldani azt, hogy háromszög struktúrából (háromszögekből) is többet lehessen bevinni, méghozzá előre nem meghatározott darabot (dinamikus tömb).
A magyarázatod egyszerűsíthető úgy, hogy azért szállt el a program mert a tömb tele volt null pointerekkel, illetve a hiba a foglalással azért oldódott meg, mert a foglalás után a pointereknek már lett értékük? Tehát inicializálatlan pointerekkel nem dolgozunk?
-
dobragab
addikt
válasz
dabadab
#5549
üzenetére
Igen.
Kicsit off, de hátha segít valakinek, ezért inkább leírom, ha már eszembe jutott.
int temp = 1;
evil_api_function_call(fp, ptr, &temp);C99-ben tudod lokális változónak is képezni a "címét" egy trükkel. Pontosabban: tudsz compound literal segítségével temp tömböt létrehozni egy elemmel, ami viszont már konvertálódik pointerre.
evil_api_function_call(fp, ptr, (int[]){1});
-
G.A.
aktív tag
válasz
dabadab
#5302
üzenetére
Utánanéztem, hogy eddig melyiket is használtam a C vagy a C++ és ez elsővel szoktam a mikróvezérlőkre(AVR) kódot írni, WinAVR-el.
A C# most hirtelen azért kellett, mert egy USB átalakító chip-hez akartam egy parancssorban lefutható kódot írni, aminek a példa kódja C#-ben volt leírva.
GA
-
buherton
őstag
válasz
dabadab
#5259
üzenetére
Pont a napokban turkálok egy olyan kódban, amiben goto van. Én még életemben nem írtam még goto-t kódba, de ezt annyira jól eltalálták és annyira leegyszerűsítette a program megértését és futását, hogy az már zseniális. Nem az ördögtől való, de csak akkor használja az ember, amikor tényleg ezzel egyszerűbb, mert nagyon átláthatatlan lesz. Főleg ha modulok között ugrál, nem csak függvényen belül.
MOD: off
-
válasz
dabadab
#5250
üzenetére
A k/q write only, akarhogy strukturalsz
Ha meg van code folding, akkor
#region Do something complex
do_something_simple();
do_something_even_simpler();
#endregionDe ha sima C-rol van szo, akkor igazabol nincs gyakorlati tapasztalatom real life, szoval elfogadom, ami mondasz.
-
válasz
dabadab
#5247
üzenetére
C/C++-ban tenyleg nem (amikor azzal dolgoztam, akkor maniakus overengineering ment a fejlesztes soran, es az kod nagy resze pure virtual osztalyokbol epult fel
), mas nyelvekben lattam hasonlot, de nem volt extra szenvedes, ez teny. (Es 40 agas switch/case szerkezetekkel se sokat talalkoztam, ez is teny; nem tudom, hogy ez szerencse, vagy tapasztalatlansag 
.)Mondjuk azert masrol beszelunk. En azt mondtam, hogy onmagaban a fuggveny hossza nem problemas, te meg azzal jossz, hogy ha nagyon bonyolult switch/case szerkezetek vannak, vagy a valtozok deklaracioja/ertekadasa es felhasznalasa kozott van 40 kepernyonyi kod, az problemas. Ezt elfogadom/elhiszem, de ugye itt nem a kod hosszaval van a gond -- a kod hossza az kovetkezmenye a problemanak, de nem az oka.
APL(-szeru) nyelven neztem bazi hosszu, teljesen strukturalatlan kodokat - ott ugye nem jellemzoek a fuggvenyek, viszont az sem, hogy regesreg krealt ertekeket hasznalsz sokkal-sokkal kesobb; inkabb sok-sok egymas utan kovetkezo es egymasra epulo lepest irnak le. Peldaul ilyen esetben semmi problema nincs a hosszu koddal.
De tenyleg nem tudok az erveddel vitatkozni
-
válasz
dabadab
#5241
üzenetére
Tehat vegulis az ok, amiert szet akarod szedni, az a konnyebb navigacio. Ennek a megkonnyitese szerintem az IDE dolga lenne, nem a programszervezese, es a modern IDEk mar szoktak tudni fold/collapse funkciot C++-ra is, ha jol gondolom. .Net-ben ott a #region pragma, ami pont erre valo; Java-ban a sok patternhuszar ugyis haromsoros classokba szervez mindent (
![;]](//cdn.rios.hu/dl/s/v1.gif)
), funkc. nyelvek meg altalaban tul tomorek ahhoz, hogy ilyen hosszu fuggvenyeket irjon az ember. -
EQMontoya
veterán
válasz
dabadab
#5204
üzenetére
Func ptr-t nyilván nem, nem is arra értettem.
Azért tegyük fel, hogy legalább minimálisab objektum-orientáltan kódolunk mátrixot, és annak műveleteit. Ott simán lehet írni inline-olt gettert.Egyébként teljesen jogos, de muszáj volt beletrollkodnom. Mint láthatod, nem csak bennem merült fel.
Illetve, ha már itt észt osztok, mai c++ lecke: egy argumentumos, POT-ot váró konstruktor legyen explicit, ha lehet.
Ha nem az, akkor olyan mókásságokba futhat bele a zember fia, mint egy rossz copy-paste után leforduló bool paraméterrel meghívott függvény, mint egy saját, file system path osztályt vár paraméterül. -
Jester01
veterán
válasz
dabadab
#5196
üzenetére
Attól függ mi a feladat pontosan. Mert ha a transzponált mátrixot oda kell adni valami másik függvénynek az boldogtalan lesz ha nem transzponálod ténylegesen mert nem tudja, hogy fel kell cserélni a koordinátákat. Persze ha van valami társított flag ami mutatja és ezt minden tudja is kezelni, akkor jó megoldás.
A kérdésre válaszolva: végig kell iterálni az alsó vagy a felső hárömszögön és cserélgetni. Már ha nem kell új helyre másolni, mert akkor az egészen végig kell menni és felcserélve kiírni.
-
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 ) -
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. -
don_peter
senior tag
-
don_peter
senior tag
válasz
dabadab
#4675
üzenetére
Ja értem most már..
Itt sokat nem kell változtatni a menüpontokon szóval csak azokért nem használnék külön struktúrát.Itt egy kis részlet a kódomból:
E programrész felett ellenőrzöm az Eepromban tárolt adatokat és, ha van elmentett profil akkor azt a memóriából kiolvasva betöltöm./****************************************************************************
+ "menu" goto utasítás
+ Ha nincs betölthető profil akkor ugrás a menu goto utasításra
*****************************************************************************/
menu:
lcd_clear();
i=0;
while(1){
keyval = get_key(KeyAlfOrNum); //numerikus gombok engedélyezése
if(keyval=='1'){
//Új profil hozzáadása
}else if(keyval=='2'){
//Aktuális profil szerkesztése
}else if(keyval=='3'){
//Profilok listázása
}else if(keyval=='4'){
//Ugrás a már betöltött profilra
goto profil_betoltve;
}
printf("1. Uj profil hozzaad");
lcd_write(0xC0,0,1,1);
printf("2. Akt. prof. szerk.");
lcd_write(0x94,0,1,1);
printf("3. Profilok listaja ");
lcd_write(0xD4,0,1,1);
printf("4. Vissza ");
lcd_write(0x80,0,1,1);
}Itt látszik valamennyire, hogy oldottam meg a programok közi ugrálást...
-
don_peter
senior tag
válasz
dabadab
#4673
üzenetére
Jelenleg programoktól függően külön van választva több részre a teljes program kód.
1. inicializáló függvények és típusdefiníciók, adatstruktúrák, I/O portok beállítása...stb
2. függvények melyek mindent külön kezelnek. (Memória IC, PIC Eeprom, időzítők és egyéb vezérlők)
3. PIC láb definíciók
4. Megszakítások (Magas és alacsony prioritásúak)
5. maga a program amely összevonja a feljebb felsoroltakat. ( main() )Természetesen még van pár része a programnak melyekre nem tértem ki, de nem is fontosak a mondanivalómhoz.
A programban nem kezelhetek mindent adatstruktúrákban, de egy részét abban kell vagy legalább is jobb abban kezelni nyilván.
Maga a főmenüt és elágazásait egy ciklusban kell kezeljem, ha nem "goto" paranccsal ugrálok a ciklusok közt.
Nyilván itt a 4x4-es mátrix interfész miatt kell egyben kezeljem mert azon keresztül tudom csak manuálisan kezelni a programot.
Muszáj pergetnem, különben nem tudom figyelni folyamatosan a gombok állapotát. -
don_peter
senior tag
válasz
dabadab
#4650
üzenetére
Igen, köszönöm.
Közben ez a része megoldódott adat struktúrával amely aztán típus definícióval deklarálva lesz.
Természetesen ez is jó megoldás csak így kellene még egy függvényt használnom ami kicsit bonyolítaná a program tekinthetőségét. (véleményem szerint)Az strukturálisában például nem értem miként adódik át úgy egy 16bites adat, hogy az adatszerkezet 2 változójába egységesen oszlik fel.
Kiolvastam a könyv adatstruktúrájáról szóló fejezetet, de nem írja le, vagy csak számomra nem érthető...Tehát egy példa:
Típus definiciótypedef union INT16
{
sort int Value;
struct
{
unsigned char LB;
unsigned char HB;
} bytes;
} INT16Aztán jöhet a main() függvényben a deklaráció
INT16 temp;
Aztán adunk át értéket, mondjuk 900-at.
temp.Value = 900;
Ez az én gondolat menetem szerint 2részre bomlik, 2db 1bájtos részre.
temp.LB-ben lesz az első (alacsonyabb helyi értéken lévő) 8bit és temp.HB-ben a második (magasabb helyi értéken lévő) 8bit.
Szóval így: 900 16bites bináris értéke == 00000011 10000100Amit nem értek, hogy a miért és milyen elv szerint rendezi el önkényesen az átadott adatokat?
-
buherton
őstag
válasz
dabadab
#4608
üzenetére
Szeretném én is kiegészíttetni a téma összefoglalót.
Magyar nyelvű könyvekhez:
Kónya László-Kopják József - PIC Mikrovezérlők alkalmazástechnikája [link]Fejlesztő környezetek:
Clang
cross-platform (Windows / Linux / OSX) csak fordítóMPLABX
cross-platform (PIC) fejlesztőkörnyezetEclipse CDT
fordítót nem tartalmaz, de konfigurálhatósága miatt szinte minden platforma minden fordítóval lehet benne fejleszteniLPCXpresso
cross-platform (NXP Cortex-M, ARM7, és ARM9 alapú mikrokontrollerek) fejlesztőkörnyezetAtmel Studio
cross-platform (AVR8, AVR32, Atmel ARM-ok) fejlesztő környezetarm-none-eabi
cross-platform (ARM Cortex-M és Cortex-R) csak fordítóEzek mind ingyenesen használhatóak. Az MPLABX-ben nem vagyok biztos.
-
don_peter
senior tag
válasz
dabadab
#4578
üzenetére
Nos közben haza értem külföldről és kipróbáltam a kódodat, ilyesfajta bits varázslatokat nem fogad el a C18
Sebaj az első belinkelt kódom kicsi átalakítással már megy is tökéletesen.
Vannak még hibái a programnak, de ha elkészülök dobok fel vidit róla mit sikerült összekovácsolnom... -
alapz@j
tag
-
don_peter
senior tag
válasz
dabadab
#4578
üzenetére
Ez akkor most vissza tér egy char típusú karakterrel ami 1-16-ig van, gombnyomástól függően.
Ez eddig szép és jó. Mellesleg köszönöm, hogy tisztába raktad a dolgot és leegyszerűsítetted, sokat fogok belőle tanulni.
A fő kérdés viszont az, hogy miként kivitelezhető az, hogy mint a telefonnál alfanumerikus módon is írhassak?
Tehát van egy 4x4-es mátrix nyomó gombsorom, az rá van csatlakoztatva a mikrovezérlőmre és szépen, ha megnyomom valamelyik gombot akkor 1-től 16-ig vissza adja nekem a benyomott gomb értékét.
4x4 keypad
Ezt nem tudom tovább gondolni, hogy miként lehetne megoldani, hogy egy-egy gomb többszöri megnyomásánál már alfanumerikus értékként a gombonkénti eltárolt 3 betű egyikét adja vissza.
Arra gondoltam, hogy valami ciklusban ciklust kellene futtatni és mivel egy gombot megnyomok és várakoztatnom kellene legalább 1-2mp-et, és vizsgálnom, hogy van e ugyan azon a gombon közvetlen, további nyomás és az szerint váltani a betűket, hogy hány további nyomás történik.Legalább is erre felé gondolkodom, persze ez lehet nem jó irány.
Gyakorlatilag mint a telefon gombsora úgy működne a dolog annyi kivétellel, hogy nem lenne annyi karakter.
Csak az angol nagy betűs A-Z-ig és 0-9-ig számok kellenek.
Illetve egy BACK és SPACE gomb, hogy vissza törölhető és léptethető legyen a dolog.
Ez természetesen csak a gombsor egy részét foglalná le ami 4sorból és 3oszlopból állna.
A 4. oszlop 4sora külön funkció gombok lennének.
Szóval ezen a dolgon rágom magam már lassan 1 hete, de túlnő rajtam ez a globális gondolkodás.
Tudsz ebben segíteni?
Ha csak elméletben azt is megköszönöm.
Természetesen az eddig megírt és leegyszerűsített kódot kellene kiegészíteni ezzel a nem kis résszel
Előre is köszi a segítséget. (Ha valamit nem világosan írtam, csak kérdezz bele bátran) -
don_peter
senior tag
válasz
dabadab
#4574
üzenetére
Az a baj, hogy alig másfél hónapja kezdtem el a C-ét és a C18-at vagy is a PIC programozást egyszerre így sajnos nem tudok még rendesen érthetően megfogalmazni a kérdéseimet.
"SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) );"
Gyakorlatilag, ha két >> jelet teszünk az azt jelenti, hogy a 2 hatványával léptetjük a változó értékét a megadott irányban? (Ha igen akkor már is tanultam ismét valamit, vagy is tanultam már csak nem értettem meg ezek szerint)"int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };"
Hogy ez is tiszta legyen:
"PORT_B4" egyenlő a következővel : PORTBbits.RB4
Gyakorlatilag ez egy (port) regiszter mellyel a chip egy adott porton adott láb állapotát tudjuk lekérdezni, hogy az 1 vagy 0.
Ha 1 akkor annak állapota magas szintű, értelemszerűen a 0 = alacsony szinttel.
A portok nekem egy header állományban külön definiálva vannak, pl. így:
#define PORT_B4 PORTBbits.RB4"#define NO_KEY 0"
Teljesen igazad van.
Jobb rászokni az olvasható kód írásra...Ezt a részt nem igazán értem: "Viszont a getchar() egyaltalan nem egy bit allasat adja vissza, hanem egy karakterkodot, ami logikailag abszolút más dolog."
Vagy itt elírás történt és valójában getchar() az get_key() akart lenni?
Ha igen akkor ő nem a bit állással kell vissza jöjjön hanem a beolvasott karakterrel ami 1,2,3...16-ig."A ciklus végtelen pergésben van"
while(1){
bill_ertek = get_key();
Delay10TCYx(10);
}//while()
Ez egy végtelen ciklus nem?
Ebben minden ciklusnál újratöltődik a bill_ertek változó még ha egyelőre nem is jól van megadva."Ha arra gondoltál, hogy a getchar()-t kívülről végtelen ciklusban hívod, az meg nem számít, mert azzal kezdődik, hogy lenullázod a k-t"
Feltételezem, hogy itt is get_key()-re gondolsz.
Igen igazad van mert ha vége a ciklusnak akkor az újra meghívásnál nullázódik alapból is a k.
Próbálkozom erősen, de kellenek a szakik tanácsai és gondos szemei -
don_peter
senior tag
válasz
dabadab
#4569
üzenetére
Köszönöm a kiigazítást.
Gondolom én voltam félreérthető az első bejegyzésemben."#define FIRST_ROW_BIT_POSITION 4"
Így gyakorlatilag csak egy értéket adunk FIRST_ROW_BIT_POSITION nak és nem tudjuk később léptetni a mikrocsip lábait.
Tehát ez "SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) ); " helyett az kell amit eredetileg is írtam.
SOROK = (0x08>>i); Ezzel gyakorlatilag a mikrocsip B portjának lábaira adunk magas szintet."int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };"
Ezt ugyan nem próbáltam még ilyen formában, de van egy sejtésem, hogy nem jó mivel értéknét adjuk át a az egyes portok egyes lábait.
Bár elképzelhető, hogy ha minden ciklusba adom át a tömbnek az értékeket akkor elvileg működhet is."#define NO_KEY 0"
Gyakorlatilag ugyan az mint az én
"#define ALACSONY 0" definícióm."A k-t állítgató résznek semmi értelme"
A ciklus végtelen pergésben van és ha nem érkezik gombnyomás akkor a 4 ciklusonként nullázni kell az értékét hiszen 4x4 vagy is 16gomb van.Egyszóval, ha sima C programnak tekintjük akkor tökéletes a példád, de sajnos itt figyelembe kell venni, hogy mikrokontrollert programozunk fel illetve a lábak szintjeit ellenőriztük.
Azt hiszem erre irányuló kérdésem a C topikban nem állja meg a helyét.
Köszönöm ettől függetlenül a segítőkészséget. -
tototos
addikt
válasz
dabadab
#4541
üzenetére
RTOS fölé szeretnék írni egy burkolót, ami azt csinálja hogy a felhasználó megadja, hogy melyik funkciót szeretné futtatni, milyen periodicitással, és ezt az alatta lévő réteg elintézi. A felhasználónak nem kell a taskjában while loopot írni, meg várakoztatni adott ideig a taszkot, csak megírja mit csináljon a task és az lefut minden egyes periódusban. A létrehozható taszkok száma maximalizálva van, az a taskN. A bővítést szeretném macroval megoldani, hiszen minden task ugyanazt csinálja, csak ugye a hívandó funkció és a periódus változik.
-
JmL
csendes tag
válasz
dabadab
#4530
üzenetére
És most jó !!
Köszönöm szépen a segítséged, nagyon hálás vagyok ! :p
Gondolhattam volna a lezáró 0-ra
Egyébként magamtól tanulom a programozást mert az infótanárom csak pascal-t ismeri, és mivel BME-re készülök, célszerűbbnek gondoltam megtanulni a C-t, oda úgy is az kell a legelején, szóval a tanár ebben nem tud segíteni
Köszi!
![;]](http://cdn.rios.hu/dl/s/v1.gif)
, de nem tudok ezzel vitatkozni.
.)
. Illetve néhány oldallal ezelőtt volt az a másik windowsos IDE, az is megérhet egy említést.
Ú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!
- Remek áron Lenovo Flex 5 14 laptop/2in1/Touch/Ryzen i5-1135G7/8GB/512 GB SSD/14"/Gari
- Exclusive ajánlat! Dobozos új LG GRAM /13. gen i7-1360P/32GB RAM/512GB SSD/14"COL/FHD+/IPS/Garancia/
- Pénztárcakímélő áron eladó HP Pavilion laptop/I5-1135G7 8GB 256SSD 13" FHD IPS Gari
- Samsung Galaxy Book 3 /i5-1335u/8GB/512SSD/FHD/Garancia/ 6 napot ment eddig összesen
- Xiaomi Redmi Note 14 Pro Plus 12/512GB Újszerű,Dobozos,Kétkártyás 1év Garanciával!
- ÁRGARANCIA!Épített KomPhone i5 14600KF 32/64GB DDR5 RAM RTX 5070Ti 16GB GAMER PC termékbeszámítással
- Bomba ár! Dell Inspiron 15 3511 - i5-11GEN I 8GB I 256SSD I HDMI I 15,6" FHD I Cam I W11 I Gari
- BESZÁMÍTÁS! MSI B450M R5 5500 32GB DDR4 512GB SSD RTX 3060 12GB Rampage SHIVA Chieftec 600W
- ÁRGARANCIA! Épített KomPhone Ryzen 5 7600X 32/64GB RAM RTX 5070 12GB GAMER PC termékbeszámítással
- Bomba ár! Lenovo ThinkPad T490s - i7-8GEN I 16GB I 256SSD I 14" WQHD HDR I Cam I W11 I Gari!
Állásajánlatok
Cég: PC Trade Systems Kft.
Város: Szeged
Cég: PC Trade Systems Kft.
Város: Szeged