PIC kezdőknek - Hobbielektronika.hu - online elektronikai magazin és fórum

(#)	mps válasza _BiG_ hozzászólására (»)	Feb 18, 2018		/

Köszi a választ!
Ezeket néztem. mint írtam, ha angolra állítom a win.-ben a beviteli nyelvet nincs is semmi gond. De ha magyar akkor ezt a két karaktert nem találom. Magyarnál viszont a + és az ö jön.Ha az x-et küldöm a jobb alt-al, akkor meg ű. A többi a helyén van.(Pedig már kínomban írtam egy pascal progit is. Na ott valamiért a 0-ra 96 jön vissza.) Mondjuk ami nekem még fura, hogy többféle táblázatot találtam, pl az első linkeden a 0 az 0x0b a másodikon (ezt még nem láttam) 0x45 ezen pedig 0x27.
A # még kacifántosabb, mert vagy jobb altot vagy shiftet is "nyomni" kell mellé.

(#)	_BiG_ válasza mps hozzászólására (»)	Feb 18, 2018		/

Akkor feltöltöm a Microsoft ™©®֍֏ stb-stb saját doksiját, szintén gugli barátom tálalta.
Ebben a különböző billentyű-elrendezések vannak részletezve, hogy a winfos miként kezeli őket.
Réges-régen kellett írnom programot (suliban), ami a scan-kódokat használta, nem a BIOS-on át vette a bevitt karaktereket. Akkor megoldottam. Itt se lehet vele gond, hiszen a hardver ugyanaz.

Idézet:
„ha angolra állítom a win.-ben a beviteli nyelvet nincs is semmi gond. De ha magyar akkor ezt a két karaktert nem találom. Magyarnál viszont a + és az ö jön.”

Fel kell készíteni a programot az eltérő beállításokra. De, mint mondám, ha jól emlékszem, a billentyűzet küld valami scan-kódot, azt az oprendszer kezeli le, helyettesíti be a megfelelő karakter ASCII kódját. Neked nem az ASCII-kód kell, hanem a scan kód, ami a csatin kibuggyan. Elvileg az csak billentyűzet-függő (hány gombos, stb). Tehát rittyents egy progit, ami közvetlenül kiolvassa és aszerint te kezeld le, mit kezdesz vele. Ja, és persze a PIC-re kell megírni, a vett kódot soros vonalon küldd be a PC-be, és láthatod. Mintha tettem volna fel ide pár hónapja linkeket, hogy milyen elektronika kell a billentyűzet-PIC összekötéshez.
Keress rá a nevemre.

scancode.pdf

(#)	mps válasza _BiG_ hozzászólására (»)	Feb 18, 2018		/

Köszi! Átnézem ezt a doksit is.
Amúgy lehet nem teljesen egyértelműen írtam a gondom. Soros porton jön egy adat, ezt kell a pc felé küldenem mintha egy billentyűzet lenne rákötve. A pic-ben csinálom az ASCII-scan konverziót. Ez működik is amíg a gépen a win beviteli nyelve az angol. Ill. nem akarok nullát vagy # küldeni. Egyedül ezt a két karaktert nem sikerül konvertálni. Elméletileg ezek a billentyű kódok az ősidőktől megvannak. Az érdekel, hogy a win mit szeretne kapni, és első ránézésre a küldött doksi jó is lesz erre

(#)	pajti2 hozzászólása	Feb 18, 2018		/

Anno kérdeztem, kinek milyen gányolási tapasztalata van USB töltőkkel. Azóta beleakadtam egy általános teszter oldalba is. Némelyik tényleg szörnyű

Bővebben: Link

(#)	sparowjoe válasza Bakman hozzászólására (»)		Feb 19, 2018		/

Igen tisztelt Bakman!

Valami ehhez hasonló a dolog.
Kérhetek valami infó hogy mi tudja ezt?

(#)	pipi válasza mps hozzászólására (»)	Feb 19, 2018		/

Hali!
Nem világos miért nem tudod konvertálni...
A scan kódok a billenytű gomb helytől függenek, nem a nyelvi beállítástól
fenti pdf 11. oldal
29 scan(vagy a 01scan), angol ~ , magyar 0
02 scan angol/magyar 1
0a scan, angol/magyar 9
0b scan, angol 0, magyar ö
vagyis a 0-hoz angol módban 0b scant kell küldened, magyar módban meg 29-et.
A # bonyolultabb, kikeresed melyik helyen van(2d?), és egy alt gr nek megfelelő scan-t is kell küldeni nyomást előtte/utána elengedést...
Lehet a pdf valami régebbi cucc, én úgy látom a bal felső 110dec az inkább a 01hex, a második sor első meg 1 helyett 29hex scannak kellene lenni...
Szerintem...

A hozzászólás módosítva: Feb 19, 2018

(#)	Elektro.on válasza mps hozzászólására (»)	Feb 19, 2018		/

Esetleg még ez segíthet:

Bővebben: Link

(#)	mps válasza pipi hozzászólására (»)	Feb 19, 2018		/

Számomra sem világos, ennek egyszerűnek kellene lennie mint egy faék. De most "megoldódott", akinek csináltam jó az angol is. Viszont ha lesz egy kis időm, előveszem mert izgat. Ha másként nem megy akkor végiglépkedek minden kódon,meg minden módosító billentyűn.
Köszi mindenkinek a segítséget!

(#)	DJozso hozzászólása	Feb 20, 2018		/

Kedves elektronika szerető fórum társaim! Komoly fába vágtam a fejszém, most viszont elakadtam. Gondoltam, itt hátha van olyan, aki csípőből megoldja a problémám. Vagy csak megjelölné a helyes utat.
MikroC fejlesztő környezetben próbálok életre kelteni egy kapcsolást, mely tartalmaz egy 18f46k22 kontrollert és egy HC06-os bluetooth modult. A két egység soros kommunikációval(USART) beszélget.
Célom, hogy egy okos telefonról parancsokat küldjek a piknek. A problémám a következő:
Csatlakozom a telefonnal a bluetooth modulhoz, Bluetooth Terminal nevű programmal, melyet a Play áruházból töltöttem le. Ezzel tudok adatot küldeni/fogadni, amit látok a telefon kijelzőjén. Irtam egy programot, a fent említett kontrollerbe, hogy ha a tx lábra adat érkezik (RCREG), megszakítás keretében dolgozza fel az adatot, egy tömbbe, egymás után szépen sorba...
Majd ha vége a bejövő adatnak, akkor küldje vissza a xy nevű tömb tartalmát az rx lábon keresztül a bluetooth modulra.
A forráskód:

#define LED PORTD.F0
unsigned char Szoveg[10] ;
unsigned short Rx_KarakterSzam = 0, Vissza_Kuldes = 0, Rx_KarakterSzam_Last = 0;
void Config_PIC(){
OSCCON.F4 = 1; //64Mhz órajel beállítás
OSCCON.F5 = 1; //
OSCCON.F6 = 1; //
OSCTUNE.PLLEN = 1; / INTERNAL RC OSC 16MHZ * 4
TRISA = 0xFF;
TRISB = 0xFF;
TRISC = 0b10010111;
PORTC = 0;
TRISD = 0b11111100;
PORTD = 0;
TRISE = 0xFF;
ANSELA = 0;
ANSELB = 0;
ANSELC = 0;
ANSELD = 0;
ANSELE = 0;
INTCON = 0xC0; //Glob.int, Perf. int, TMR0 int
PIE1 = 0x20; //Tx int.
PIR1.RC1IF = 0;
UART1_Init(9600);
delay_ms(100);
BAUDCON1.BRG16 = 1; // Ezeket a beállításokat egy másik forráskódban találtam,
TXSTA1.BRGH = 1; // gondoltam, hátha ezek működnek ha már a bitráta itt is 9600.
SPBRGH1 = 0x06; //
SPBRG1 = 0x82;
RCSTA1.SPEN = 1;
RCSTA1.CREN = 1;
TXSTA1.TXEN = 1;
RCON.IPEN = 1; //High piority interrupt
IPR1.RC1IP = 1;} //Transmitter soros port
void Interrupt(){
if (PIR1.RC1IF == 1) {
// Szoveg[Rx_KarakterSzam] = RCREG1-1;
if (RCSTA1.OERR == 1 | RCSTA1.FERR == 1) { // Ha hiba lenne az átvitelnél
RCSTA1.CREN = 0; //Hiba esetén a CREN bit ki, be kapcsolása
RCSTA1.CREN = 1; //
Rx_KarakterSzam = 0; //Tömb elejére ugrás
Vissza_Kuldes = 2;} // Hiba Visszaküldése
else { // Ha minden "OK"
Szoveg[Rx_KarakterSzam] = UART1_Read();
Rx_Karakterszam++;}
if ( UART1_Tx_Idle() == 1 & Rx_KarakterSzam > 0 ) {// Ha vége van az adat fogadásnak
Szoveg[Rx_KarakterSzam+1] = 0; // tömb utolsó üres karakterének írása, hogy a tömb mérete kiolvasható legyen
Rx_KarakterSzam = 0; // Tömb elejére ugrás
Vissza_Kuldes = 1;}// Visszaküldés paramétere
PIR1.RC1IF = 0;
PIE1.RC1IE = 1;}}
void main() {
Config_PIC();
while(1){
if (Vissza_Kuldes != 0) {
if (Vissza_Kuldes == 1){
UART1_Write_Text(Szoveg);// tömb vissza küldése
Vissza_Kuldes = 0;}
if (Vissza_Kuldes == 2) {
UART1_Write_Text("Olvasasi hiba!"); // hiba kuldes
Vissza_Kuldes = 0;}
if (Szoveg[0] == 'B' & Szoveg[1] == 'e' ) LED = 1; //Led be kapcsolása
if (Szoveg[0] == 'K' & Szoveg[1] == 'i' ) LED = 0;}}} //Led ki kapcsolása

A mellékelt usart beállításokkal a pic doksija szerint a frekvencia hiba (Eltérés a várt 9600-hoz képest) 0,16%! Szóval azt csinálja a drága, hogy küldök neki egy számsort (mondjuk 0-9ig), és a válaszba beleszúr olyan számot, ami nem volt ott. Pl.: 0123456789 elküldve a válasz:0123545678;De nem mindig ugyanazt küldi vissza. Van hogy az utolsó két karakter hiányzik. Vagy két lépcsőben küldi vissza: 012 elsőként, a többit utána másik "csomagként". Amit a bluetooth modul alapbeállításairól sikerült megtudnom: Baud: 9600, 8 bites adatszélesség, aszinkron adat, no parity bit, 1 széles stop bit. Tudom, hogy néha előfordul a kommunikációban hibás adat, de ilyen sűrűn azért nem. Véleményem szerint, valami adatátviteli sebesség probléma, de fogalmam sincs mit néztem el az adatlapon.... Minden segítséget nagyon szépen köszönök!

A hozzászólás módosítva: Feb 20, 2018

(#)	Hp41C válasza DJozso hozzászólására (»)	Feb 20, 2018		/	1

Az adást is megszakításosra írd meg. Vegyél fel egy adási puffert. Ha valamit el akarsz küldeni, írd be a bufferbe. Ne használd a UART1_Write_Text() eljárást.

(#)	DJozso válasza Hp41C hozzászólására (»)		Feb 20, 2018		/

Ha jól emlékszem, adatlapon olvastam, hogy ilyen regisztere van a pic-nek(nem tudom mindegyiknek van-e). Mi fogja elindítani a megszakítást? Az, hogy ennek a regiszternek értéket adok, amit küldeni kell?

(#)	kissi válasza DJozso hozzászólására (»)	Feb 20, 2018		/	1

Szia!

Az indítja el, hogy feltöltöd a buffert, majd engedélyezed a megszakítást ( innen tud autmatikusan működni az egész!) és az utolsó adat után tiltod a megszakítást !

(#)	DJozso válasza Hp41C hozzászólására (»)	Feb 20, 2018		/

Szia! Megírtam, de valami nem jó, mert így nem is küldd semmit. A küldéshez szükséges beállításokat szerintem beállítottam (többször átnéztem). A kód:

#define LED PORTD.F0
unsigned char Hiba[] = "Olvasasi hiba!" ;
unsigned char Szoveg[10] ;
unsigned short Rx_KarakterSzam = 0, Vissza_Kuldes = 0, KarakterSzam_Tx = 0, Karakter_Tx = 0, Ciklus;
void Config_PIC(){
OSCCON.F4 = 1; //64Mhz órajel beállítás
OSCCON.F5 = 1; //
OSCCON.F6 = 1; //
OSCTUNE.PLLEN = 1; // INTERNAL RC OSC 16MHZ * 4
TRISA = 0xFF;
TRISB = 0xFF;
TRISC = 0b10010111;
PORTC = 0;
TRISD = 0b11111100;
PORTD = 0;
TRISE = 0xFF;
ANSELA = 0;
ANSELB = 0;
ANSELC = 0;
ANSELD = 0;
ANSELE = 0;
INTCON = 0xC0; //Glob.int, Perf. int, TMR0 int
PIE1 = 0x30; //Tx int., RX int
PIR1.RC1IF = 0;
PIR1.TX1IF = 0;
UART1_Init(9600);
delay_ms(100);
BAUDCON1.BRG16 = 1;
TXSTA1 = 0x24; // TXEN = 1 és SYNC = 1
SPBRGH1 = 0x06; //
SPBRG1 = 0x82;
RCSTA1.SPEN = 1;
RCSTA1.CREN = 1;
RCON.IPEN = 1; //High piority interrupt
IPR1.RC1IP = 1;} //Transmitter soros port
void Interrupt(){
if (PIR1.TX1IF == 1) {
PIR1.TX1IF = 0;
PIE1.TX1IE = 1;}
if (PIR1.RC1IF == 1) {
if (RCSTA1.OERR == 1 | RCSTA1.FERR == 1) { // Ha hiba lenne az átvitelnél
RCSTA1.CREN = 0; //Hiba esetén a CREN bit ki, be kapcsolása
RCSTA1.CREN = 1; //
Rx_KarakterSzam = 0; //Tömb elejére ugrás
Vissza_Kuldes = 2;} // Hiba Visszaküldése
else { // Ha minden "OK"
Szoveg[Rx_KarakterSzam] = RCREG1;
Rx_Karakterszam++;}
if ( UART1_Tx_Idle() == 1 & Rx_KarakterSzam > 0 ) {// Ha vége van az adat fogadásnak
Szoveg[Rx_KarakterSzam+1] = 0; // tömb utolsó üres karakterének írása, hogy a tömb mérete kiolvasható legyen
Rx_KarakterSzam = 0; // Tömb elejére ugrás
Vissza_Kuldes = 1;}// Visszaküldés paramétere
PIR1.RC1IF = 0;
PIE1.RC1IE = 1;}}
void main() {
Config_PIC();
while(1){
if (Vissza_Kuldes != 0) {
if (Vissza_Kuldes == 1){
KarakterSzam_Tx = strlen(Szoveg); //Karakter számlálás
for (Ciklus = 0; Ciklus <= KarakterSzam_Tx; Ciklus++){
Karakter_Tx = Szoveg[Ciklus];
TXREG1 = Karakter_Tx; // TxReg írása
while(TXSTA1.TRMT == 0);} //Várj, míg TSR teli van
Vissza_Kuldes = 0;}
if (Vissza_Kuldes == 2) {
KarakterSzam_Tx = strlen(Hiba); //Karakter számlálás
for (Ciklus = 0; Ciklus <= KarakterSzam_Tx; Ciklus++){
Karakter_Tx = Hiba[Ciklus];
TXREG1 = Karakter_Tx; // TxReg írása
while(TXSTA1.TRMT == 0);} //Várj, míg TSR teli van
Vissza_Kuldes = 0;}
if (Szoveg[0] == 'B' & Szoveg[1] == 'e' ) LED = 1; //Led be kapcsolása
if (Szoveg[0] == 'K' & Szoveg[1] == 'i' ) LED = 0;}}} //Led ki kapcsolása

Rá tudna nézni valaki, mi lehet a baj?
Kissi: Most látom írtál. Értem, mit mondasz, megpróbálom így átírni a kódot.

A hozzászólás módosítva: Feb 20, 2018

(#)	DJozso válasza DJozso hozzászólására (»)	Feb 20, 2018		/

kissi: Javítottam a kódot, ahogy mondtad, mégsem küldd vissza semmit.
A javított kód:

#define LED PORTD.F0
unsigned char Hiba[] = "Olvasasi hiba!" ;
unsigned char Szoveg[10] ;
unsigned short Rx_KarakterSzam = 0, Vissza_Kuldes = 0, KarakterSzam_Tx = 0, Karakter_Tx = 0, Ciklus;
void Config_PIC(){
OSCCON.F4 = 1; //64Mhz órajel beállítás
OSCCON.F5 = 1; //
OSCCON.F6 = 1; //
OSCTUNE.PLLEN = 1; // INTERNAL RC OSC 16MHZ * 4
TRISA = 0xFF;
TRISB = 0xFF;
TRISC = 0b10010111;
PORTC = 0;
TRISD = 0b11111100;
PORTD = 0;
TRISE = 0xFF;
ANSELA = 0;
ANSELB = 0;
ANSELC = 0;
ANSELD = 0;
ANSELE = 0;
INTCON = 0xC0; //Glob.int, Perf. int, TMR0 int
PIE1 = 0x30; //Tx int., RX int
PIR1.RC1IF = 0;
PIR1.TX1IF = 0;
UART1_Init(9600);
delay_ms(100);
BAUDCON1.BRG16 = 1;
TXSTA1 = 0x24; // TXEN = 1 és SYNC = 1
SPBRGH1 = 0x06; //
SPBRG1 = 0x82;
RCSTA1.SPEN = 1;
RCSTA1.CREN = 1;
RCON.IPEN = 1; //High piority interrupt
IPR1.RC1IP = 1;} //Transmitter soros port
void Interrupt(){
if (PIR1.TX1IF == 1) {
PIR1.TX1IF = 0;}
if (PIR1.RC1IF == 1) {
if (RCSTA1.OERR == 1 | RCSTA1.FERR == 1) { // Ha hiba lenne az átvitelnél
RCSTA1.CREN = 0; //Hiba esetén a CREN bit ki, be kapcsolása
RCSTA1.CREN = 1; //
Rx_KarakterSzam = 0; //Tömb elejére ugrás
Vissza_Kuldes = 2;} // Hiba Visszaküldése
else { // Ha minden "OK"
Szoveg[Rx_KarakterSzam] = RCREG1;
Rx_Karakterszam++;}
if ( UART1_Tx_Idle() == 1 & Rx_KarakterSzam > 0 ) {// Ha vége van az adat fogadásnak
Szoveg[Rx_KarakterSzam+1] = 0; // tömb utolsó üres karakterének írása, hogy a tömb mérete kiolvasható legyen
Rx_KarakterSzam = 0; // Tömb elejére ugrás
Vissza_Kuldes = 1;}// Visszaküldés paramétere
PIR1.RC1IF = 0;
PIE1.RC1IE = 1;}}
void main() {
Config_PIC();
while(1){
if (Vissza_Kuldes != 0) {
if (Vissza_Kuldes == 1){
KarakterSzam_Tx = strlen(Szoveg); //Karakter számlálás
// PIE1.TX1IE = 1; // Int. engedélyezés
TXSTA1.TXEN = 1; // Int. engedélyezés
for (Ciklus = 0; Ciklus <= KarakterSzam_Tx; Ciklus++){
Karakter_Tx = Szoveg[Ciklus];
TXREG1 = Karakter_Tx; // TxReg írása
while(TXSTA1.TRMT == 0);} //Várj, míg TSR teli van
// PIE1.TX1IE = 0; // Int. kikapcsolás
TXSTA1.TXEN = 0; // Int. kikapcsolás
Vissza_Kuldes = 0;}
if (Vissza_Kuldes == 2) {
KarakterSzam_Tx = strlen(Hiba); //Karakter számlálás
// PIE1.TX1IE = 1;
TXSTA1.TXEN = 1;
for (Ciklus = 0; Ciklus <= KarakterSzam_Tx; Ciklus++){
Karakter_Tx = Hiba[Ciklus];
TXREG1 = Karakter_Tx; // TxReg írása
while(TXSTA1.TRMT == 0);}
TXSTA1.TXEN = 0;
// PIE1.TX1IE = 0;
Vissza_Kuldes = 0;}
if (Szoveg[0] == 'B' & Szoveg[1] == 'e' ) LED = 1; //Led be kapcsolása
if (Szoveg[0] == 'K' & Szoveg[1] == 'i' ) LED = 0;}}} //Led ki kapcsolása

Valami ötlet, mi nem lehet jó?

A hozzászólás módosítva: Feb 20, 2018

(#)	kissi válasza DJozso hozzászólására (»)	Feb 20, 2018		/	1

Az adatot kiküldeni is megszakításból kell, ez így nem jó !!
Feltöltöd a tömböt, engedélyezed a megszakítást, ennyi a főprogram dolga. A megszakításban, ha a PIR1.TX1IF aktív, akkor a tömb következő elemét betöltöd a TXREG-be. Ha a kiküldendő adatok elfogytak, akkor az adási megszakítást tiltod !!

(#)	DJozso válasza kissi hozzászólására (»)	Feb 20, 2018		/

Bocsánat, hogy értetlenkedek, de:
Adott a tömböm, amit szeretnék elküldeni uart-on keresztül. Hogy tudom a tömböt "feltölteni"? A megszakítás engedélyezése az oké...
A megszakításban a TX1IF bitet, mi váltja egyre, mert a megszakítás akkor fut le ? Az, hogy engedélyezem a megszakítást a PIE1.TX1IE bit 1-re állításával? És, ha jól értem a megszakításban kell a tömb elemeit egymás utánban küldeni, míg a TX1IF bit= 1, majd a végén kikapcsolni a PIE1.TX1IE = 0. Jól értem?

A hozzászólás módosítva: Feb 20, 2018

(#)	kissi válasza DJozso hozzászólására (»)	Feb 20, 2018		/	1

Idézet:
„Hogy tudom a tömböt "feltölteni"?”

Biztosítod, hogy a küldendő elemek már benne vannak a megfelelő helyeken

!

Idézet:
„A megszakításban a TX1IF bitet, mi váltja egyre, mert a megszakítás akkor fut le ?”

Maga a hardver jelzi ezzel, ha kész újabb adat fogadására, neked ezt sem beállítani, sem törölni nem kell !!

(#)	DJozso válasza kissi hozzászólására (»)	Feb 20, 2018		/

És az egyes karakterek közt, a TX1IF bit néha átvált 0-ra? Amikor "dolgozik"? Kezdem kapiskálni.Megpróbálom ezen elvek szerint átírni. Addig is köszönöm szépen a segítséget.

A hozzászólás módosítva: Feb 20, 2018

(#)	kissi válasza DJozso hozzászólására (»)	Feb 21, 2018		/	1

Idézet:
„És az egyes karakterek közt, a TX1IF bit néha átvált 0-ra? Amikor "dolgozik"?”

Igen, igen

!

(#)	Hp41C válasza DJozso hozzászólására (»)	Feb 21, 2018		/	1

Még egy apróság:
A PIR1.TX1IF és a PIR1.RC1IF programból nem törölhető.
Az adási megszakításkérése akkor keletkezik, ha az adó kész az új adatra és a megszakítás kérés engedélyezett. Ebből következik, hogy akkor kell engedélyezni, ha van legalább egy adandó adat és le kell tiltani, ha nincs adni való. Ha a TXREG1 -et feltöltöd az új adattal, automatikusan törlődik a TX1IF.
Ugyanígy az RCIF1 is automatikusan törlődik az RCREG1 kiolvasásával, a vevő kikapcsolása viszont nem törli...

RCSTA1.CREN = 0; //Hiba esetén a CREN bit ki, be kapcsolása
WREG=RCREG1;
RCSTA1.CREN = 1;

A hozzászólás módosítva: Feb 21, 2018

(#)	Zekageri hozzászólása	Feb 21, 2018		/

Sziasztok! Lenne egy nagy problémám. Jelenleg egy PICDEM net 2 DEV boardot programozok tanulási céllal. Egy PIC18F97J60-as vezérlő van benne. A microchip egyik demo appját vettem alapul , a webvend-et. Mplab X IDE v4.05-öt használok , C18-as fordítóval , ( Azért C18 mert ide lett megírva a demo program és képtelen vagyok átírni XC8-ra) és egy ICD3-as debuggerrel. Etherneten töltöm fel a weboldal HTML tartalmát aminek a kódolása kifejezetten könnyűnek bizonyult eddig. A forrás kódban van egy demo UART program , amit rá szeretnék bírni hogy kommunikálni tudjak a PC-vel Serial RS232-es porton. Tudna nekem ebben valaki egy kis segítséget nyújtani? Mit kellene még beírnom a kódba illetve hogyan kellene módosítanom hogy erre rábírjam? Tudom hogy Baud ratet kell állítanom pl. Két potenciális kód jelöltem van erre a feladatra. Beírom ide őket remélve hogy valaki ad egy kis támpontot. Előre is köszönöm!

Ő lenne az alap Microchipes webvendhez tartozó demo UART kód:

#define __UART_C
#include "TCPIPConfig.h"
#if defined(STACK_USE_UART)
#include "TCPIP Stack/TCPIP.h"
/* *CONFIG1H*
#pragma config IESO = OFF // osc switchover, default = off
#pragma config FOSC = HS // Belső oszcillátor block, használd az RA6 és RA7 portokat normál port pineknek.
#pragma config FCMEN = OFF // Fail-Safe Clock Monitor Enable, default = off
// *CONFIG2H*
#pragma config WDTPS = 32768 // Watchdog Timer Postscale, default érték = div. 32768
#pragma config WDT = OFF // Watchdog Timer Engedélyező, default érték = on
// *CONFIG3H*
#pragma config CCP2MX = OFF // CCP2 input/output multiplexelve az RB3-al.
// *CONFIG1L*
#pragma config DEBUG = OFF // Background Debugger Engedélyezés.
#pragma config XINST = OFF // Extended Instruction Set Enable
// *CONFIG2L*
#pragma config CP0 = OFF // Program memória írás védettség OFF.
*CONFIG4H* //Nincs ilyen sajnos!
#pragma config CPD = ON // Data EEPROM Code read Protection
#pragma config CPB = ON // boot block code read protect enable
* * * * * * * * * * * * END OF CONFIG BITS * * * * * * * * * * * * * * * * * */
BYTE ReadStringUART(BYTE *Dest, BYTE BufferLen)
{
BYTE c;
BYTE count = 0;
while(BufferLen--) // Amíg az UART bufferben lévő bitek
{ // 0-ásak
*Dest = '\0';
while(!DataRdyUART()); // Amíg az UART bufferben vannak
c = ReadUART(); // Olvassuk ki őket!
if(c == '\r' || c == '\n') // Ezt nem vágom!
break; // Talán ha as C megegyezik az R-el vagy az
// N-el akkor szünet?
count++;
*Dest++ = c; // Adjunk hozzá a desthez amíg = a C bittel.
}
return count; // Visszatérítjük a countot ha megvan.
}
#if defined(__18CXX) // PIC18
char BusyUSART(void)
{
return !TXSTAbits.TRMT; // A bufferben lévő stringeket visszaadjuk
}
void CloseUSART(void)
{
RCSTA &= 0x4F; // Kikapcsoljuk a vevőt ezzel a bittel: 0x4F
TXSTAbits.TXEN = 0; // Transmitter bitet adunk hozzá!
PIE1 &= 0xCF; // Kikapcsoljuk a 2 interruptot!
}
char DataRdyUSART(void)
{
if(RCSTAbits.OERR) // Ha az OERR 1 es akkor
{
RCSTAbits.CREN = 0; // A CREN-t 0-ra rakjuk
RCSTAbits.CREN = 1; // Aztán 1-re? Not sure why...
}
return PIR1bits.RCIF;
}
char ReadUSART(void)
{
return RCREG; // Vissza az RCREGbe kapott adatot!
}
void WriteUSART(char data)
{
TXREG = data; // A data bitet beírjuk az USARTBA!
}
void getsUSART(char *buffer, unsigned char len)
{
char i; // Adat hossz számláló bit az " I "!
unsigned char data;
for(i=0;i<len;i++) // Csak a megadott hosszúságú karaktereket
{ // Visszük vissza. " LEN "!
while(!DataRdyUSART()); // Várunk kicsit hogy megkapjuk az adatot!
data = getcUART(); // Kivesszük az USARTBÓL a karaktert!
// És STRINGKÉNT mentjük el!
*buffer = data;
buffer++; // Inkrementáljuk a string pointert!
}
}
void putsUSART( char *data)
{
do
{ // Átviszünk egy bájtot!
while(BusyUSART());
putcUART(*data);
} while( *data++ );
}
void putrsUSART(const rom char *data)
{
do
{ // Átviszünk egy bájtot!
while(BusyUSART());
putcUART(*data);
} while( *data++ );
}

Ő pedig egy másik amit egy angol fórumon találtam , elvileg ugyan erre a PIC-re lett írva ugyan ezen a boardon:

#include <p18f97j60.h>
#include <stdio.h>
#include<delays.h>
#define USE_OR_MASKS
#include<usart.h>
#define EAUSART_V4
#include <UART.h>
/*Configuration bits
#pragma config WDT=OFF
#pragma config XINST=ON
#pragma config FOSC=HSPLL
*/
//End configuration bits
#define delay_number 2
#define spbrg_val 542
unsigned char msg[]="Hello world !";
void main(){
int i;
char data=0x54;
WDTCON=0x00;
OSCTUNE = 0x40;
OSCCON = 0x08;
BAUDCON1=0x00; //clearing BAUDCON1
TRISJ=0x00;
PORTJ=0x00;
baud1USART(BAUD_IDLE_CLK_LOW |\
BAUD_16_BIT_RATE |\
BAUD_WAKEUP_OFF |\
BAUD_AUTO_OFF);
Open1USART(USART_TX_INT_OFF |\
USART_ADDEN_OFF |\
USART_RX_INT_OFF |\
USART_ASYNCH_MODE |\
USART_EIGHT_BIT |\
USART_CONT_RX |\
USART_BRGH_HIGH,\
spbrg_val );
//Main Routine
while(1){
for(i=0;i<delay_number;i++){
Delay10KTCYx(0);
}
if(PORTJ==0xff)
PORTJ=0x00;
else
PORTJ=0xff;
for(i=0;i<delay_number;i++){
Delay10KTCYx(0);
}
putc1USART(data);
// putrs1USART ("Hello World! putRs\n");
puts1USART(msg);
// printf("Hello World!");
// for(i=0;i<0xFFFF;i++);
// for(i=0;i<0xFFFF;i++);
}
}

A fordító ennél a kódnál dobál olyan hibákat pl hogy a void Main 2x van , mivel 2x is van , a projektben a main az természetesen nem itt található. Ha átírom akkor pl olyan hibát dob hogy nincs definiálva a "baud1USART" annak ellenére hogy includolva van a file ahol definiálva van.

(#)	pajti2 válasza Zekageri hozzászólására (»)	Feb 21, 2018		/

Pár ellenőrző kérdés azt felmérni, valójában mivel is akadtál el.

-Szakmai angol szöveg elolvasás okoz gondot?
-C programozási alapok megvannak?
-Érted az aszinkron állapotgépek koncepcióját?
-Megtalálod a forrásban a főciklus kódját?
-Az mla help könyvtárában az ethernet stack pdf-jét megtaláltad?
-Pic adatlapot megtaláltad?
-Érted az uart periféria működését?

És a konkrét példát majd csak utána.

(#)	pipi válasza Zekageri hozzászólására (»)	Feb 21, 2018		/

Próbáld a TCPIP\Demo App-ot,
ebben a STACK_USE_UART2TCP_BRIDGE kapcsold be...

(#)	Zekageri válasza pajti2 hozzászólására (»)	Feb 21, 2018		/

-Nem okoz gondot.
-Megvannak viszont még csak kissebb programokat írtam.
-Nem tudom mik azok.
-Megtalálom.
-Igen , el is olvastam.
-Igen megtaláltam.
-Értem.

^_^

(#)	pajti2 válasza Zekageri hozzászólására (»)	Feb 21, 2018		/

Az alapok kb okés

Ha a doksi anyagot megtaláltad a projecthez, és el is tudod olvasni, akkor megtalálod a config kapcsolókat. Modulokra van szétszedve minden, modulonként config kapcsoló van hozzá, hogy egyes kódrészletek bekerüljenek-e a projectbe, vagy sem, és hogy hogyan működjenek. Nem ismerem konkrétan azt a projectet, de biztosra veszem, hogy ugyan olyan, mint bármelyik másik. Az összes könnyítés, hogy a config kapcsolók csoportokba vannak szedve, és ha valami csoport egyben nem kell, annak a részleteit átugorhatod, de a többit egyesével mind végig kell nyálaznod, és célszerű lenne meg is értened, mire szolgál. Ha mást nem, kikeresheted a kódban, hol használja, de arra nem szokott szükség lenni, mert a régebbi mla-k még elég normálisak, le van írva minden elég részletesen. Be kell majd állítani halom sok dolgot webhez, helyi hálózathoz, a soros porthoz. Elvileg meg kell találnod a doksiban legalább a config file megemlítését, de javarészt az ott szereplő kapcsolókat is egyesével mind leírja. Amit nem ír le, azt a forrásban találod meg kommentben (az adott config file-ban).

Ami az állapotgépeket illeti, ha belenézel a kódba, halom sok switch-case-t fogsz találni, ami ránéz egy változóra, és annak alapján halom sok opció közül egyet hajt végre, egy picike kódrészletet futtat, aztán visszatér. A program részletek addig tartanak, amíg perifériára várakozás nélkül tudnak bármi egységnyi feladatot elvégezni. Ha azt elvégezték, akkor állapot változók módosítása, végrehajtás snitt, majd legközelebb folytatja, de addig visszaadja a vezérlést, és futhat a többi állapotgép is. Amolyan önkéntes processzor idő feladás elve alapján épített multitasking. Hogy ne legyen teljesen érthetetlen, mit csinálnak azok a config kapcsolók: olyan pici snippetek forráskódba beépülését és működési paramétereit vezérlik. Olyanokból áll az egész alkalmazás. Kicsit közelebbről majd akkor kell összebarátkoznod velük, ha bele is akarsz nyúlni valahova. Amíg csak a példa project előre kitalált látványosságát akarod megszemlélni, addig még magához a kódhoz nem kell madártávlatnál közelebb menned, logikai szinten is kezelheted, és a config kapcsolók abban segítenek neked.

(#)	Zekageri válasza pajti2 hozzászólására (»)	Feb 21, 2018		/

Nos igen , köszönöm a választ. Ezeket a config kapcsolókat meg is találtam , használtam is őket , bele raktam a projectbe azt ami kell és kivettem azt ami nem kell. Végig követtem az útjukat , hogy milyen program részeket tudok velük bekapcsolni illetve ki. Ezek után sikerült rábírnom a programomat hogy működjön az én boardommal , hogy elérjem a TCP/IP-t , a webes felületet módosítottam ezek által , illetve a ledeket és az LCD kijelzőt. Ezeket sikerült megcsinálnom , az alap dolgokat amiket a demo leírt , tanulásnak. Viszont ezek felett és már egy Serial RS232 porton való kommunikációt szeretnék létrehozni a PC-M és a PIC board között , egyenlőre. Később pedig ha sikerül teljesen ( vagy nagy részt ) megértenem a program kódot akkor az a terv hogy egy kártya olvasó modulról kérek adatot az RS232-n , amit feldolgozok a programban a PIC18-al aztán megjelenítem a webes felületén. Viszont nem vagyok benne biztos hogy a demo UART program amit ide leírtam képes lenne-e nekem RS232-n adatot fogadni nem PC-ről. Illetve találtam még egy UART_TCP bridge-s source filet amiben megvan határozva a PIC baud rateja meg ilyen kis mókaságok meg valószínűleg ( amennyire az én tudásommal látom ) egy híd a TCP és az UART között.

itt a kód:

#define __UART2TCPBRIDGE_C
#include "TCPIPConfig.h"
#include "HardwareProfile.h"
// TCP listen port and UART baud rate settings. Due to a current C18
// preprocessor bug (tested on compiler 3.30), the BAUD_RATE definition needs
// to be placed above the #if defined(STACK_USE_UART2TCP_BRIDGE) test.
// Otherwise, it won't compile when STACK_USE_UART2TCP_BRIDGE is UNdefined.
// Also, HardwareProfile.h also needs to be included before the
// STACK_USE_UART2TCP_BRIDGE test.
#define UART2TCPBRIDGE_PORT 9761
#define BAUD_RATE 19200
#if defined(STACK_USE_UART2TCP_BRIDGE)
#include "TCPIP Stack/TCPIP.h"
// Komment ezt a definet ha nem vagyunk szerver!
#define USE_REMOTE_TCP_SERVER "192.168.2.50" //Szerverek vagyunk elvileg!
// Ring buffers for transfering data to and from the UART ISR:
// - (Head pointer == Tail pointer) is defined as an empty FIFO
// - (Head pointer == Tail pointer - 1), accounting for wraparound,
// is defined as a completely full FIFO. As a result, the max data
// in a FIFO is the buffer size - 1.
static BYTE vUARTRXFIFO[65];
static BYTE vUARTTXFIFO[17];
static volatile BYTE *RXHeadPtr = vUARTRXFIFO, *RXTailPtr = vUARTRXFIFO;
static volatile BYTE *TXHeadPtr = vUARTTXFIFO, *TXTailPtr = vUARTTXFIFO;
/*********************************************************************
* Function: void UART2TCPBridgeInit(void)
*
* Overview: UART perifériák felállítása!
*
* Note: Interruptokat használunk!
********************************************************************/
void UART2TCPBridgeInit(void)
{
// Initilize UART
#if defined(__18CXX)
TXSTA = 0x20;
RCSTA = 0x90;
#define CLOSEST_SPBRG_VALUE ((GetPeripheralClock()+2ul*BAUD_RATE)/BAUD_RATE/4-1)
#define BAUD_ACTUAL (GetPeripheralClock()/(CLOSEST_SPBRG_VALUE+1))
#if (BAUD_ACTUAL > BAUD_RATE)
#define BAUD_ERROR (BAUD_ACTUAL-BAUD_RATE)
#else
#define BAUD_ERROR (BAUD_RATE-BAUD_ACTUAL)
#endif
#define BAUD_ERROR_PRECENT ((BAUD_ERROR*100+BAUD_RATE/2)/BAUD_RATE)
#if BAUD_ERROR_PRECENT > 2
// Use high speed (Fosc/4) 16-bit baud rate generator
BAUDCONbits.BRG16 = 1;
TXSTAbits.BRGH = 1;
SPBRGH = ((GetPeripheralClock()+BAUD_RATE/2)/BAUD_RATE-1)>>8 & 0xFF;
SPBRG = ((GetPeripheralClock()+BAUD_RATE/2)/BAUD_RATE-1) & 0xFF;
#else
// See if we can use the high baud (Fosc/16) 8-bit rate setting
#if ((GetPeripheralClock()+2*BAUD_RATE)/BAUD_RATE/4 - 1) <= 255
SPBRG = (GetPeripheralClock()+2*BAUD_RATE)/BAUD_RATE/4 - 1;
TXSTAbits.BRGH = 1;
#else // Use the low baud rate 8-bit setting
SPBRG = (GetPeripheralClock()+8*BAUD_RATE)/BAUD_RATE/16 - 1;
#endif
#endif
// Use high priority interrupt
IPR1bits.TXIP = 1;
#else
UARTTX_TRIS = 0;
UARTRX_TRIS = 1;
UMODE = 0x8000; // Set UARTEN. Note: this must be done before setting UTXEN
#if defined(__C30__)
USTA = 0x0400; // UTXEN set
#define CLOSEST_UBRG_VALUE ((GetPeripheralClock()+8ul*BAUD_RATE)/16/BAUD_RATE-1)
#define BAUD_ACTUAL (GetPeripheralClock()/16/(CLOSEST_UBRG_VALUE+1))
#else //defined(__C32__)
IPC8bits.U2IP = 6; // Priority level 6
USTA = 0x00001400; // RXEN set, TXEN set
#define CLOSEST_UBRG_VALUE ((GetPeripheralClock()+8ul*BAUD_RATE)/16/BAUD_RATE-1)
#define BAUD_ACTUAL (GetPeripheralClock()/16/(CLOSEST_UBRG_VALUE+1))
#endif
#define BAUD_ERROR ((BAUD_ACTUAL > BAUD_RATE) ? BAUD_ACTUAL-BAUD_RATE : BAUD_RATE-BAUD_ACTUAL)
#define BAUD_ERROR_PRECENT ((BAUD_ERROR*100+BAUD_RATE/2)/BAUD_RATE)
#if (BAUD_ERROR_PRECENT > 3)
#warning UART frequency error is worse than 3%
#elif (BAUD_ERROR_PRECENT > 2)
#warning UART frequency error is worse than 2%
#endif
UBRG = CLOSEST_UBRG_VALUE;
#endif
}
/*********************************************************************
* Function: void UART2TCPBridgeTask(void)
*
* PreCondition: Stack is initialized()
********************************************************************/
void UART2TCPBridgeTask(void)
{
static enum _BridgeState
{
SM_HOME = 0,
SM_SOCKET_OBTAINED
} BridgeState = SM_HOME;
static TCP_SOCKET MySocket = INVALID_SOCKET;
WORD wMaxPut, wMaxGet, w;
BYTE *RXHeadPtrShadow, *RXTailPtrShadow;
BYTE *TXHeadPtrShadow, *TXTailPtrShadow;
switch(BridgeState)
{
case SM_HOME:
#if defined(USE_REMOTE_TCP_SERVER)
// Connect a socket to the remote TCP server
MySocket = TCPOpen((DWORD)USE_REMOTE_TCP_SERVER, TCP_OPEN_ROM_HOST, UART2TCPBRIDGE_PORT, TCP_PURPOSE_UART_2_TCP_BRIDGE);
#else
MySocket = TCPOpen(0, TCP_OPEN_SERVER, UART2TCPBRIDGE_PORT, TCP_PURPOSE_UART_2_TCP_BRIDGE);
#endif
// Abort operation if no TCP socket of type TCP_PURPOSE_UART_2_TCP_BRIDGE is available
// If this ever happens, you need to go add one to TCPIPConfig.h
if(MySocket == INVALID_SOCKET)
break;
// Eat the first TCPWasReset() response so we don't
// infinitely create and reset/destroy client mode sockets
TCPWasReset(MySocket);
// We have a socket now, advance to the next state
BridgeState = SM_SOCKET_OBTAINED;
break;
case SM_SOCKET_OBTAINED:
// Reset all buffers if the connection was lost
if(TCPWasReset(MySocket))
{
// Optionally discard anything in the UART FIFOs
//RXHeadPtr = vUARTRXFIFO;
//RXTailPtr = vUARTRXFIFO;
//TXHeadPtr = vUARTTXFIFO;
//TXTailPtr = vUARTTXFIFO;
// If we were a client socket, close the socket and attempt to reconnect
#if defined(USE_REMOTE_TCP_SERVER)
TCPDisconnect(MySocket);
MySocket = INVALID_SOCKET;
BridgeState = SM_HOME;
break;
#endif
}
// Don't do anything if nobody is connected to us
if(!TCPIsConnected(MySocket))
break;
// Make sure to clear UART errors so they don't block all future operations
#if defined(__18CXX)
if(RCSTAbits.OERR)
{
RCSTAbits.CREN = 0;
RCSTAbits.CREN = 1;
LED1_IO ^= 1;
}
if(RCSTAbits.FERR)
{
BYTE dummy = RCREG;
LED2_IO ^= 1;
}
#else
if(U2STAbits.OERR)
U2STAbits.OERR = 0;
#endif
// Read FIFO pointers into a local shadow copy. Some pointers are volatile
// (modified in the ISR), so we must do this safely by disabling interrupts
RXTailPtrShadow = (BYTE*)RXTailPtr;
TXHeadPtrShadow = (BYTE*)TXHeadPtr;
#if defined(__18CXX)
PIE1bits.RCIE = 0;
PIE1bits.TXIE = 0;
#else
IEC1bits.U2RXIE = 0;
IEC1bits.U2TXIE = 0;
#endif
RXHeadPtrShadow = (BYTE*)RXHeadPtr;
TXTailPtrShadow = (BYTE*)TXTailPtr;
#if defined(__18CXX)
PIE1bits.RCIE = 1;
if(TXHeadPtrShadow != TXTailPtrShadow)
PIE1bits.TXIE = 1;
#else
IEC1bits.U2RXIE = 1;
if(TXHeadPtrShadow != TXTailPtrShadow)
IEC1bits.U2TXIE = 1;
#endif
//
// Transmit pending data that has been placed into the UART RX FIFO (in the ISR)
//
wMaxPut = TCPIsPutReady(MySocket); // Get TCP TX FIFO space
wMaxGet = RXHeadPtrShadow - RXTailPtrShadow; // Get UART RX FIFO byte count
if(RXHeadPtrShadow < RXTailPtrShadow)
wMaxGet += sizeof(vUARTRXFIFO);
if(wMaxPut > wMaxGet) // Calculate the lesser of the two
wMaxPut = wMaxGet;
if(wMaxPut) // See if we can transfer anything
{
// Transfer the data over. Note that a two part put
// may be needed if the data spans the vUARTRXFIFO
// end to start address.
w = vUARTRXFIFO + sizeof(vUARTRXFIFO) - RXTailPtrShadow;
if(wMaxPut >= w)
{
TCPPutArray(MySocket, RXTailPtrShadow, w);
RXTailPtrShadow = vUARTRXFIFO;
wMaxPut -= w;
}
TCPPutArray(MySocket, RXTailPtrShadow, wMaxPut);
RXTailPtrShadow += wMaxPut;
// No flush. The stack will automatically flush and do
// transmit coallescing to minimize the number of TCP
// packets that get sent. If you explicitly call TCPFlush()
// here, latency will go down, but so will max throughput
// and bandwidth efficiency.
}
//
// Transfer received TCP data into the UART TX FIFO for future transmission (in the ISR)
//
wMaxGet = TCPIsGetReady(MySocket); // Get TCP RX FIFO byte count
wMaxPut = TXTailPtrShadow - TXHeadPtrShadow - 1;// Get UART TX FIFO free space
if(TXHeadPtrShadow >= TXTailPtrShadow)
wMaxPut += sizeof(vUARTTXFIFO);
if(wMaxPut > wMaxGet) // Calculate the lesser of the two
wMaxPut = wMaxGet;
if(wMaxPut) // See if we can transfer anything
{
// Transfer the data over. Note that a two part put
// may be needed if the data spans the vUARTTXFIFO
// end to start address.
w = vUARTTXFIFO + sizeof(vUARTTXFIFO) - TXHeadPtrShadow;
if(wMaxPut >= w)
{
TCPGetArray(MySocket, TXHeadPtrShadow, w);
TXHeadPtrShadow = vUARTTXFIFO;
wMaxPut -= w;
}
TCPGetArray(MySocket, TXHeadPtrShadow, wMaxPut);
TXHeadPtrShadow += wMaxPut;
}
// Write local shadowed FIFO pointers into the volatile FIFO pointers.
#if defined(__18CXX)
PIE1bits.RCIE = 0;
PIE1bits.TXIE = 0;
#else
IEC1bits.U2RXIE = 0;
IEC1bits.U2TXIE = 0;
#endif
RXTailPtr = (volatile BYTE*)RXTailPtrShadow;
TXHeadPtr = (volatile BYTE*)TXHeadPtrShadow;
#if defined(__18CXX)
PIE1bits.RCIE = 1;
if(TXHeadPtrShadow != TXTailPtrShadow)
PIE1bits.TXIE = 1;
#else
IEC1bits.U2RXIE = 1;
if(TXHeadPtrShadow != TXTailPtrShadow)
IEC1bits.U2TXIE = 1;
#endif
break;
}
}
#if defined(__18CXX)
/*********************************************************************
* Function: void UART2TCPBridgeISR(void)
*
* PreCondition: UART interrupt has occured
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: None
*
* Note: This function is supposed to be called in the ISR
* context.
********************************************************************/
void UART2TCPBridgeISR(void)
{
// NOTE: All local variables used here should be declared static
static BYTE i;
// Store a received byte, if pending, if possible
if(PIR1bits.RCIF)
{
// Get the byte
i = RCREG;
// Clear the interrupt flag so we don't keep entering this ISR
PIR1bits.RCIF = 0;
// Copy the byte into the local FIFO, if it won't cause an overflow
if(RXHeadPtr != RXTailPtr - 1)
{
if((RXHeadPtr != vUARTRXFIFO + sizeof(vUARTRXFIFO)) || (RXTailPtr != vUARTRXFIFO))
{
*RXHeadPtr++ = i;
if(RXHeadPtr >= vUARTRXFIFO + sizeof(vUARTRXFIFO))
RXHeadPtr = (volatile BYTE*)vUARTRXFIFO;
}
}
}
// Transmit a byte, if pending, if possible
if(PIR1bits.TXIF)
{
if(TXHeadPtr != TXTailPtr)
{
TXREG = *TXTailPtr++;
if(TXTailPtr >= vUARTTXFIFO + sizeof(vUARTTXFIFO))
TXTailPtr = (volatile BYTE*)vUARTTXFIFO;
}
else // Disable the TX interrupt if we are done so that we don't keep entering this ISR
{
PIE1bits.TXIE = 0;
}
}
}

Szóval igazából a kérdés az az hogy ezeknek a demo kódoknak a bekapcsolásával vajon képes lehet a PIC egy ilyen adat fogadásra egy külső terminálról az RS232-es serial porton? És ha nem miket kellene még bele írnom hogy képes legyen?

(#)	pipi válasza Zekageri hozzászólására (»)	Feb 21, 2018		/

Ha PC-n telnettel megnyitod a definiált tcpip porton a cuccodat, akkor amit bepötyögsz, az kiesik az uarton, amit a cuccod kap a soroson azt meg kipöfögi a pc-re, a telnetben fogod látni.
Ha bekapcsoltad ezt a funkciót, máshol nem kell belenyúlni a tcpip/uart forrásszövegéhez

A hozzászólás módosítva: Feb 21, 2018

(#)	pajti2 válasza Zekageri hozzászólására (»)	Feb 21, 2018		/

Ahogy néztem a boardot, van rajta soros porti meghajtó db9 csatlakozóval, van rajta eeprom is, van minden a boardon, hogy alkalmas legyen egy ethernet / uart bridge feladat elvégzésére, és még jelszót is rárakhatsz a boardra védelem gyanánt. Az más kérdés, hogy memória nincsen túl sok abban a pic-ben, de ha nem izomból akarod hajtani, és ésszel írsz soros port oldali protokolt, akkor bőven elég lesz.

Ha én akarnék belőle fabrikálni valamit, én hagynám a webezést, és sima udp-t használnék hozzá. Azzal sokkal tisztább és stabilabb. Nem tud elfogyni a memória, meg túl nagy terhelést kapni a pic, vagy bármi hasonló. Ha te webezni szeretnél, persze csináld.

Viszont ha nem elég pont az és úgy, ahogy a példa project támogatja neked, akkor az a project csak a komponens felső szintű kipróbálásához lesz neked jó, és ha kijátszadoztad magad vele, akkor tiszta lapról kell majd kezdened nulláról mindent. Elolvasod az ethernet stack doksiját, te app initelsz, állítod be a modulokat, és ami összetevő nem jó a régi projectből, azt újraírod. Ahhoz már kelleni fog a programozási gyakorlat, nem fog menni legózás szintjén. Nincsenek olyan legó darabok, amik gondoltak rá, hogy minden lehetséges igényt ki tudjanak szolgálni. Szóval rágcsáld a project doksiját egészen addig, míg el tudod különíteni a projectből a neked szükséges modulokat, és azokat be tudod húzni teljesen üres projectbe önállóan, valamint megtalálod a modulokban azokat az interface pontokat, ahol adatokat mozgathatsz, és az ahhoz tartozó folyamat vezérlést is megérted. Szájba is rághatnám, de az úgy nem buli, és nem tanulsz belőle.

Vagy ha csak egy megoldás kell és gyorsan, kaphatóak egyben port szerverek is készen, azokhoz nem kell fejleszteni semmit se.

(#)	Zekageri hozzászólása	Feb 21, 2018		/

Köszönöm szépen a válaszaitokat , nagyon hasznosak voltak. A webes részét nem szeretném hanyagolni , mert valós időben szeretném megjeleníteni a bejövő adatokat egy felületen , ez a legjobb megoldás rá szerintem. Van itt telnet is , csak még nem tudom hogy használjam , megvan írva benne minden , a jelszó , a felhasználó név is , csak nemtudom hogy érjem el telneten keresztül , mert semmi elérési út nincs megadva ezeken kívül a programban. Az IP címével pedig csak a webes felületet érem el amihez meg nem kell jelszó. Hát igen , meg is vehetném de azzal meg nem érnék el semmit.

Mindenképp tanulmányozom tovább és össze pakolok egy saját projectet ezekből! ^_^

(#)	pajti2 válasza Zekageri hozzászólására (»)	Feb 21, 2018		/

Ha erőltetni akarod a webezést, szükséged lehet nagyobb teljesítményű pic-re. A pic18-asokban túl kevés a belső ram. Falnak tud futni a fejlesztés, ha kiegészítgetnéd ezzel-azzal. Utólag majd ne sírj nekünk, miért nem szólt senki

Valami pic32-es boardot javasolnék inkább. Pic18-at inkább csak olyankor használnék, ha elégséges a média felület mentes funkcionalitás. Például udp-n csomag kérdés / válasz, magasabb szintű protokol semmi, és az adat megjelenítés is egy másik számítógép dolga, amiben már van bőven proci, meg ram, meg minden. Néztem én is a pic-ek webezési lehetőségeit, és össze lehet velük rakni valamit, ami tisztára úgy néz ki, "mintha", de az akkor sem az, hanem fából vaskarika, és nem fog tudni terhelést bírni. Még a pic32-essel is bele tudsz szaladni abba, hogy eléred a teljesítménykorlátot, mert nem lesz elég ram - mindig az a fránya ram - de egy pic18-al meg pláne két pillanat alatt fogsz belefutni a korlátaiba.