OK Mégsem
Fórum témák

» Több friss téma
Fórum » Arduino
A klónok CH340 Soros-USB illesztőjének drivere (Letöltés)
Lapozás: OK   58 / 847
(#) vilmosd válasza kisedison hozzászólására (») Nov 4, 2014 /
 
Ne nekem mondjad!
Idézet:
„én lm35-ös tranzisztort használtam.”
Ennyi.
(#) minimodel hozzászólása Nov 4, 2014 /
 
Azt már észre vettem, hogy az Arduino-t könnyített C++ nyelven lehet programozni és .ino kiterjesztésű fájlok lesznek a programkódok. Viszont ha pl. építek egy égetőt, felprogramozom Arduino-val, akkor azzal az égetővel lehet majd síma C nyelven programozni pl. egy Attiny-t?
(#) kisedison válasza vilmosd hozzászólására (») Nov 4, 2014 /
 
Jó, akkor mindjárt leírom az érintettnek is, vagy látja amit írtam. Nem kell mindjárt felkapni a vizet...
(#) kisedison válasza erdeidominik1999 hozzászólására (») Nov 4, 2014 /
 
vilmosd kedvéért konkrétan neked is leírom, az LM35 egy analóg hőmérő.
(#) varttina válasza minimodel hozzászólására (») Nov 4, 2014 /
 
Az AVR-ek csak a lefordított programkóddal (HEX) boldogulnak. Amennyiben van egy olyan fordítód, ami lefordítja a "sima C"-t HEX-re, és van egy égető szoftvered, akkor már kész is vagy. Jó ha a két funkció egy szoftverben egyesül (mint pl. az Arduino esetében), de nem feltétlenül szükséges.
(#) pepe1125 válasza erdeidominik1999 hozzászólására (») Nov 5, 2014 /
 
A MOSFET elé nem kell ellenállás, mert feszültség vezérelt alkatrész, egyébként olyan 10 ohm-ot szoktak ha nagy frekin járatják a GATE -el sorosan. Valamint, hogy ha bármi baj lenne, akkor a GATE és a SOURCE elektródája közé mondjuk 10k ellenállást, ami lehúzza földre az N csatornás FET-et. De ha ezeket kihagyod és közvetlenül a kontrollerre kötöd, az se baj, csak számolj azzal, hogy bootoláskor lebeg a kimenet, és a MOSFET kinyithat. Tehát célszerű betenni azt a 10k ellenállást legalább.
(#) pepe1125 válasza erdeidominik1999 hozzászólására (») Nov 5, 2014 /
 
Régebben szórakoztam vele, próbáld ki mit csinál, csak írd át a te LCD kijelződ bekötésére. Nálam az analóg porton volt a kijelző, mert ott volt neki hely.
  1. // define integers for the cursor location
  2. int x = 0;
  3. int y = 0;
  4. int j = 0;
  5.  
  6. #include <LiquidCrystal.h>
  7.  
  8. LiquidCrystal lcd(A11,A10,A9,A5,A4,A3,A2);
  9. const int gnd = A14;
  10. const int vdd = A13;
  11. const int cont = A12;
  12. const int back_A = A1;
  13. const int back_C = A0;
  14.  
  15. void setup() {
  16.   pinMode(A6, INPUT);
  17.   pinMode(A7, INPUT);
  18.   pinMode(A8, INPUT);
  19.   pinMode(gnd, OUTPUT);
  20.   pinMode(vdd, OUTPUT);
  21.   pinMode(cont, OUTPUT);  
  22.   pinMode(back_A, OUTPUT);
  23.   pinMode(back_C, OUTPUT);  
  24.   digitalWrite(gnd, LOW);
  25.   digitalWrite(vdd, HIGH);
  26.   digitalWrite(cont, LOW);
  27.   digitalWrite(back_A, HIGH);
  28.   digitalWrite(back_C, LOW);  
  29.   delay(1000);
  30.   lcd.begin(16, 2);
  31.   lcd.print("CUSTOM  CHAR  SP");
  32.   //        "                "
  33.   delay(1000);
  34. }  
  35.  
  36. void customclear()
  37. {
  38.   // ensures all custom character slots are clear before new custom
  39.   // characters can be defined.
  40.   byte blank[8] =
  41.   {
  42.     B00000, B00000, B00000, B00000, B00000, B00000, B00000, B00000
  43.   };
  44.   for(int i = 0; i < 8; i++)
  45.   {
  46.     lcd.createChar(i, blank);
  47.   }
  48. }
  49. // filles a segment one line at a time fron left to right.
  50. void customset1()
  51. {
  52.   customclear();
  53.   j = 4;
  54.   // arrays to form one set of custom characters
  55.   byte line1[8] =
  56.   {
  57.     B10000, B10000, B10000, B10000, B10000, B10000, B10000, B10000
  58.   };
  59.   byte line2[8] =
  60.   {
  61.     B11000, B11000, B11000, B11000, B11000, B11000, B11000, B11000
  62.   };
  63.   byte line3[8] =
  64.   {
  65.     B11100, B11100, B11100, B11100, B11100, B11100, B11100, B11100
  66.   };
  67.   byte line4[8] =
  68.   {
  69.     B11110, B11110, B11110, B11110, B11110, B11110, B11110, B11110
  70.   };
  71.  
  72.   // assignes each segment a write number
  73.   lcd.createChar(0, line1);
  74.   lcd.createChar(1, line2);
  75.   lcd.createChar(2, line3);
  76.   lcd.createChar(3, line4);  
  77. }
  78.  
  79. // fills a segment one line at a time from top to bottom.
  80. void customset2()
  81. {
  82.   customclear();
  83.   j = 7;
  84.   // arrays to form one set of custom characters
  85.   byte line1[8] =
  86.   {
  87.     B11111, B00000, B00000, B00000, B00000, B00000, B00000, B00000
  88.   };
  89.   byte line2[8] =
  90.   {
  91.     B11111, B11111, B00000, B00000, B00000, B00000, B00000, B00000
  92.   };
  93.   byte line3[8] =
  94.   {
  95.     B11111, B11111, B11111, B00000, B00000, B00000, B00000, B00000
  96.   };
  97.   byte line4[8] =
  98.   {
  99.     B11111, B11111, B11111, B11111, B00000, B00000, B00000, B00000
  100.   };
  101.   byte line5[8] =
  102.   {
  103.     B11111, B11111, B11111, B11111, B11111, B00000, B00000, B00000
  104.   };
  105.   byte line6[8] =
  106.   {
  107.     B11111, B11111, B11111, B11111, B11111, B11111, B00000, B00000
  108.   };
  109.   byte line7[8] =
  110.   {
  111.     B11111, B11111, B11111, B11111, B11111, B11111, B11111, B00000
  112.   };
  113.  
  114.   // assignes each segment a write number
  115.   lcd.createChar(0, line1);
  116.   lcd.createChar(1, line2);
  117.   lcd.createChar(2, line3);
  118.   lcd.createChar(3, line4);
  119.   lcd.createChar(4, line5);
  120.   lcd.createChar(5, line6);
  121.   lcd.createChar(6, line7);
  122. }
  123.  
  124. void mediaChar()
  125. {
  126.   customclear();
  127.  
  128.   byte play[8] =
  129.   {
  130.     B00000, B01000, B01100, B01110, B01100, B01000, B00000, B00000
  131.   };
  132.   byte fastforward[8] =
  133.   {
  134.     B00000, B10100, B01010, B00101, B01010, B10100, B00000, B00000
  135.   };
  136.   byte forward[8] =
  137.   {
  138.     B00000, B01000, B00100, B00010, B00100, B01000, B00000, B00000
  139.   };
  140.   byte fastback[8] =
  141.   {
  142.     B00000, B00101, B01010, B10100, B01010, B00101, B00000, B00000
  143.   };
  144.   byte back[8] =
  145.   {
  146.     B00000, B00010, B00100, B01000, B00100, B00010, B00000, B00000
  147.   };
  148.   byte Stop[8] =
  149.   {
  150.     B00000, B11111, B11111, B11111, B11111, B11111, B00000, B00000
  151.   };
  152.   byte record[8] =
  153.   {
  154.     B00000, B01110, B11111, B11111, B11111, B01110, B00000, B00000
  155.   };
  156.   byte pause[8] =
  157.   {
  158.     B00000, B11011, B11011, B11011, B11011, B11011, B00000, B00000
  159.   };
  160.   // assignes each segment a write number
  161.   lcd.createChar(2, play);
  162.   lcd.createChar(4, fastforward);
  163.   lcd.createChar(3, forward);
  164.   lcd.createChar(0, fastback);
  165.   lcd.createChar(1, back);
  166.   lcd.createChar(6, Stop);
  167.   lcd.createChar(7, record);
  168.   lcd.createChar(5, pause);
  169. }
  170.  
  171. void cardChar()
  172. {
  173.   customclear();
  174.  
  175.   byte heart[8] =
  176.   {
  177.     B00000, B01010, B11111, B11111, B01110, B00100, B00000, B00000
  178.   };
  179.   byte diamond[8] =
  180.   {
  181.     B00000, B00100, B01110, B11111, B01110, B00100, B00000, B00000
  182.   };
  183.   byte spade[8] =
  184.   {
  185.     B00000, B00100, B01110, B11111, B11111, B01110, B00100, B01110
  186.   };
  187.   byte club[8] =
  188.   {
  189.     B00000, B01110, B10101, B11111, B10101, B00100, B01110, B00000
  190.   };
  191.   // assignes each segment a write number
  192.   lcd.createChar(0, heart);
  193.   lcd.createChar(1, diamond);
  194.   lcd.createChar(2, spade);
  195.   lcd.createChar(3, club);
  196. }
  197.  
  198. void boarderChar()
  199. {
  200.   customclear();
  201.  
  202.   byte topleft[8] =
  203.   {
  204.     B11111, B10000, B10000, B10000, B10000, B10000, B10000, B10000
  205.   };
  206.   byte topright[8] =
  207.   {
  208.     B11111, B00001, B00001, B00001, B00001, B00001, B00001, B00001
  209.   };
  210.   byte bottomleft[8] =
  211.   {
  212.     B10000, B10000, B10000, B10000, B10000, B10000, B10000, B11111
  213.   };
  214.   byte bottomright[8] =
  215.   {
  216.     B00001, B00001, B00001, B00001, B00001, B00001, B00001, B11111
  217.   };
  218.   byte leftside[8] =
  219.   {
  220.     B10000, B10000, B10000, B10000, B10000, B10000, B10000, B10000
  221.   };
  222.   byte rightside[8] =
  223.   {
  224.     B00001, B00001, B00001, B00001, B00001, B00001, B00001, B00001
  225.   };
  226.   byte top[8] =
  227.   {
  228.     B11111, B00000, B00000, B00000, B00000, B00000, B00000, B00000
  229.   };
  230.   byte bottom[8] =
  231.   {
  232.     B00000, B00000, B00000, B00000, B00000, B00000, B00000, B11111
  233.   };
  234.   // assignes each segment a write number
  235.   lcd.createChar(0, topleft);
  236.   lcd.createChar(1, topright);
  237.   lcd.createChar(2, bottomleft);
  238.   lcd.createChar(3, bottomright);
  239.   lcd.createChar(4, leftside);
  240.   lcd.createChar(5, rightside);
  241.   lcd.createChar(6, top);
  242.   lcd.createChar(7, bottom);
  243. }
  244.  
  245. void arrowChar()
  246. {
  247.   customclear();
  248.  
  249.   byte up[8] =
  250.   {
  251.     B00000, B00100, B01110, B10101, B00100, B00100, B00100, B00000
  252.   };
  253.   byte down[8] =
  254.   {
  255.     B00000, B00100, B00100, B00100, B10101, B01110, B00100, B00000
  256.   };
  257.   byte lowleftcorner[8] =
  258.   {
  259.     B00000, B00000, B00001, B10010, B10100, B11000, B11110, B00000,
  260.   };
  261.   byte lowrightcorner[8] =
  262.   {
  263.     B00000, B00000, B10000, B01001, B00101, B00011, B01111, B00000,
  264.   };
  265.   byte upleftcorner[8] =
  266.   {
  267.     B00000, B11110, B11000, B10100, B10010, B00001, B00000, B00000
  268.   };
  269.   byte uprightcorner[8] =
  270.   {
  271.     B00000, B01111, B00011, B00101, B01001, B10000, B00000, B00000
  272.   };
  273.   byte updown[8] =
  274.   {
  275.     B00100, B01110, B10101, B00100, B00100, B10101, B01110,  B00100
  276.   };  
  277.   // assignes each segment a write number
  278.   lcd.createChar(0, up);
  279.   lcd.createChar(1, down);
  280.   lcd.createChar(2, lowleftcorner);
  281.   lcd.createChar(3, lowrightcorner);
  282.   lcd.createChar(4, upleftcorner);
  283.   lcd.createChar(5, uprightcorner);
  284.   lcd.createChar(6, updown);
  285. }
  286. void fillset()
  287. {
  288.   for(int i = 0; i < j; i++)
  289.   {
  290.     lcd.setCursor(x, y);
  291.     lcd.write(i);
  292.     delay(10);
  293.   }
  294.   lcd.setCursor(x, y);
  295.   lcd.write(255);
  296.   delay(10);
  297.   x++;
  298.   if(x < 16)
  299.   {
  300.     fillset();
  301.   }
  302.   if(x > 15)
  303.   {
  304.     x = 0;
  305.     y++;
  306.     if (y < 2)
  307.     {
  308.       fillset();
  309.     }
  310.   }
  311.   if(y > 1)
  312.   {
  313.     x = 0;
  314.     y = 0;
  315.     lcd.clear();  
  316.   }
  317. }
  318.  
  319. void loop()
  320. {
  321.   customset1();
  322.   fillset();
  323.   customset2();
  324.   fillset();
  325.   customclear();
  326.   for(int i = 0; i <8; i++)
  327.   {
  328.     lcd.setCursor(x,y);
  329.     lcd.write(i);
  330.     x++;
  331.   }
  332.   x=0;
  333.   mediaChar();
  334.   delay(1000);
  335.   cardChar();
  336.   delay(1000);
  337.   arrowChar();
  338.   delay(1000);
  339.   lcd.clear();  
  340.   boarderChar();
  341.   lcd.setCursor(0,0);
  342.   lcd.write((uint8_t)0);
  343.   lcd.setCursor(0,1);
  344.   lcd.write(2);
  345.   lcd.setCursor(15,0);
  346.   lcd.write(1);
  347.   lcd.setCursor(15,1);
  348.   lcd.write(3);
  349.   lcd.setCursor(6,0);
  350.   lcd.write((uint8_t)0);
  351.   lcd.setCursor(9,0);
  352.   lcd.write(1);
  353.   lcd.setCursor(6,1);
  354.   lcd.write(2);
  355.   lcd.setCursor(9,1);
  356.   lcd.write(3);
  357.   lcd.setCursor(7,0);
  358.   lcd.write(6);
  359.   lcd.write(6);
  360.   lcd.setCursor(7,1);
  361.   lcd.write(7);
  362.   lcd.write(7);
  363.   delay(1000);
  364.   x=0;
  365.   lcd.clear();
  366. }
(#) steelgoofy hozzászólása Nov 5, 2014 /
 
Üdv,

Egy arduinoval megvalósított PID vezérlést szeretnék elkészíteni. A projektben használt eszközök DC motor(12V), propeller, gyorsulásmérő szenzor. Rajz a szerkezetről. A lényeg az lenne, hogy a PID algoritmus egyensúlyban tartsa a mérleget, azáltal, hogy mindig a megfelelő kitöltési tényezőjű PWM jelet küldi a motornak. A szenzor x tengelyre vonatkozó érzékelője -16 000 (90°balra) től +16 000 (90°jobbra) ig szolgáltat digitális jelet a mikrovezérlőnek. Mikor vízszintest érzékel a szenzor akkor az érték 0.
A beállítások tehát:
Setpoint: 0
Input: szenzor jele
Outpu: Motor PWM jelének kitöltési tényezője
A programhoz az arduino PID könyvtárát használom. A program kb. így fog kinézni:
  1. 1.      #include <PID_v1.h>
  2. 2.       
  3. 3.      //változók deklarálása
  4. 4.      double Setpoint, Input, Output, Kp, Ki, Kd;
  5. 5.      //pid algoritmus konfigurálása
  6. 6.      PID myPID(&Input, &Output, &Setpoint,Kp,Ki,Kd, DIRECT);
  7. 7.       
  8. 8.      void setup()
  9. 9.      {
  10. 10.       Input = AcX;
  11. 11.       Setpoint = 0;
  12. 12.       //PID funkció bekapcsolása
  13. 13.       myPID.SetMode(AUTOMATIC);
  14. 14.     }
  15. 15.      
  16. 16.     void loop()
  17. 17.     {
  18. 18.       //bemenet folyamatos olvasása
  19. 19.       Input = AcX;
  20. 20.       //számítás
  21. 21.       myPID.Compute();
  22. 22.       //kimenet írása
  23. 23.       analogWrite(3,Output);
  24. 24.     }


A kérdésem az lenne, hogy a Kp, Ki, Kd értékeket hogyan kellene beállítani ? A kimenet 0..255 értékű (ez befolyásolja a kitöltési tényezőt. A mintavételezési idő 200 ms.
A hozzászólás módosítva: Nov 5, 2014
(#) pisti0413 hozzászólása Nov 5, 2014 /
 
Sziasztok! Nemrég vettem egy Arduino Mega 2560 as board-ot. Próbaként réraktam egy sima led villogtató programot. Azóta viszont a softwer nem találja a boardot, vagy ha más gépre dugom rá az látja de nem tudok programot rátölteni mert megszakad timeout ra.
Ha valaki tudja a probléma okát annak előre is köszönöm a segítséget.
(#) TavIR-AVR válasza pisti0413 hozzászólására (») Nov 5, 2014 /
 
A Tools Board alatt igaz a Mega2560 van kiválsztva?
COM port kiválasztás OK?

Melyik keretrendszer, milyen oprendszer (verzióval)?
(#) TavIR-AVR válasza icserny hozzászólására (») Nov 5, 2014 /
 
ENC28J60: 5V tolerant a bemenetei, csak a tápfeszre kell 3.3V
(#) pisti0413 válasza TavIR-AVR hozzászólására (») Nov 5, 2014 /
 
A port menüpont halványal van írva, szóval váasztani se tudok.
Ha a gépre gondoltál azon xp van net 3.5 keretrendszerrel.
(#) Chipmunk1960 hozzászólása Nov 5, 2014 /
 
Sziasztok! Nem találtam sehol megoldást, így itt kérdezek. Pontosabban ezt a kérdést már '13-ban feltették, azt megtaláltam, de megoldást nem. Ard Mega 2560 board, 1.05ver. software. Shield+TFT_320QVT touch display. Az UTFT.zip-et már többször letöltöttem, elméletileg mindent a helyére bemásoltam. Example & Libraries. Fordításkor a következő hibával áll meg:
Idézet:
„In file included from UTouch_ButtonTest.ino:13:
C:\Program Files (x86)\Arduino\libraries\UTouch/UTFT.h:162: error: 'bitmapdatatype' has not been declared”
Néztem, cseréltem a UTFT.h filet, de semmi változás. Van esetleg valami ötlet, találkozott valaki ilyennel? Köszi: Mike
(#) TavIR-AVR válasza pisti0413 hozzászólására (») Nov 5, 2014 /
 
Soros driver fenn van? Ismeretlen eszköz?
Ha a drivert megmutatod neki?

Arduino keretrendszer verzió?
(#) icserny válasza Chipmunk1960 hozzászólására (») Nov 5, 2014 /
 
Idézet:
„Van esetleg valami ötlet, találkozott valaki ilyennel?”

Hogyne, Google barátod bizonyára találkozott már vele...
(#) Chipmunk1960 válasza icserny hozzászólására (») Nov 5, 2014 /
 
Igen, ezeket már végig zongoráztam....
(#) atus1981 válasza Chipmunk1960 hozzászólására (») Nov 6, 2014 /
 
Bővebben: Link
itt van Bővebben: Link
Én ez alapján indultam el, de mégsem működik.
A meghajtó chip alapján módosítani kell a kódot, neked hátha menni fog, nekem nem ment...

Link javítva.
Használd a link gombot!
-moderátor-
A hozzászólás módosítva: Nov 6, 2014
(#) erdeidominik1999 hozzászólása Nov 6, 2014 1 /
 
Még egy kérdésem lenne. A hálózati 230v-ot szeretném arduinoval analogRead()-elni. Azt tudom, hogy ha nagyobb mint 5v-ot akarok, akkor ha 2 ellenállást használok, működik, de ide milyen egyenirányító és mekkora értékű ellenállás kéne? (Fontos lenne, hogy ne kelljen táp!)
(#) Kovidivi válasza erdeidominik1999 hozzászólására (») Nov 6, 2014 / 1
 
Szia Aki olyanokat kérdez, hogy tranzisztor elé milyen ellenállást tegyen, meg mi az a FET, az ne méregesse a 230V-ot! Én már szerintem vagy 10éve érdeklödök az elektronika iránt, de ilyen igény, mint a tied, még fel sem merült bennem. Tisztában vagy, hogy amit akarsz, az életveszélyes? Keress más megoldást, vagy írd le a megoldandó feladatot, mihez kell ez egyáltalán?
(#) erdeidominik1999 válasza Kovidivi hozzászólására (») Nov 6, 2014 /
 
Szia tisztában vagyok vele, hog életveszélyes. Amihez kell: Az egyik eszköz, amit építek, tartalmazni fog egy szünetmentes táp "részt" is, és így szerném leolvasni, hogy mikor megy el a hálózati áram. De a táp azért nem jó, mert ugye ott kikapcsolás után még marad benne egy kis áram egy ideig, és akkor nem rögtön kapcsol át aksira.
(#) Kovidivi válasza erdeidominik1999 hozzászólására (») Nov 6, 2014 1 /
 
Hello.
Rakj a transzformátor szekunder kivezetésére egy diódát, erre rakj 100kohm-ot elöterhelésnek, ezt pedig mérheted analogread-del. Esetleg rakj utána feszültség osztót. Ha elmegy a 230V, itt sem lesz feszültség, mert kondi sincs, viszont az Arduino tápjában levö kondiban még lesz elég tárolt töltés az átkapcsoláshoz.
(#) vilmosd válasza erdeidominik1999 hozzászólására (») Nov 6, 2014 / 1
 
A tap szekunder oldalan be kell tenni a greatz es a tapkondi koze egy diodat, es a dioda ele egy optot (4N35) Amig van halozat, addid az opto vezet, es 100 Hz-es impulzusokat ad., de amikor a tap elmegy megszunik az impulzus. Ebbol tudhatod hogy nincs tovabb fesz a halozaton. Ez nem eletveszelyes. Esetleg egy kozonseges NPN tranyoval hasonlo eredmenyt erhetsz el,
(#) atus1981 válasza Chipmunk1960 hozzászólására (») Nov 6, 2014 /
 
ÜDv!
Jutottál valamire?
(#) erdeidominik1999 válasza Kovidivi hozzászólására (») Nov 8, 2014 /
 
Szia! De milyen feszültségű legyen a szekunder? És egyenirányítás nem kell?
(#) Chipmunk1960 válasza atus1981 hozzászólására (») Nov 8, 2014 /
 
Szia, Most kezdtem neki megint, amit eddig sikerült képet kiküldeni rá, azt is szerencsésen letöröltem Csak azóta, újra kellett tenni a win-t, habár 1-1 ben lementettem a könyvtárat valami mégsem szuperál, most próbálom, amit küldtél linket. Köszi!
(#) Chipmunk1960 válasza Chipmunk1960 hozzászólására (») Nov 8, 2014 /
 
Akármit csinálok:
Idézet:
„In file included from UTFT_Demo_320x240.ino:13:
C:\Program Files (x86)\Arduino\libraries\UTouch/UTFT.h:162: error: 'bitmapdatatype' has not been declared”
ezzel a bitmap-el van gondja. De amit most másoltam be, annak a könyvtárnak UTFT2 nevet adtam, és mégis máshol matat...
(#) icserny válasza Chipmunk1960 hozzászólására (») Nov 8, 2014 /
 
A saját felhasználói mappádban tedd be az Arduino/libraries almappába!
(#) Chipmunk1960 válasza icserny hozzászólására (») Nov 8, 2014 /
 
Ott van, a 162. sorra írja ki a hibát, a fiam azt írta:
Idézet:
„ebből hiányzik a bitmapdata osztály”
, de hogy miez???
(#) Panhard hozzászólása Nov 8, 2014 /
 
Sziasztok!
Van egy ENC28J60-as ethernet modulom. Addig eljutottam vele, hogy egy weblapot meg tudok vele jeleníteni. Viszont a email küldés nem akar összejönni. Tudtok ebben segíteni? Neten nem nagyon találok erre a modulra példákat, csak az Arduino Ethernet Shield-re.

IMG_2313.JPG		    
(#) erdeidominik1999 hozzászólása Nov 8, 2014 /
 
Sziasztok! Lenne egy fura kérdésem, hogyan lehetne egy char-rel létrehozott változóval azt megcsinálni, hogy ha egy megadott szöveg "benne van", akkor a változó másik fele, a megadott szöveg nélkül átkerüljön egy másik változóba.
pl.: a megadott szöveg: abc és a char1 == abc123, akkor a char2 123 lesz vagy char1== abc456 a char2 456 lesz.
Ezekre szükség lehet! - HESTORE.HU

4N35
LM350T
ENC28J60-I/SO
MPSA92
ACT108-800EQP
Következő: »»   58 / 847
Bejelentkezés

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