Fórum témák

» Több friss téma
Fórum » PIC kezdőknek
 
Témaindító: Placi84, idő: Okt 3, 2005
Témakörök:
- A PIC ÖSSZES Vdd és Vss (AVdd és AVss) (tápfeszültség) lábát be kell kötni!
- A táplábak mellé a lehető legközelebb 100nF-os KERÁMIA kondenzátorokat kell elhelyezni.
- Az MCLR lábat, 10kohm-mal fel kell húzni a Vdd tápfeszültségre.
- Külső kvarc használatakor 4MHz-ig XT, a fölött pedig HS konfigurációt kell beállítani.
- Stabilizált tápegységet kell használni, a kapcsoló üzemű "telefon töltő" adapterek okozhatnak hibákat.
- Programozáshoz, használj lehetőleg PICKIT2 vagy 3 programozót. Kerülendő a JDM (soros porti) programozó.
- A PIC adatlapja (PDF), tartalmazza a lábak kiosztását és a PIC minden paraméterét. Az adatlap ingyen letölthető!
- Egyes PIC típusoknál az RA4 nyitott nyelőelektródás (Csak lefelé húz L szintre, H szintet nem ad ki!)
- Ha a PGM lábat digitális ki-/bemenetnek használod, az alacsony feszültségű programozási lehetőséget le kell tiltani.
Lapozás: OK   1172 / 1179
(#) Laja1 hozzászólása Jan 26, 2022 /
 
Átírtam, de hibára futott. Bizonyára nem pontosan ugyanaz a konfigurációja. Végig kell néznem.
(#) Hp41C válasza Laja1 hozzászólására (») Jan 26, 2022 /
 
Így csak sajnálkodni tudunk, de ha látnánk is a hibalistát, rögtön lenne ötletünk.
(#) Laja1 válasza Hp41C hozzászólására (») Jan 26, 2022 /
 
Annyi volt, hogy írtad, hogy felülírtam a delay_ms definiálását, így azt a sort kikommenteltem. Erre most meg az lett a baja. Így ismét benne hagytam és most szépen lefordult. Köszönöm. (Elhamarkodottan írtam, bocsi.)
(#) Laja1 hozzászólása Jan 26, 2022 /
 
De abban mégis kérném a segítségeteket, hogy miért van az, hogy a stopper szépen számol másodpercenként, akár másfél, két percig is, utána valamiért várakozik 2-3 másodpercet, majd újra szépen fut. Mi lehet ennek az oka?
  1. #include <xc.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  5. //#define _XTAL_FREQ 4000000 ;
  6. #pragma config FOSC = INTOSCIO     // Oscillator ion bits (RC oscillator)
  7. #pragma config WDTE = OFF    // Watchdog Timer Enable bit (WDT disabled)
  8. #pragma config PWRTE = OFF   // Power-up Timer Enable bit (PWRT disabled)
  9. #pragma config BOREN = OFF   // Brown-out Reset Enable bit (BOR disabled)
  10. #pragma config CP = OFF      // Flash Program Memory Code Protection bit (Code protection off)
  11. #pragma config MCLRE = ON
  12. #pragma config LVP = OFF  
  13.  
  14.  
  15. #define bnyomogomb  PORTBbits.RB2
  16. #define jnyomogomb  PORTBbits.RB1
  17. #define oragomb  PORTBbits.RB0;
  18. #define valtas  PORTBbits.RB3  
  19.  
  20.  
  21. #define __delay_ms(x) _delay((unsigned long)((x)*(8000000/4000.0)))
  22. // set up the timing for the LCD delays
  23. #define LCD_delay 0.05 // ~5mS
  24. #define LCD_Startup 17 // ~15mS
  25.  
  26. // Command set for Hitachi 44780U LCD display controller
  27. #define LCD_CLEAR 0x01  // It clears everythings
  28. #define LCD_HOME 0x02  // set the cursor to first line and first row
  29. #define LCD_CURSOR_BACK 0x10 // moves curson one position back
  30. #define LCD_CURSOR_FWD 0x14 //moves curson one position forward
  31. #define LCD_PAN_LEFT 0x18   // used to scroll text left side to scroll text
  32. #define LCD_PAN_RIGHT 0x1C  // used to scroll text right side to scroll text
  33. #define LCD_CURSOR_OFF 0x0C // stops display curson on screen
  34. #define LCD_CURSOR_ON 0x0E  // turns on cursor display
  35. #define LCD_CURSOR_BLINK 0x0F // curson keeps blinking
  36. #define LCD_CURSOR_LINE2 0xC0  // move curson to scond line or second row
  37.  
  38. // display controller setup commands  page 46 of Hitachi datasheet
  39. #define FUNCTION_SET 0x2C // 4 bit interface, 2 lines, 5x10 font
  40. #define ENTRY_MODE 0x06 // increment mode
  41. #define DISPLAY_SETUP 0x0C // display on, cursor off, blink offd
  42.  
  43. #define LCDLine1() LCDPutCmd(LCD_HOME) // legacy support
  44. #define LCDLine2() LCDPutCmd(LCD_CURSOR_LINE2) // legacy support
  45. #define shift_cursor() LCDPutCmd(LCD_CURSOR_FWD) // legacy support
  46. #define cursor_on() LCDPutCmd(LCD_CURSOR_ON) // legacy support
  47. #define DisplayClr() LCDPutCmd(LCD_CLEAR) // Legacy support
  48.  
  49.  
  50. //----------------------------------------------------------------------
  51. // Definitions specific to the PICDEM 2 Plus
  52. // These apply to the Black (2011) version.
  53. //----------------------------------------------------------------------
  54.  
  55. // single bit for ing command register or data register
  56. #define instr 0
  57. #define data 1
  58.  
  59. // These #defines create the pin connections to the LCD in case they are changed on a future demo board
  60. #define LCD_PORT PORTA
  61. #define LCD_PWR 1 // LCD power pin
  62. #define LCD_EN PORTAbits.RA6 // LCD enable
  63. #define LCD_RW 0 // LCD read/write line
  64. #define LCD_RS PORTAbits.RA7 // LCD register  line
  65. #define led PORTBbits.RB5
  66. #define ledgomb PORTBbits.RB7
  67.  
  68. #define NB_LINES 2 // Number of display lines
  69. #define NB_COL 16 // Number of characters per line
  70.  
  71.    
  72. void LCD_Initialize(void);
  73. void LCDPutChar(char ch);
  74. void LCDPutCmd(char ch);
  75. void LCDPutStr(const char *);
  76. void LCDWriteNibble(char ch, char rs);
  77. void LCDGoto(char pos, char ln);
  78. void UpdateTimer (void) ;
  79. //unsigned int k=0;
  80.  
  81.  
  82.  
  83.  
  84.  
  85.  
  86.     /**/
  87.     unsigned char t2cnt,mpflag,mpcount,villog, bgomb, bgombold, jgomb, jgombold, flag,bkeycnt=0, jkeycnt=0, r1cnt,r2cnt,time1=60, time2=30, s,ki, bk=0,
  88.             jk=0, bv=51, jv=51, ogomb, ora, min, sec=0, l, tsec;
  89.      
  90.     void  __interrupt() megszak (void)
  91.     {
  92.         if(PIR1bits.TMR2IF)
  93.         {
  94.             t2cnt++;
  95.             if(t2cnt==10){t2cnt=0;flag |=1;}// lejárt 0,1 sec frissülhet a f?progi
  96.             mpcount++ ;
  97.             if(mpcount==100){mpcount=0;mpflag = 1;} // lejárt az 1 sec        
  98.           PIR1bits.TMR2IF=0;
  99.         }
  100.     }
  101.    
  102.      
  103.     void main (void)
  104.     {
  105.      
  106.      
  107.    
  108.  
  109.  
  110.      
  111.       PCONbits.OSCF=1;  // a bels? oszc. 4 Mhz
  112.      
  113.      
  114.      
  115.       OPTION_REG = 0x55; // Set TMR0 configuration and enable PORTB pullups    
  116.      INTCON = 0b11000000; // ' Enable global interrupts, Disables all peripheral interrupts, disable timer0 interrupt        
  117.       CMCON = 0x07 ;  // analóg komparátorok kikapcsolva, RA0-1 digitális port!
  118.       PORTB = 0b00000111;
  119.        PORTA = 0;
  120.       TRISA = 0b00100000;  //  RA0, RA7 port bemenet, relé vagy LED
  121.       TRISB = 0b00001111; // RB2 és RB3 bemenet, a többi kimenet
  122.      
  123.       // timer2 beállítása
  124.       PR2=249;                  //timer2 250órajel után ujrakezdi a számolást
  125.       T2CON= 0b01001101 ;       //4 el?osztó  modul on 10 utóosztó
  126.       PIE1bits.TMR2IE=1;        // tmr2 irq enable
  127.      
  128.      
  129.        LCD_Initialize();
  130.       while(1)
  131.       {
  132.      
  133.          
  134.           if(mpflag)
  135.            {
  136.                 villog =  ~villog ;   //LED villogtató
  137.                 led =  villog ;
  138.                 mpflag = 0   ;    
  139.            }  
  140.          
  141.           if(flag)              // 0.1 sec lejárt f?program frissítése
  142.           {
  143.             flag=0;
  144.            
  145.             bgombold = bgomb ;
  146.             bgomb = bnyomogomb ;
  147.            
  148.             jgombold = jgomb ;
  149.             jgomb = jnyomogomb ;
  150.             ogomb =oragomb;
  151.            
  152.             if(bgomb == 0 & ogomb ==0) l=1;
  153.              if (l==1)
  154.             {
  155.                
  156.                  
  157.                  UpdateTimer ();
  158.                
  159.                     LCDGoto(4,1);
  160.                     LCDPutChar((ora/10)+0x30);
  161.                     LCDPutChar((ora%10)+0x30);
  162.                     LCDPutChar(0x3A);
  163.                
  164.                    
  165.                     LCDPutChar((min/10)+0x30);
  166.                     LCDPutChar((min%10)+0x30);
  167.                     LCDPutChar(0x3A);
  168.                
  169.                    
  170.                     LCDPutChar((sec/10)+0x30);
  171.                     LCDPutChar((sec%10)+0x30);
  172.                    
  173.             }
  174.            
  175.                
  176.                
  177.                
  178.                
  179.            
  180.             if (bgomb == 0 & bgombold == 1 /*& bv>50 */)   //lenyomtuk a gombot, magasból alacsony szintre vált a bemenet
  181.             {  bv=0;  
  182.                 if (valtas) bk--;
  183.                 else        bk++;
  184.                 bkeycnt=0;
  185.          
  186.             }
  187.              bv++;  
  188.            
  189.             if(bgomb == 0)     //ha még mindig nyomva
  190.             {
  191.                
  192.                  
  193.                 bkeycnt++;
  194.              
  195.                  
  196.             }
  197.              
  198.              
  199.          
  200.             if (bgomb == 1 & bgombold == 0)   //elengedtük a gombot, alacsonyból magas szintre vált a bemenet    
  201.             {
  202.                
  203.                
  204.                 if(bkeycnt>50) //sokáig nyomva volt
  205.                 {
  206.                    ledgomb=1;
  207.                    bk=0;
  208.                    
  209.                  LCDGoto(0,0);
  210.                  LCDPutChar(0x30);
  211.                   LCDPutStr (" ");
  212.                 }
  213.                 else
  214.                 {  
  215.                    
  216.                 LCDGoto(0,0);
  217.                 if(bk<10) LCDPutChar(bk+0x30);
  218.                 else
  219.                     {LCDPutChar((bk/10)+0x30);
  220.                     LCDPutChar((bk%10)+0x30);
  221.                 }  }
  222.                  
  223.          
  224.             }  
  225.           if (jgomb == 0 & jgombold == 1 /*& jv>50 */)   //lenyomtuk a gombot, magasból alacsony szintre vált a bemenet
  226.             {  jv=0;
  227.               if (valtas) jk--;
  228.                 else        jk++;
  229.              
  230.                 jkeycnt=0;
  231.          
  232.             }
  233.                
  234.              jv++;
  235.             if(jgomb == 0)     //ha még mindig nyomva
  236.             {
  237.                
  238.                  
  239.                 jkeycnt++;
  240.              
  241.                  
  242.             }
  243.              
  244.              
  245.          
  246.             if (jgomb == 1 & jgombold == 0)   //elengedtük a gombot, alacsonyból magas szintre vált a bemenet    
  247.             {
  248.                
  249.                
  250.                 if(jkeycnt>50) //sokáig nyomva volt
  251.                 {
  252.                    ledgomb=1;
  253.                    jk=0;
  254.                    
  255.                  LCDGoto(14,0);
  256.                  LCDPutChar(0x30);
  257.                  LCDPutStr (" ");
  258.                 }
  259.                 else
  260.                 {
  261.                 LCDGoto(14,0);
  262.                 if(jk<10) LCDPutChar(jk+0x30);
  263.                 else
  264.                     {LCDPutChar((jk/10)+0x30);
  265.                     LCDPutChar((jk%10)+0x30);
  266.                 }  }
  267.                  
  268.          
  269.             }  
  270.             if (jk==bk & bk>0)
  271.             {
  272.                 LCDGoto(5,0);
  273.                 LCDPutStr ("EGYENLo");
  274.                
  275.             }
  276.            
  277.             if (abs(jk-bk)>=10)
  278.             {LCDGoto(5,0);
  279.                 LCDPutStr ("MOCSING");
  280.                
  281.             }
  282.             if (jk!=bk & abs(jk-bk)<10)
  283.                 {LCDGoto(5,0);
  284.                 LCDPutStr ("       ");}
  285.       }
  286.      
  287.     }
  288.     }
  289.    
  290. void LCD_Initialize()
  291. {
  292. // clear latches before enabling TRIS bits
  293. //LCD_PORT = 0;
  294.     PORTAbits.RA0=0;
  295.     PORTAbits.RA1=0;
  296.     PORTAbits.RA2=0;
  297.     PORTAbits.RA3=0;
  298.     PORTAbits.RA6=0;
  299.     PORTAbits.RA7=0;
  300.  
  301. TRISA = 0b00100000;
  302.  
  303. // power up the LCD
  304. //LCD_PWR = 1;
  305.  
  306. // required by display controller to allow power to stabilize
  307. __delay_ms(LCD_Startup);
  308.  
  309. // required by display initialization
  310. LCDPutCmd(0x32);
  311.  
  312. // set interface size, # of lines and font
  313. LCDPutCmd(FUNCTION_SET);
  314.  
  315. // turn on display and sets up cursor
  316. LCDPutCmd(DISPLAY_SETUP);
  317.  
  318. DisplayClr();
  319.  
  320. // set cursor movement direction
  321. LCDPutCmd(ENTRY_MODE);
  322.  
  323. }
  324.  
  325.  
  326.  
  327.  
  328.  
  329.  
  330. void LCDWriteNibble(char ch, char rs)
  331. {
  332. // always send the upper nibble
  333. ch = (ch >> 4);
  334.  
  335. // mask off the nibble to be transmitted
  336. ch = (ch & 0x0F);
  337.  
  338. // clear the lower half of LCD_PORT
  339. LCD_PORT = (LCD_PORT & 0xF0);
  340.  
  341. // move the nibble onto LCD_PORT
  342. LCD_PORT = (LCD_PORT | ch);
  343.  
  344. // set data/instr bit to 0 = insructions; 1 = data
  345. LCD_RS = rs;
  346.  
  347. // RW - set write mode
  348. //LCD_RW = 0;
  349.  
  350. // set up enable before writing nibble
  351. LCD_EN = 1;
  352.  
  353. // turn off enable after write of nibble
  354. LCD_EN = 0;
  355. }
  356.  
  357. void LCDPutChar(char ch)
  358. {
  359. __delay_ms(LCD_delay);
  360.  
  361. //Send higher nibble first
  362. LCDWriteNibble(ch,data);
  363.  
  364. //get the lower nibble
  365. ch = (ch << 4);
  366.  
  367. // Now send the low nibble
  368. LCDWriteNibble(ch,data);
  369. }
  370.  
  371.  
  372. void LCDPutCmd(char ch)
  373. {
  374. __delay_ms(LCD_delay);
  375.  
  376. //Send the higher nibble
  377. LCDWriteNibble(ch,instr);
  378.  
  379. //get the lower nibble
  380. ch = (ch << 4);
  381.  
  382. __delay_ms(1);
  383.  
  384. //Now send the lower nibble
  385. LCDWriteNibble(ch,instr);
  386. }
  387.  
  388.  
  389. void LCDPutStr(const char *str)
  390. {
  391. char i=0;
  392.  
  393. // While string has not been fully traveresed
  394. while (str[i])
  395. {
  396. // Go display current char
  397. LCDPutChar(str[i++]);
  398. }
  399.  
  400. }
  401.  
  402. void LCDGoto(char pos,char ln)
  403. {
  404. // if incorrect line or column
  405. if ((ln > (NB_LINES-1)) || (pos > (NB_COL-1)))
  406. {
  407. // Just do nothing
  408. return;
  409. }
  410.  
  411. // LCD_Goto command
  412. LCDPutCmd((ln == 1) ? (0xC0 | pos) : (0x80 | pos));
  413.  
  414. // Wait for the LCD to finish
  415. __delay_ms(LCD_delay);
  416. }
  417.  
  418.  
  419. void UpdateTimer (void)
  420. {
  421.      if(mpflag)
  422.                  {
  423.                     sec++;
  424.                 mpflag = 0   ;    
  425.                  }  
  426.    
  427.                
  428.                    
  429.                if (sec==60)
  430.                 {sec=0; min++;}
  431.                
  432.                 if (min==60)
  433.                 {min=0; ora++;}
  434.                
  435.                if (ora==24)  ora= 0;  
  436. }
(#) Laja1 hozzászólása Jan 26, 2022 /
 
Lehet, hogy a baj, hogy számítógépes szimulációval nézem és ha a számítógépem éppen csinál valami gondolkodtatót, akkor itt megáll egy kicsit az "idő" ?
(#) KBal76 válasza Laja1 hozzászólására (») Jan 26, 2022 /
 
Ó, nemár! A szimuláció az nem a valóság! Ha hibát keresel akkor legalább rakj fel egy stoppert a szimulációra, és nézd hogy nem-e állt meg arra az idôre az is. (Mármint nem amit írsz, hanem egy mindentôl független számlálót. Esetleg állítsd meg a szimulációt amikor úgy érzed megakadt, hogy épp hol tart a programban.)
A hozzászólás módosítva: Jan 26, 2022
(#) Laja1 hozzászólása Jan 26, 2022 /
 
Hogy szokás azt csinalni, ha egy LCD-re kiírt visszaszámláló kezdő értékét szeretnénk beállítani? Van erre egy bevált programrészetek C-ben?
Tehát a megfelelő helyen a kurzor villog, vagy az állitandó szám villog. Utána, ha egy gombot hosszan nyomunk, akkor gyorsan fut a szám, ha röviden, akkor csak egyesével.
Köszönöm!
(#) KBal76 válasza Laja1 hozzászólására (») Jan 27, 2022 /
 
Az lenne az ideális ugye, hogy mások által írt kódrészleteket egymásután pakolva mûködne a szimulációd (netán egyszer valami amit összelegóztál)? Tulajdonképp fel is adhatnál egy hirdetést, hogy valaki írja meg neked amit akarsz. De így sosem tanulsz meg programozni, vagy ez nem is volt cél?
(#) Laja1 válasza KBal76 hozzászólására (») Jan 27, 2022 /
 
Szégyelld magad! El se tudod képzelni mennyit küzdök vele. Talán Te is voltál kezdő....
(#) KBal76 válasza Laja1 hozzászólására (») Jan 27, 2022 /
 
A minimális önállóság ebben a sportban nem lehetôség hanem kötelezô tulajdonság.
Pl. azt megkérdezni hogy a felhúzó ellenállás hogyan van, nos ha elôkapod az adatlapját akkor egyértelmû a helyzet. Mindent is kérdezni persze kényelmesebb nyilván.
szerk: És azért kell egyre nagyobb tokot keresned egy ennyire banális feladatra is, mert ez a PIC16F sorozat nem C nyelvre van optimalizálva, ASM-ben programozva töredék helyet foglalna.
A hozzászólás módosítva: Jan 27, 2022
(#) Elektro.on válasza Laja1 hozzászólására (») Jan 27, 2022 /
 
Hozz létre egy változót, mondjuk "szamlalo" néven, és azt pöcögtesd ahogy szetretnéd.
Utána ezt kiírathatod ahogy jól esik, akár ciklusban akár valami megszakításon kersztül.
De az LCD az csak legyen egy megjelenítő egység humanoid egyedek számára.
Ha direkt az LCD megjelenítésben játszol ezekkel az értékekkel, előbb utóbb eljutsz oda, hogy készítesz egy eszközt és annak a beállításait az LCD -ről kéne vissza olvasnod.
Tehát - minden munka a háttérben folyik, az LCD csak informálja a felhasználót.
(#) sonajkniz válasza Laja1 hozzászólására (») Jan 27, 2022 / 3
 
Tudom, sokan nem értenek egyet velem, de én minden kezdőnek azt javaslom, első körben assemblyben tanuljon meg programozni, mert ahhoz elengedhetetlen, hogy megismerd a mikrokontroller működését, lelki világát.
Ezen alaptudás nélkül ugyanis csak KBal76 által felvázolt "kódrészletek összelegózása"
módon fogsz tudni programot írni, és ha valami nem működik, önerőből meg nem fejted, mi a gondja.

Ui: Nem utolsó sorban, ha magadnak készítessz pl LCD kezelő rutint, mindíg fogod tudni, hogy működik, és akár sokkal jobbat is írhatsz, Rövidebbett, gyorsabbat, megbízhatóbbat) mint amivel a C könyvtárból dolgozhatsz.
A hozzászólás módosítva: Jan 27, 2022
(#) KBal76 válasza sonajkniz hozzászólására (») Jan 27, 2022 / 2
 
Én totálisan az ASM híve vagyok, talán két alkalommal vetemedtem rá hogy PIC16 családdal magasabb programnyelvhez nyúljak, de ott tipikusan egy szögegyszerû feladat leküzdése volt a cél.
Most feltúrtam egy ~15 éves projektem, itt ugyanez a f628 volt a tok, és kicsivel több fért bele ASM-ben egy stoppernél (konkrétan 5 vaku+dslr fényképezôgép távvezérlô, 4 soros LCD-vel, , menüs agyonkonfigurálással). Épp csak sörért nem ment le. A gombokat és néhány nem idôkritikus funkciót shift-regiszterekkel kezeltem le.
(#) vorosj hozzászólása Jan 27, 2022 /
 
Én assemblyvel kezdtem a PIC programozást, akkor még nem is lehetett máshogy. Sok évig így is folytattam.
Ennek ellenére ma már szerintem nem ez a célszerű. Nagyobb, komplexebb uC-k vannak, a programozók döntő többsége a hatékonyság érdekében már nem a hardver részleteinek megismerésével, regiszter szintű hardver kezeléssel dolgozik.
Más emberek munkájára támaszkodunk, kész periféria könyvtárakat használunk. Nem a hardver regisztereket nézegetjük, hanem a könyvtárakat, API-t, kód generátort. C-ben, C++-ban, vagy akár python, java, feladattól függően.
(#) Laja1 válasza vorosj hozzászólására (») Jan 27, 2022 /
 
Én is így gondolom. Mindenki használ könyvtárat, előre (maga vagy mások által ) megírt blokkokat. Nincs ebben semmi különös. Másoktól tanulni nem szégyen! Senki nem az alapokból rak össze egy programot, hanem tulajdonképpen legózik. Teljesen soha nem megyünk vissza a kályháig. És talán - hobbiként- nem is az a cél, hogy profi programozók legyünk, hanem kedvtelésből egy-két apróságot a magunk számára meg tudjunk csinálni.
(#) nedudgi válasza vorosj hozzászólására (») Jan 27, 2022 /
 
Nulláról elindulva még csak nem is assembly nyelvvel kellene kezdeni.
Folyamatára, amit annyira hajlamosak vagyunk elfelejteni. A feladat megfogalmazása után szerintem alap egységekre kell bontani, "kiemelve"/elhatárolva döntéseket, elágazásokat.
Utána jöhet a többi rész, egy processzor értelmi képességeihez idomítva. Pár év gyakorlattal el lehet jutni oda, hogy az általunk teljesen uralt szubrutinkészlettel komplex feladatokat is meg lehet oldani.
A úgynevezett magas szintű nyelvek természetesen jól használhatók, amíg nem kerülünk közel a hardverhez. A funkciók nagy részét el tudja takarni a nyelv, és keretrendszere, de amikor bonyolultabb perifériát kell vezérelni, regiszterek tucatjait állítgatva, nagy hátrányt jelent a hardver ismeretének hiánya.
(#) vorosj válasza Laja1 hozzászólására (») Jan 27, 2022 /
 
Mikor a PIC megjelent itthon, csak egy éktelen rossz assembler volt hozzá. Valamilyen más oprendszerre írhatták eredetileg, és átgányolták PC-re. Állandóan lefagyott, bizonyos kódméret felett rendszeresen elszállt. Ez odáig ment, hogy kénytelen voltam egy általános célú assembler szerkesztő programban megírni egy primitív fordítót. Lényegében egy macro gyűjtemény volt, az első PIC-eknek kb 40 utasításuk volt összesen.
Aztán a Parallax készített egy jó assemblert, majd némi késéssel a Microchip is.

A szimulátor is elég kalandosan alakult. Eredetileg egy terminálban írogató szimulátort adtak hozzá, iszonyat kényelmetlen volt. Kb. úgy működött, mintha a GDB-t közvetlenül terminálból, parancsokkal vezérelnék. Aztán Rétallér Pista írt egy jól sikerült kis szimulátort, amit kényelmesen lehett használni.
Majd jött a Parallax, végül a Microchipé.
(#) Bakman válasza nedudgi hozzászólására (») Jan 27, 2022 /
 
Hobbielektronika: PIC kezdőknek.

Pl.: PIC18F27Q43: 128 KB programmemória, 8192 byte RAM, mai áron kb. 1100 Ft bruttó. Ebbe azért belefér egy-két nagyobbacska program úgy is, hogy nem ASM-ben van írva.

A regiszterek ismeretével egyetértek, egyszerűen kell.
(#) KBal76 válasza Bakman hozzászólására (») Jan 27, 2022 /
 
Jópofa ez a PIC18 mcu amit írtál. Érdekes/elgondolkodtató a Microchip árképzése, ez olcsóbb mint a legtöbb PIC16 mcu (a Chipcad-nál valami 711Ft br. az SOIC tok), és a tudása meg minden irányban sokszoros. Nyilván egy ilyen chipbe okafogyott ASM-ben fejleszteni , PC-re sem abban írja az ember a szoftver nagyját (bár vannak részletek a mai napig amikor kell).

Laja1:
Idézet:
„Senki nem az alapokból rak össze egy programot, hanem tulajdonképpen legózik. Teljesen soha nem megyünk vissza a kályháig.”

Ez teljes tévedés, nincs királyi út. Egyrészt igenis sokszor kell visszamenni. Valóban legtöbbünknek, nekem is van bejáratott kódgyüjteményem, de egyesével magam írtam, vagy ha valami AppNote-bôl mazsoláztam, akkor lepróbáltam a mûködését, megértettem és felkommenteltem magamnak. A legózás a megúszásról szól nem a tanulásról-tudásról.
Ez olyan mint a puskázás a suliban: ha nem tudsz semmit, akkor lehet neked egy novellára való puskád, akkor is megbuksz
(#) Josi777 válasza Laja1 hozzászólására (») Jan 27, 2022 / 1
 
Idézet:
„Senki nem az alapokból rak össze egy programot, hanem tulajdonképpen legózik. Teljesen soha nem megyünk vissza a kályháig.”

Ez nem igaz, mert van legalább 1 kivétel, ... én
Aritmetikai rutinokon kívül soha nem használtam semmi mást, sőt, volt, hogy még azt is én írtam, amikor 13 bites értéket kellett elosztani 5 bites értékkel, akkor a 16/8-as osztás helyett megírtam a sajátomat, mert pazarlásnak gondoltam
(#) sonajkniz válasza nedudgi hozzászólására (») Jan 28, 2022 /
 
Idézet:
„A feladat megfogalmazása után szerintem alap egységekre kell bontani, "kiemelve"/elhatárolva döntéseket, elágazásokat”

Pontosabban bármit csinálni akarunk, ez a létező legelső lépés!
Amíg ez nincs meg, addig nem lehet megtervezni még áramköri szinten sem.
Legalábbis jól nem.
Én jelenleg pont ezért szívok a munkahelyemen. Egy komplett gépsor vezérlését készítem éppen.
Azzal kezdték a főnökeim, hogy első lépésként (úgy, hogy nincs folyamatterv, nincs elektromos terv, gyakorlatilag csak egy körvonalazott elképzelés van) határozzam meg a kapcsoló szekrények méretét, a kezelőszervek mennyiségét és helyét. (Naná, hogy a tervezett szekrénybe nem fért bele a vezérlés.)
Ezt követően tervezzem meg a vezérlést, hogy el tudják kezdeni a gyártást. Folyamatterv még mindig sehol! (Marhára boldog volt a vezérlés építője, mikor a kész szekrényen kellett módosításokat végeznie.)
Majd közölték velem, hogy jó lenne, ha iparkodnék a program (azaz programok, mert 3 PLC van a gépsorban) megírásával. Ja, hogy folyamatterv még mindig nincs? Sebaj! Csiáljam programírás közben!
(#) Kera_Will válasza sonajkniz hozzászólására (») Jan 28, 2022 /
 
Lehet azért lettek ők a főnökeid , mert nekik sem ment a folyamatterv megalkotása
(#) bbatka válasza sonajkniz hozzászólására (») Jan 28, 2022 /
 
Véletlenül nem egy helyen dolgozunk? Az én főnökeim is ilyenek. Egyébként én gépész karbantartó mérnök vagyok.
(#) sonajkniz válasza bbatka hozzászólására (») Jan 28, 2022 /
 
Idézet:
„Véletlenül nem egy helyen dolgozunk?”

Nem valószínű. Nálunk rajtam és a kollégámon kívül még hobbi szinten sem konyít senki az elektromossághoz.
Bár azt már megtanulták páran, hogy a fázis az ráz is.
(#) bitmixer válasza Josi777 hozzászólására (») Jan 28, 2022 / 2
 
Én is pont ilyen vagyok, és élvezem. A projektjeim túlnyomórészt időkritikusak, így assembly nélkül nem is igazán lehetne őket megcsinálni, csak erősen túlméretezett procikkal.
Csak érdekességként: 8085-tel kezdtem, és helyszűke miatt többször előfordult, hogy három bájtos utasításokat derékba kapott egy ugrás, ilyenkor kellett bűvészkedni, hogy ne legyen ebből baj. Továbbá kénytelen voltam használni a 8085 nem publikus, de jól működő utasításait is...
Ezért vagyok bitmixer
(#) nedudgi válasza bitmixer hozzászólására (») Jan 28, 2022 / 1
 
A Videoton VDT 521xx, ipari, sorozatban gyártott, igen sikeres terméknél is használtunk hasonló megoldást. Egy szurutinba két helyen lehetett belépni, funkciótól függően. A második belépési pont egy utasítás közepe, ahol a kétbájtos második fele egy NOP-nak felelt meg.
(#) nedudgi válasza Bakman hozzászólására (») Jan 28, 2022 /
 
Könnyen el lehet képzelni olyan felhasználást, ahol a kontroller fizikai mérete korlát. Nem lehet nagyobbat betenni egy nyolclábasnál, de a program nem fér el a rendelkezésre álló ROM memóriaterületen, ha "magas szintű" programnyelvet használunk.
(#) Bakman válasza nedudgi hozzászólására (») Jan 28, 2022 1 /
 
Mindenre van magyarázat és az ellenkezőjére is.

Lehet mutogatni hogy kinek mekkora csak éppen a lényeg mellett siklotok el: Hobbielektronika, PIC kezdőknek téma.
(#) nedudgi válasza Bakman hozzászólására (») Jan 28, 2022 / 2
 
Az nem hobbi témának minősül, hogy egy áramkört a lehető legkisebb méretben készítsünk el? Az sem kifejezetten a hobbisták jellemzője, hogy ágyúval lövik a verebet, és egy tenyérnyi lapra készítenek el az áramkört. A hab a MicroChip tortáján, hogy az újabb kontrollerekhez már valószínűleg új programozó (Pickit4) kell.
Kezdőnek, tanulásra, a processzorok, kontrollerek lelkivilágát megismerni nem olyan nyelv kell, ami eltakar mindent.
A hozzászólás módosítva: Jan 28, 2022
(#) KBal76 válasza nedudgi hozzászólására (») Jan 28, 2022 / 1
 
Ha már hobbi meg "olcsóság", meg szimuláció: pl. Proteus-ban szimulálható a PIC16C62B (so28), ami ugyan OTP tok (egyszer írható), viszont Lomex-ben bruttó 100Ft alatt van ha egy csíkot (27 db) vesz valaki, ez kb. két 555 ára. És a PIC16F72A-val kódkompatibilis (kivéve A/D), tehát élôben is be lehet járatni a programot próbapadon. A véglegesbe meg mehet az OTP, és örülés van.
Következő: »»   1172 / 1179
Bejelentkezés

Belépés

Hirdetés
Lapoda.hu     XDT.hu     HEStore.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