- Samsung Galaxy Watch7 - kötelező kör
- Milyen okostelefont vegyek?
- iPhone topik
- Motorola Razr 60 Ultra - ez a kagyló könnyen megfő
- Netfone
- Karaktere biztos lesz az első Nothing fejhallgatónak
- Apple Watch
- Honor 400 Pro - gép a képben
- Samsung Galaxy S20 és S20+ duplateszt
- Samsung Galaxy S24 Ultra - ha működik, ne változtass!
Új hozzászólás Aktív témák
-
don_peter
senior tag
válasz
buherton
#4656
üzenetére
Sikeres volt a vissza fejtés..
Rájöttem, hogy mivel 16bit-es adatot adok át így hexában tárolja. (logikus)
Itt egy példa ha valaki le akarja még tesztelni:typedef union INT16 {
short int value;
struct{
unsigned char low;
unsigned char hight;
}bytes;
}INT16;
void main(void){
INT16 temp;
temp.value = 900;
printf("%x\n", temp.bytes.low);
printf("%x\n", temp.bytes.hight);
printf("%i\n", temp.bytes);
}Most már világos
Köszi a rávezetést...
-
-
don_peter
senior tag
A bájt sorrend az teljesen megvan szóval ez rendben van...
Itt inkább maga az érték átadás folyamatára lennék kíváncsi miként töltődik fel az adatstruktúrában lévő változók.Talán itt a túlcsordulás miatt ugrik egyet az adatstruktúra?
Tehát az első 8bit befér a LB-be de a 9-edik bittől már túlcsordulás van és a következő változóba esetünkben a HB-be töltődik be a maradék 8bit? -
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?
-
don_peter
senior tag
Igen használok adatstruktúrát és azt union-ban (típus definícióval) megadva megadom a memória címzését hexában...
De azt hogy egy adott 2bájtos adatot, hogyan adok át egy memóriának mikor az maximum 1bájtot tud egyszerre a buffer regiszterébe kezelni....ez nem fér a fejembe..
A többi dolgot megoldom sort int és unsigned char típusú változókkal. -
don_peter
senior tag
"Nem ertem mit akarsz osszevonni, megmondom oszinten... lesz x byte teruleted, arra rateszel egy olyan strukturat, amilyen illik az adatokra. Lesz benne char[] es lesz benne unsigned byte meg unsigned short."
Csak kérdeztem, hogy megoldható e, hogy egyszerre 2 típust tároljak egy változóba, de ez nem megoldható.
Így marad egy külön char ami 8bites és egy short int ami 16bites.
Hozzáteszem, hogy csak egy adat az alsó fűtés igényel 1bájtnál nagyobb területet.
Ezt túl is tárgyaltuk...En me'g azt nem ertem, hogy ha rogton az elejen hogy lehet 2 VAGY 3 byte/char... feltoltod ugy hogy (karakteresen) #12 akkor honnan fogod tudni, hogy igy kell olvasni, es a 2 nem az utana kovetkezo adathoz tartozik es a #1-rol van szo?
Itt a "#" kettős kereszt lesz egy speciális karakter amely jelzi az érvényes adatblokk kezdetét. (ez 1bájt)
Az utána következő 1bájtban egy szám lesz ami 0-14 közt van mivel maximum 15db különálló profilt lehet majd előre rögzíteni a memóriába.
A program elején egy feltétel vizsgálattal ellenőrzöm és beazonosítom az utolsó betöltött profilt.
Az azonosítás több részből áll, de ez már más téma... -
don_peter
senior tag
-
don_peter
senior tag
Mikrokontroller programozásról van szó.
A program nyelvünk a C.
A mikrokontroller alap programmemóriája 2KB így csínján kell bánni vele.
Elég nagy lesz a program szóval spórolni szeretnék ahol tudok.
A mikrokontroller Eeprom memóriája 256bájt, ezen területen fogom tárolni az utolsó betöltött állásokat, áramszünet vagy kikapcsolás esetére...
Természetesen csatolni fogok SPI csatlakoztatással egy 64KB-os memóriát is melyben a profil adatokat fogom tárolni.
Ezen memória területeket el kell lássam egy azonosító jellel melyet vissza keresve tudom majd ellenőrizni, hogy az érvényes profilbeállítás.
Ez az érvényes azonosító kerül be az Eeprom területre, és ez alapján töltöm be a memóriából az utolsó elmentett profil állapotot.
A kijelzés egy 2x16 és vagy 4x20karakteres LCD kijelző lesz amelyen a lehető legkifejezőbben szeretném értesíteni a felhasználót az éppen aktuális állapotról.A név hosszán már is spóroltam így csak maximum 16karakter lehet.
A kérdésem pont arra vonatkozott, hogy megoldható e az összevont tárolás, hogy karaktert és számot egyaránt tudjak tárolni.
De úgy fest külön kell megoldanom mint ahogy én is megcsináltam azt eredetileg.
Talán így érthetőbb.
Így meg szerintem totál meg fogod érteni az eredeti elképzelésem: nézd meg kérlek
Köszi... -
don_peter
senior tag
válasz
k.kristof
#4640
üzenetére
A program melyet írtam le korlátozza a számértékeket a megengedett 1-255-re (1bájt).
Ha már 256 akkor hibával tér vissza a program, illetve az alsó fűtés értéke lehet nagyobb mint 255, de kisebb mint 65536 vagy is 2bájt.
unsigned char változóba lennének mentve ideiglenesen bevitt értékek...Ja és még ide annyi, hogy mivel a nevet és minden számértéket egy változóba akarok menteni így nem lehet int típusú.
Ez lenne a lényege a dolognak.
unsigned char buffer[32]={0}; //ebbe lenne minden tárolva -
don_peter
senior tag
Húú annyi információt kaptam, hogy még jobban össze zavart.
Tehát a lényeg, hogy van egy memória területem amiben 32bájt helyem van.
A 32bájt helyre szeretném elmenteni a következőket.:
2-3 karakter a sor azonosító, egy speciális karakter és egy szám 0-14-ig (#0-#14)
16 karakter a név, (min 3 - max 16) 16bájt
6 számérték a hőprofil, (1-255) 6x1bájt
6 számérték az időprofil, (1-255) 6x1bájt
1 számérték az alsó fűtés (1-1023) 2bájtA számadatok unsigned int változóba a karakterek unsigned char változóba vannak jelenleg elmentve és így működik is ahogyan szeretném, de véleményem szerint sok memóriát emészt fel és szeretnék spórolni a felhasználható programmemóriával. (mikrokontroller)
A kérdésem arra irányul, hogy ezen adatokat egy unsigned char változóba is beírhatom úgy hogy a számértékek mint pl.: 255 az maximum 1bájt-ot foglaljanak?
Vagy ez nem megoldható.
Nem tudom mennyire érthető a kérdésem... -
don_peter
senior tag
Fiúk, Lányok!
Lenne egy valószínűleg vicces kérdésem, de muszáj megkérdeznem mert nem vagyok biztos a gondolat menetemben.
A lényeg, hogy van 2 típus, char és int.
El akarom menteni memóriába és az a kérdésem, hogy ha számokat akarok elmenteni char típusként akkor 1 szám 1bájtot fog foglalni?
Tehát ha egy 8-as számot akarok char típusként elmenteni akkor az 1bájtot fog foglalni a memóriában?
És ha 12-őt akkor az már 2bájtot igaz?
Viszont int típusként 0-255-ig 1bájt igaz?
Vagy char típusként is megmarad a 0-255-ig az 1bájt?Én úgy gondolom, hogy char típusnál 1 szám vagy betű 1bájtot foglal.
Okosítsatok fel.
Előre is köszi.. -
don_peter
senior tag
Az sajnos nincs.. mármint sscanf() függvényem, nyilván egyszerübb lenne sok minden, ha pont úgy működne mint PC-én, de sajnos nem
A 4x4-es mátrix gombsort folyamatosan ellenőrzi a progi amit írtam rá és ha gombnyomás történik akkor a gombhoz párosított karaktert menti egy ideiglenes változóba.
Ez után, ha végig ment a kiértékelésen betöltődik egy tömbbe és az ideiglenes változót töröljük és újrakezdődik a folyamat addig ameddig el nem érjük a kívánt karakterszámot vagy ENTER-nek megfelelő gombot meg nem nyomjuk.Érdekes dolog ez a mikrokontroller programozás.
Ui:
Közben így módosítottam a vizsgáló kódom:unsigned int i=0;
unsigned char teszt[4] = {'1','A','3','\0'};
for(i=0; i<=sizeof(teszt)-2; i++){
if ( (teszt[i] >= '0' && teszt[i] <= '9') )
printf("Ez egy számjegy!\n");
else
printf("Ez egy betű!\n");
}Viszont a változó méretű, de maximum 18 karakter férőhelyes tömbömben majd vizsgálnom kell a végét is és ez felveti azt a problémát, hogy a sizeof() függvényt le kell cseréljem egy általam vagy már létező strlen() függvényre.
De, ezek már részletkérdések.. -
don_peter
senior tag
Közben rájöttem
Kicsit agyalnom kellett az eddig tanultakon bár annak nem örülök, hogy lépésenként kell végignézni a karaktereket ...unsigned int i=0;
unsigned char teszt[4] = {'1','A','3','\0'};
for(i=0; i<=sizeof(teszt)-1; i++){
if ( (teszt[i] >= 'A' && teszt[i] <= 'Z') )
printf("Ez egy betű!\n");
else
printf("Ez egy számjegy!\n");
}Közben látom, hogy megelőztetek
Köszi..Szerk:
Értem akkor inkább a számokat vizsgáljam, mert az rövidebb ideig tart.
Világos.. Mindig tanulok valami újat.
Néztétek a videót amit linkeltem ezzel kapcsolatban?
Kukk meg itt: [link] -
don_peter
senior tag
válasz
alapz@j
#4623
üzenetére
Köszi, de mikrokontrollerbe használom így azt hiszem vagy is azt gondolom, hogy nem működne ez ebben a formában.
Főként talán azért mert nem emlékszem, hogy a C18-as könyvtárban lenne ilyen "intrin.h" állomány.Egyébként ha működne miért lenne ez jobb mint az előző?
A tömbökben amiket törlök memset()-el rövid életűek és csak az interfészen bevitt karaktereket tárolják majd ha végeztem a 14 adat bekérésével kimentem memóriába a tömb adatait és utána rögtön törlöm is.Tényleg ha már itt tartok:
Hogy tudom ellenőrizni a tömb tartalmát hogy abban karaktert vagy számot írtam?
Mutatok egy példát:unsigned char teszt[4] = {'1','2','3','\0'};
//ellenőrzés pedig
if(atoi(teszt)>0 & atoi(teszt)<255){
printf("Csak szám\n");
}else{
printf("Nem csak szám\n");
}
//Másik változat
unsigned char teszt[4] = {'1','1','A','\0'};
//ellenőrzés pedig
if(atoi(teszt)>0 & atoi(teszt)<255){
printf("Csak szám\n");
}else{
printf("Nem csak szám\n");
}Eredménye:
1. Csak szám - ez helyesen értékelődik ki
2. Csak szám - ez hibásan értékelődik ki mivel tartalmaz egy betűt isTegnap próbálkoztam vele és pl: ha betűvel kezdődik a tömb akkor helyesen értékelődik ki, de ha az elején szám van és a végére betűt írok akkor hibás a kiértékelődés.
Hogyan tudom megvizsgálni a tömböt, hogy abban csak számok van?
Köszi előre is..ui: tömb bejárásnál eszembe jutott, hogy talán elemnkénti vizsgálattal pl:
if(tomb[i] != 'A - Z' & tomb[i] != 'a - z') //helyes
Vagy valami ilyesmi...
-
don_peter
senior tag
Hölgyek, Urak!
Hogy tudok egyszerűen és gyorsan törölni egy tömböt?
Pl. van egy ilyen tömböm:
tomb[] = {a,b,c,d,e,f,1,2,3};
Szeretném ennek teljes tartamát törölni, de lehetőleg nem bejárással.
Van erre valami jól bevált vagy legalább hatékonyan használható parancs vagy kód?
Köszi előre is.. -
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... -
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. -
don_peter
senior tag
válasz
don_peter
#4567
üzenetére
Oksa közben rájöttem, hogy az oszlop1, oszlop 2...stb-re gondolsz.
És közben arra is rájöttem, hogy mivel az oszlop1, ...oszlop4 változok a mikrovezérlő lábait tartalmazzák így azokat nem tömbösíthetem.
Az if() feltétben a mikrovezérlő lábainak szintjét ellenőrzöm, hogy magas vagy alacsony szinten áll. -
don_peter
senior tag
válasz
Jester01
#4566
üzenetére
Közben rájöttem, hogy van a kódban még hiba így azt javítottam.:
unsigned char get_key(){
unsigned int i, k=0;
for(i=0; i<4; i++){
SOROK = (0x08>>i); //Léptetjük a sorok szintjét
k++;
if(oszlop1 == MAGAS){
while(oszlop1==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop2 == MAGAS){
while(oszlop2==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop3 == MAGAS){
while(oszlop3==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop4 == MAGAS){
while(oszlop4==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
if(i>0){ //Ha a második lefutásnál sincs találat
k=(i+1)*4;
}else if(i==3){ //Ha az utolsó is lepörgött nullázzuk k-t
k=0;
SOROK = 0x08; //Sorok szintjét vissza állítjuk az elejére.
}else{ //Első lefutás után a k értéke 4 lesz
k=4;
}
}
return ALACSONY;
}Arra célzol, hogy gondolkozzak 2 dimenziós tömbökbe?
-
don_peter
senior tag
Hölgyek, Urak segítséget szeretnék kérni alfanumerikus 4x4-es keypad programjának megírásához.
Angol ABC és 0-9-ig számok lennének kb. mint a telefonnál vagy hasonlóan gondoltam kivitelezni.
Tudtok segíteni elméletben vagy akár gyakorlatban?
Hogyan lehet ezt legegyszerűbben megírni?
P18F4550-es mikrokontroller fogja feldolgozni az adatokat.
Ilyen lenne a keypad:A sima 16 gomb kezelésére írtam már programot, talán ebből ki lehetne indulni csak nem tudom, hogy miként vagy milyen irányban haladjak tovább..
A megírt kódom most így néz ki:#include <delays.h>
#define SOROK LATD //Sorok
#define oszlop1 PORT_B4 //Oszlopok bemenet
#define oszlop2 PORT_B5
#define oszlop3 PORT_B6
#define oszlop4 PORT_B7
#define MAGAS 1
#define ALACSONY 0
/*----- Prototípus --------*/
unsigned char get_key();
unsigned int bill_ertek; //Globális változó
void main(void){
unsigned int i,k=0;
ADCON1 = 7; //Analóg portok digitálisra állítva
TRISB = 0xf0; //B port felső 4 bit (nagyobb helyi értéken 7:4) bemenet
//alsó 4 bit (kisebb helyi értéken 3:0) kimenet
//0b11110000
while(1){
bill_ertek = get_key();
Delay10TCYx(10);
}//while()
}//main()
//Függvények
unsigned char get_key(){
unsigned int i, k=0;
for(i=0; i<4; i++){
SOROK = (0x08>>i); //Léptetjük a sorok szintjét
k++;
if(oszlop1 == MAGAS){
while(oszlop1==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop2 == MAGAS){
while(oszlop2==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop3 == MAGAS){
while(oszlop3==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop4 == MAGAS){
while(oszlop4==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
if(i>0){ //Ha a második lefutásnál sincs találat
k=(i+1)*4;
}else if(i==3){ //Ha az utolsó is lepörgött nulláztuk k-t
k=0;
}else{ //Első lefutás után a k értéke 4 lesz
k=4;
}
}
return ALACSONY;
}Minden ötletet szívesen fogadok.
-
don_peter
senior tag
válasz
alapz@j
#4557
üzenetére
Ez ebben a formában még magas nekem, de azért köszi a szándékot.
A mutatókat már ismerem, de csak felületesen.
Átvariáltam a dolgot mivel a fentebbi kódomnál csak a char típus jöhetett szóba és így pazaroltam a bájtokat illetve a megfelelő típusmódosítások is igényeltek további sorokat.
Az új verzában már külön szedtem a char és int típusokat és így már szebben lehet e memóriába beírni és kiolvasni.
Nem kellenek az elválasztó karakterek sem.
Ahogy tanulom és gyakorlom a dolgot úgy értem meg egyre jobban a működéseket. -
don_peter
senior tag
Igen van ilyen, csak nem jutottam előrébb vele és ezért kezdtem el gondolkodni a lépéseken.
Itt a függvény:
#include<string.h>
#include<stdio.h>
int main()
{
char input[16] = "abc,d";
char *p;
p = strtok(input, ",");
if(p)
{
printf("%s\n", p);
}
p = strtok(NULL, ",");
if(p)
printf("%s\n", p);
return 0;
}
Szerintem ő jól dolgozik, csak nem jutottam vele dűlőre -
don_peter
senior tag
Húúú mennyire igazad van..
A lezárót elfelejtettem.
Most már jó...char memtomb[7][10];
És
memtomb[x][z] = '\0';egyébként ez véleményed szerint hatékony módszer vagy ennél van egyszerűbb és hatékonyabb mód a szétválasztásra és tömbbe másolásra?
Gondolom ha a számokat már int típusra akarom alakítani akkor a típusmódosítással el tudom érni azt.
int elsoszam;
elsoszam = (int)memtomb[1];
Ez így jó lesz? -
don_peter
senior tag
Közben meg is oldottam a dolgot.
A kérdésem a következő lenne:
Van esetleg egyszerűbb és hatékonyabb megoldás a következő kódomra?
#define MAXTOMBSIZE 32 //headerbe
//main()
unsigned int maxmemtomb;
char meminput[MAXTOMBSIZE] = "Valaminev#60#120#185#225#240#260";
char memtomb[7][46];
int i,z,x;
char ek = '#';
maxmemtomb = MAXTOMBSIZE;
x=0;
z=0;
for(i=0; i<=maxmemtomb-1; i++){
if(meminput[i] == ek){
z=0;
x++;
printf("\n%c", meminput[i+1]);
memtomb[x][z] = meminput[i+1];
z++;
i++;
}else{
printf("%c", meminput[i]);
memtomb[x][z] = meminput[i];
z++;
}
}
printf("\n\nTömbbe rendezve:\n");
for(i=0; i<=6; i++){
printf("%i. adat: %s\n",i, memtomb[i]);
}
Illetve az is érdekel, hogy miért kellett a "char memtomb[7][46];" többdimenziós tömböm második paraméterébe minimum 46-ot tennem, hogy jó eredményt kapjak?
Ezt nem értem még akkor sem, ha így működik...
Elviekben ott a maximum 9 karakter lehet mert a "Valaminev" a leghosszabb string nem? Vagy nem jól értelmezek valamit? -
don_peter
senior tag
Urak, Hölgyek!
A következő kóddal van bajom:
//headerbe
#define MAXTOMBSIZE 32
//main()
unsigned int maxmemtomb;
char meminput[MAXTOMBSIZE] = "Valaminev#60#120#185#225#240#260";
char memtomb[7];
int i;
char ek = '#';
maxmemtomb = MAXTOMBSIZE;
for(i=0; i<=maxmemtomb-1; i++){
if(meminput[i] == ek){
printf("\n%c", meminput[i+1]);
//memtomb[i] = meminput[i+1];
i++;
}else{
printf("%c", meminput[i]);
//memtomb[i] = meminput[i];
}
}
//for(i=0; i<=6; i++){
//printf("\nAdatok: %s\n", memtomb);
// }A program lényege, hogy a "Valaminev#60#120#185#225#240#260" karakterláncot a # karakternél szétválasszam és a szétválasztott elemeket egy tömbbe töltsem.
Addig jó a program, hogy kiírja a képernyőre a szétválasztott elemeket egymás alá, de mikor bele akarom tölteni egy tömbbe a szétválasztott elemeket akkor zagyvaságokat ír bele.
Próbáltam már kismillió formában, de a végén nem lesz jó az eredmény.
Mit cseszek el folyamatosan?
Hogy tudnám ezt megoldani?A program élesben egy 64KB-os memória 32bájt-ját fogja beolvasni ami hasonlóan vagy pont így fogja tárolni az adatot, a szétválasztott adatok külön-külön lesznek hasznosak.
De ha nem jó a megközelítésem szívesen veszem a kiokításokat. -
don_peter
senior tag
válasz
buherton
#4533
üzenetére
Köszi, egyelőre még nem értem teljesen mi hogy működik, de rajta vagyok az ügyön.
Most ezt dobtam össze ami részben működik, de egy idő után valamiért megkeveredik és összeakad a futása.
[link]
A lényege, hogy fut a főprogram, majd bekövetkezik egy magas jelre történő megszakítás (kapcsolóval) és eldúl az interrupt-ban megadott feladat. (visszaszámláló)
Majd a feladat végeztével a program visszatér a főszálba és folytatja a futást.
Ez szépen fut is egy darabig aztán káosz lép fel....(utóbbi változó idő után van amikor egyből) -
don_peter
senior tag
Srácok és lányok
Nem tartozik ide szorosan, de hátha nem köveztek meg egy ilyen kérdésért.
A lényeg, hogy C programozásban gondolkodom vagy is valószínűleg komolyabban is bele fogom ásni magam a dolgokba.
Ezzel kapcsolatos főiskolai szakokat keresgélek, de nem tudom mi lenne nekem a legmegfelelőbb.
Mind ezt természetesen annak tudatában kellene megválasztanom, hogy az a jövőre nézve is ("ha egyáltalán beszélhetünk még jövőről") értékes ismeretekkel gyarapítson, tehát a munka, elhelyezkedésemet szemelőt tartva biztos egzisztenciám legyen.
Tehát, olyan szakot kellene választanom, ami jelenleg és későbbiekben is keresett lesz.
Van esetleg ötletetek, elképzelésetek milyen szakot válasszak?
Esti vagy levelezői lesz a megfelelő, hogy finanszírozni is tudjam a tanulmányaimat.Web programozásban már vannak ismereteim: HTML, CSS, PHP, SQL, JS...stb.
-
-
don_peter
senior tag
Pfff ez az egész kusza kicsit.
Találtam közben ezt, de valamiért túl sok nekem egyszerre. [link]
Tömör és nem értem mit hogyan...
Amit értek:
Mi 10-es számrendszerben számolunk mindent, vagy is ez az alap számunkra.
Ez eddig stimmel?A 2-es számrendszerbe átszámolni valamit, mondjuk 8bit-et a példa kedvéért:
2 a 7.-en, 2 a 6.-on, 2 az 5.-en ... 2 a 0.-on.
Ez bináris példában: 0000 1100 = 8 + 4 == 12
Ez eddig stimmel?Ha stimmel akkor eddig értem a dolgot.
De a többi egyelőre homály.
Szeretném én úgy megérteni, hogy ne keljen táblázatból lesnem az értékeket.ui: a srácok jelző lehet idősebb is mint pl én és lehet ezért is nem fog már rendesen az agyam
Azt most már tudom, hogy melyik milyen számrendszerben van.
Bináris (2-es)
Oktális (8-as)
Decimális (10-es)
Hexadecimális (16-os)10bit 2-es hatványát kell venni nem? Mármint 10-esből 2-esbe átszámolásnál.
Persze csak, ha binárisban van a szám.
Lehet, hogy ez sem tusom..
Rendet kellene tennem az agyban ezekkel kapcsolatban mert enélkül nem léphetek tovább. -
don_peter
senior tag
Srácok kérnék egy kis segítséget, hogy megértsek valamit.
Tanulom ezt a C nyelvet és elakadtam a bináris és oktális átszámolásnál.
Nem értem ezeket:Bináris = oktális
... 000 011 = 03
... 000 110 = 06
... 001 100 = 014A bináris ábrázolások 32bit-en kell elképzelni és nem értem miként jönnek ki az oktális eredmények.
Valaki elmagyarázná?
A könyv nem ad számomra elégséges magyarázatot az átszámolására.
Előre is köszi. -
don_peter
senior tag
Tömb kezeléssel kapcsolatos:
Közben sikerült eljutnom odáig, hogy elolvassam a linkelt írásodat.
Most úgy oldottam meg segítséggel a dolgot, hogy egy függvénynek átadom a kellő paramétereket (float) és a feldolgozás (string-é alakítás) végén feltölt egy tomb-öt (amit a program elején "volatile unsigned char szamok[10]" változóként deklarálok) az eredménnyel.
Aztán ahol kell ott pedig kiíratom string-ként printf() %s megadásával.Az írásodban viszont arra hívod fel a figyelmet, hogy ne használjuk ezen megoldást.
Vagy nem jó értelmeztem? (globális változók)
Jó az elmélet vagy a globális változó miatt ez gondot okozhat nekem? -
don_peter
senior tag
Kíváncsi vagyok a véleményetekre:
void float_to_str(float szam){
printf("Kezdő szám: %f\n", szam);
unsigned int i = 0, x = 0, tizedes = 0;
static char szamok[8];
long int intszam = 0;
if (szam-(int)szam > 0){ //egész vagy sem
//ha lebegőpontos
while(szam-(int)szam != 0){//amég nem egész
szam = szam * 10;
i++;
tizedes = i;
}
intszam = szam;
printf(" Felszorzott szám: %li\n Hányszor futott le: %i\n Tizedes: %i\n", intszam, i, tizedes);
i = 0;
while(intszam > 0){//addig osztunk amég nagyobb intszam mint nulla
szamok[i] = intszam % 10;
intszam = intszam / 10;
i++;
}
printf(" Szétszedve: ");
x = i; // x változóba töltjuk az i változót, hogy késöbb is felhasználható legyen az i értéke
while(i){
printf("%i,", szamok[i---1]);
}
printf("\n");
printf("Eredmény: ");
while(x){
if(x == tizedes)
printf(".");
printf("%i", szamok[x---1]);
}
printf("\n");
}else{
printf("Ez egy kerek szám, nincs művelet.\n");
}
}
Mai függvényen belül indítjuk:
float_to_str(12.34567);Eredménye:
Kezdő szám: 12.345670
Felszorzott szám: 12345669
Hányszor futott le: 6
Tizedes: 6
Szétszedve: 1,2,3,4,5,6,6,9,
Eredmény: 12.345669Véleményetek szerint jó és hatásos a megoldásom?
Az eredményből látszik mikor mit tesz a program.
Az elmélet az, hogy, ha beadok egy lebegőpontos számot akkor azt valamilyen megoldással string-é alakítsam, és átalakítás után újból kiírassam.
Hogy teljes legyen a kép ez azért szükséges a számomra mert a végeredményt nem kezelhetem "float" lebegőpontos számként mert az eszköz amin kiíratom az eredményt nem hajlandó a float típusokat megjeleníteni.
Nézzétek ezt a kódot úgy, hogy alig 3napja kezdtem el tanulni a C-t szóval nem ismerem behatóan a nyelvet. -
don_peter
senior tag
Ezen elven kezdtem el agyalni:
void float_to_str(float szam){
int number, mennyi = 0, i = 0, tizedes = 0, oszto_tomb[8];
if(szam < 10)
tizedes = 1;
else if(szam < 100)
tizedes = 2;
else if(szam < 1000)
tizedes = 3;
else if(szam < 10000)
tizedes = 4;
else
printf("Ez a szám már túl nagy.");
number = szam * 100000;
while(number != 0) {
oszto_tomb[i] = number % 10;
printf("%i, ", oszto_tomb[i]);
number = number / 10;
mennyi = i;
i++;
}
printf("\n");
for(i = mennyi; i >= 0; i--){
if(i == (mennyi+1)-tizedes)
printf("%i.", oszto_tomb[i]);
printf("%i", oszto_tomb[i]);
}
printf("\nHány karakter: %i\n", mennyi+1);
}
//kiíratása a main függvényen belül
float_to_str(12.34567);Ez nádjából jól működik amíg 10-nél nem kisebb a lebegőpontos szám amit beadok neki.
Így néz ki egy kimenet:
7, 6, 5, 4, 3, 2, 1,
12.234567
Hány karakter: 7
12.234567 (mondjuk valamiért itt 2db 2-es látszik pedig csak 1 van a sorozatban)
A lényeg látszik belőle, hogy mit is szeretnék.
Ez hogy lehet hatékonyabban megoldani? -
don_peter
senior tag
Értem és igazad is van, és ahogy te is írtad szigorúan számról van szó.
Most például azon agyalok, hogy mi van abban az esetben, ha mondjuk lebegőpontos számot akarok az előzőkben leírtak szerint szétszedni majd újból összerakni, hogy azt miként kell elvégezni.
Mondjuk van egy float szam = 13.45445667; számom akkor ezt, hogy bontom le egyesével és akár egy tömbbe is aztán meg újból összerakni.
Ennél már lehetne alkalmazni a string-es megoldást, sőt az lenne a legjobb.
Tehát egy lebegőpontos számot string-é alakítani..
Ez is megoldható egyébként?ui: ezt a számot mondjuk egy program eredménye képen kapnám, tehát nincs beviteli rész.
-
don_peter
senior tag
sprintf-nél még nem járok.
Még csak a változó típusokat, függvényeket, ciklusokat és a tömböket olvastam végig.
Van még bőven mit olvasnom
550oldalas a könyv és még csak a 160. oldalnál járok, de szeretem a leírtakat gyakorlatban is kipróbálni és szeretném azok működését magam is megírni és megérteni.
Az nem kivitelezhető egyerűen, hogy megfordítás nélkül szétválasszuk a bevitt értéket? (egész számot)
Pl: 123456 = 1,2,3,4,5,6
Mindenképp a helyes út a vissza osztás és a maradék eltárolása és ezen folyamat újra és újra forgatása míg nem teljesen meg nem kapjuk egyesével a számokat? -
don_peter
senior tag
Az eredeti példa programban így szedi szét a program.
Ez egy gyakorló feladat volt és azt gondoltam kicsit tovább és ilyen szárnycsapkodásként tanulok belőle.
Kérhetek egy olyan kódrészt tőled amely a következőket demonstrálja?
123456 (ezt a számot szedjük szét és egyesével vesszővel elválasztva írassuk ki)
Eközben számoljuk meg mennyi külön álló karaktert (vagy ha jobban tetszik számot) tartalmaz és ezt is irassük ki.
És a végén ismét rakjuk össze a számot 1egy egésszé.Ez így nézne ki lefutáskor:
123456
1, 2, 3, 4, 5, 6
Hány szám: 6
Újra össze rakva: 123456Köszi előre is a példa kódot.
-
-
don_peter
senior tag
válasz
Jester01
#4452
üzenetére
Thanks a segítséget:
for(i = mennyi; i >= 0; i--){
if(i == 0)
ossz += right_digit[i];
else
ossz = (ossz + right_digit[i]) * 10;
}ui: Köszi de őszintén szólva Karma bejegyzése inkább félrevezetett mint rá
Ezt ne vedd sértésnek Karma
Jester01-nek megy a pont
Köszi, most sokat tanultam... -
don_peter
senior tag
válasz
Jester01
#4448
üzenetére
Ehhez is ismerni kell a bevitt érték nagyságát nem?
"(((a*10)+b)*10+c)*10+d" mert ez összesen csak 4 változó értékét tudja felszorozni és összeadni.
Én most így oldottam meg:int number, right_digit[5], i = 0, mennyi = 0, ossz = 0;
printf("Adj meg egy számsort (1-100e közt): ");
scanf("%i", &number);
printf("Visszafelé: ");
while(number != 0) {
right_digit[i] = number % 10;
printf("%i, ",right_digit[i]);
number = number / 10;
mennyi = i;
i++;
}
printf("\n");
for(i = mennyi; i >= 0; i--){
if(i == 4)
ossz += right_digit[i] * 10000;
else if(i == 3)
ossz += right_digit[i] * 1000;
else if(i == 2)
ossz += right_digit[i] * 100;
else if(i == 1)
ossz += right_digit[i] * 10;
else if(i == 0)
ossz += right_digit[i];
else
printf("Maximum 99999-et lehet megadni!\n");
}
printf("Hány karakter: %i",mennyi+1);
printf("\nÖssz érték: %i\n", ossz);Kimenete:
Adj meg egy számsort (1-100e közt): 344
Visszafelé: 4, 4, 3,
Hány karakter: 3
Össz érték: 344 -
don_peter
senior tag
válasz
Jester01
#4446
üzenetére
A legegyszerűbb dolgok a leg-kézenfekvőbbek.
Bonyolultabban akartam megoldani és ez volt a hiba.
Itt meg már egy saját kis függvény meg eldönti, a számok számából, hogy mennyivel kell elkezdeni szorozni és utána már mehet vissza felé szépen a dolog.
Picit még parázok ettől a nyelvtől.Az strlen -re akkor gondolom érdemes egy saját rutint írni bár gondolom majd az is lassú lesz.
A string-ek esetében még mondjuk jó is, de ha számokat akarok megszámolni már parásabb a helyzet.
Vagy erre meg jó ez a megfordító dolog, csak a végeredmény majd a szétválasztott számok száma lesz és meg is van számolva -
don_peter
senior tag
válasz
don_peter
#4444
üzenetére
Ezzel a tömbös megoldással megoldottam, de itt még nem kellene járnom szóval egyszerűbb megoldás létezhet a dologra?
És itt még felmerül a kérdés, hogy tudom megnézni egy adott változóban mennyi karakter vagy számjegy van.
Szóval a = 123;
Akkor ennek a karakter hossza 3db.
Ezt PHP-ben strlen() függvénnyel szépen le lehet kérni.
Itt is van ilyesmi?
Mert a tömbömnek meg kellene adni mekkora legyen és így automatizált lehetne a dolog.
Bár lehet rosszúl gondolkodom, de PHP-nél ez kézenfekvő volt.int number, right_digit[5], i = 0, mennyi = 0;
printf("Adj meg egy számsort: ");
scanf("%i", &number);
while(number != 0) {
right_digit[i] = number % 10;
printf("%i, ",right_digit[i]);
number = number / 10;
mennyi = i;
i++;
}
printf("\n");
for(i=mennyi; i>=0; i--){
printf("%i",right_digit[i]);
}
printf("\n");Illetve a 2. pontban lévő kérdésemet még mindig nem tudtam megoldani.
pl.: 1 2 3 4 = 1234 -
don_peter
senior tag
válasz
alapz@j
#4443
üzenetére
Srácok ez ugyan nem életbe vágó, de nekem még is érdekes lehet.
Van egy kódom ez ügye azt csinálja, hogy amit beviszel pozitív egész számokat azokat megfórdítva írja egymás mellé.
Ime:int number, right_digit;
printf("Adj meg egy számsort: ");
scanf("%i", &number);
while(number != 0) {
right_digit = number % 10;
printf("%i, ",right_digit);
number = number / 10;
}
printf("\n");2 dolog érdekel: (most kezdtem el a dolgot szóval nem vagyok még jártas a témában)
1. hogyan tudom azt megcsinálni a legegyszerűbben, hogy a számokat ugyan abban a sorrendben írja ki egyesével ahogyan azt én megadom.2. ezt teljesen külön: hogyan tudnám a szétszedett láncot újra egyesíteni úgy hogy azt egy egésznek vegye a rendszer? (pl.: 1 2 3 = 123)
Köszi előre is a segítséget. -
don_peter
senior tag
Srácok OSX alatt szeretnék C-ben programozni illetve tanulni a nyelvet.
Tudnátok ajánlani fejlesztői környezetet amit könnyű használni és fordít is?
Drag en Drop fejlesztők nem érdekelnek.
Xcode és a Code Wariors-t nézegetem, de nem tudom melyik verziót érdemes beszereznem belőlük.
Kérném segítségeteket, hogy jól válasszak.
Stephen G. Kochan könyvéből szeretnék lépésről lépésre tanulni és a feladatokat elvégezni.
Köszi előre is. -
don_peter
senior tag
válasz
Peter789
#4377
üzenetére
Az előző hozzászólásomban rosszul írtam a 10-es számrendszert.
Helyesbítés: 10bit-es számot kapok vissza értékként 2-es számrendszerbenKözben megoldottam a feldolgozást és kiíratást.
A float mint lebegőpontos változó nem tetszett az LCD-t vezérlő driver-nek, így külön kellett hozzá írni egy rutint amely égésszámmá konvertálja a törtet majd egy long változóba tölti, ezek után utána összarakja beleírva a megfelelő helyre egy pontot (ez a pont lesz a tizedest elválasztó) és string-ként kiírja az LCD display-re.
Nem volt egyszerű, de kis segítséggel ez is megoldódott.
Jöhet a digitális bemenet és a digitális jelek feldolgozása -
don_peter
senior tag
válasz
Peter789
#4377
üzenetére
Sajnos nem tudtak segíteni a hobbielektronikán, vagy csak azt akarták, hogy én kínlódjam ki a megoldást
Közben kiderült, hogy mindenképpen a bejövő analóg jelet konvertálni kell mert más ként nem lesz megjeleníthető formába így nem vált láthatóvá.
A program amit linkeltem részben jó volt, de a konverterek nem voltak benne így nem tudott vissza adni értéket.
Megkaptam 10-es számrendszerben a potméter jelét szóval faszányos a dolog.
Most már csak az alap matematikai műveleteket kell elvégezzem, csak még nem tudom, hogy kell ezeket deklarálni, mert simán beírva a műveletet 0-át ad vissza.
Köszi a segítséget. -
don_peter
senior tag
válasz
don_peter
#4375
üzenetére
Bocs, de most meg a kijelző nem akart menni
Azt beizzítottam szóval le próbáltam a dolgot.
1K ellenállással rávittem az 5v-ot a PIC A0-ás lábára.
Analógra és bemenetre van állítva ezt lecsekkoltam szóval elvileg működnie kellene, de az érték 0 marad és nem változik ha rárakom és, ha leveszem akkor sem. -
don_peter
senior tag
válasz
Peter789
#4372
üzenetére
Nah igen ha így vesszük, igazad van, de még sem egy drag-and-drop-os (fogd és húzd) megoldással dolgozom
Egy kezdőnek a C nyelvezet így is elég bonyolultnak tűnik, nem beszélve a mikroprocesszorok programozásáról és azok ismeretéről.
Természetesen minden lefut és lefordul, fel is égetem a PIC-et, de 0 értékkel jön vissza.Az A0-ás analóg bemeneten van egy 10K-os állítható értékű ellenállás vagy POTI és az 5v-ot szabályzom vele le s fel.
Reakció 0... -
don_peter
senior tag
válasz
Peter789
#4370
üzenetére
Köszönöm az ajánlásokat, de én még az a programozó vagyok aki a kódokat szereti látni és megtanulni őket leírni
Természetesen megy az élesztés és kisebb programokat már írtam is mint pl.: while ciklusok számolása, nyomógombok használata magas és alacsony szintetek beállítása és kezelése, ledek villogtatása vagy éppen csak kapcsolgatása, és természetesen mindezek értékeit LCD-re kiíratom folyamatos frissítéssel.Alap programozói tapasztalataim a webes irányzatból vannak így némileg el tudok gravírozni az egyes főbb függvények közt. (HTML, CSS, JS, PHP SQL ismereteim vannak)
A gondom az hogy elakadtam az analóg jelek bekérésénél és azok feldolgozásánál.
Egyenlőre beállítom a PIC A0-ás lábára, hogy analóg bemenet legyen és a beépített ReadADC() függvénnyel próbálom kiolvasni a rákerülő jeleket.A fő program része:
#include <p18f4550.h> //chip beállítása
#include <stdio.h> //I/O portok beállítása
#include <delays.h> //Időzítő
#include <tesztheader.h>
#include "lcd.c"
#include <adc.h>
#define ANALOG_IN ADC_CH0 //a potméter AN0-ra csatlakozik
volatile unsigned char a;
void main(){
lcd_init(); // Az LCD modulinicializálása
lcd_init_cgram(); // Az ékezetes betűk feltöltése
stdout = _H_USER; // Az LCD legyen a standard kimenetnt
TRISAbits.TRISA0 = 1; //analog A0 láb legyen bemenet
ADCON0=0b00000001;
OpenADC(ADC_FOSC_64 | ADC_RIGHT_JUST | ADC_20_TAD, ANALOG_IN | ADC_INT_OFF | ADC_REF_VDD_VSS, ADC_2ANA);
TRISBbits.TRISB7 = 0;
LATBbits.LATB7 = 1;
while(1){
a=0L;
Delay10TCYx(80);
a = ReadADC();
printf("Valami %u", a);
lcd_write(0xC0,0,1,1);
}
}
Elviekben a header állományban minden deklarálva van ami szükséges lehet mivel a program nem figyelmeztet, hogy hiányolna valamit
Előre is köszi a segítséget. -
don_peter
senior tag
Uraim, PIC programozásban jártas C-és emberkét kérdeznék, faggatnák ha segítene.
MPLAB C18 környezetben fejlesztenék, persze mint kezdő és segítségre lenne szükségem, hogy megértsem mit miért és hogyan lehet megoldani.
PIC18F4550-chipel Analóg és Digitálisan beküldött jeleket szeretnék fogadni és azok kiértékelése után egy LCD kijelzőre kiírni az eredményeket. (Analog jelet egy AD849x chip küldené a Digitálisat pedig egy MAX6675-ös. Ez mind kettő K típusú hőszenzor mérésére van.)
Van már sok próbálkozás mögöttem, de nem jutok előrébb és az angol dokumentációk sem tudtak kisegíteni.
Előre is köszönöm az esetleges segítséget.
Ú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!
- Új Gamer PC - Ryzen 7 5700X / RTX 5060 / A520M / 16GB vagy 32GB RAM / 240GB + 1TB M.2 SSD / 650W
- Samsung Galaxy Z Fold 4 256 GB, szürkészöld + S Pen tok
- TP-Link ER-7212PC Omada 3-in-1 Gigabit VPN Router
- TP-Link EAP Omada Wifi AP-k (225, 245, 615)
- Mars Gaming ML-LCD240 2x ARGB 120mm FDB Fan LCD Display (Alkatrésznek) INGYEN FOXPOST
- Samsung Galaxy A13 64GB, Kártyafüggetlen, 1 Év Garanciával
- DELL PowerEdge R630 rack szerver barebone - 2xSocket 2011v4 , 24x DDR4 DIMM, H330 RAID, 39369Ft+ÁFA
- Keresünk dokkolókat
- Akciós Windows 10 / 11 Pro OEM Licenc Kulcs 100% eredeti, jogtiszta!
- Tablet felvásárlás!! Apple iPad, iPad Mini, iPad Air, iPad Pro
Állásajánlatok
Cég: PC Trade Systems Kft.
Város: Szeged
Cég: CAMERA-PRO Hungary Kft
Város: Budapest