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   1123 / 1127
(#) Lamprologus válasza djadji hozzászólására (») Máj 5, 2020 / 1
 
Akkor szedd szét a vevőt, egy PIC-el negáld a kimeneti jelet, és minden stimmel, topic is, működés is!
(#) menyus válasza Lamprologus hozzászólására (») Máj 5, 2020 /
 
Vagy egy inverterrel, minek ahhoz PIC? Jah, hogy topic képes kegyen a project. Értem...
A hozzászólás módosítva: Máj 5, 2020
(#) djadji válasza menyus hozzászólására (») Máj 6, 2020 /
 
Köszönöm a segítő szándékot, de nem lesz jó. Kipróbáltam, és úgy 3 méter körüli távot jelez, ami nekem sok. Előbb az elvet kellene kitalálnom, hogyan tudom az "asztali macskát" érzékelni, utána jöhet a megoldása PICkel.
Felteszem egy kezdő fórumba, ahova eredetileg is kellett volna. Köszi, és bocs megint.
(#) kaqkk válasza djadji hozzászólására (») Máj 7, 2020 /
 
Induktív úton ! Az asztal aljára körben csinálsz egy tekercset és RFID kulcstartót akasztasz a macsek nyakába (a tekercs lesz a leolvasó ....) Vagy ha szerencséd van a cicus "gyári" chipjét is fel tudod használni (az is ilyen elven működik)
A hozzászólás módosítva: Máj 7, 2020
(#) spgabor válasza Taki33 hozzászólására (») Máj 9, 2020 /
 
Sziasztok!

Köszönöm a sok segítséget előre is! Most már kezd jól működni Proteusban is szerencsére. Viszont a megszakításkezelésben elrontottam valamit, amit nem teljesen értek. TMR2IE-vel csináltam a megszakítást, de ha elindítom, akkor a modellezés szerint a CPU felugrik maximális terhelésre és a KIMENET láb fel le ugrál. Próbáltam TMR2IF-re lecserélni TMR2IE-t, ahol rendben is működik, de nem szalad bele a megszakításba. Mi hiányzik, vagy mit rontok el? Már nézem egy ideje, de nem bírok rájönni. Példakódokat is néztem, de nem áll össze sajnos.

Mostani forrásom a következő:
  1. #include <stdio.h>
  2.     #include <stdlib.h>
  3.     #include <pic12f683.h>
  4.     #include <htc.h>
  5.  
  6.     __CONFIG(FOSC_INTOSCIO & WDTE_OFF & PWRTE_OFF & MCLRE_ON & CP_OFF & CPD_OFF & BOREN_OFF & IESO_OFF & FCMEN_OFF);
  7.  
  8.     volatile int csengetes_ido = 5;
  9.     int szamlalo = 0;
  10.  
  11.     #define GOMB_IDO_NOVEL GP4
  12.     #define GOMB_IDO_CSOKKENT GP5
  13.     #define CSENGETES GP1
  14.     #define KIMENET GP2
  15.  
  16.     static void interrupt isr(void){
  17.         szamlalo++;
  18.         if(szamlalo == csengetes_ido){
  19.             szamlalo = 0;
  20.             KIMENET = 1;
  21.             TMR2IF = 0;    // TMR2IE megszakítást engedélyez? bit
  22.  
  23.             TMR2 = 0;
  24.         }
  25.     }
  26.  
  27.     int main() {
  28.         PR2 = 249;    // Timer2 PR2 8bites periódus regiszter
  29.         T2CON = 5;    // T2CON regiszter
  30.         ANSEL = 0; //analog bemenetek kiakpcsolat
  31.         CMCON0 = 0b00000111// komparátor kikapcsolva
  32.         TRISIO = 0b00110010; //GP1, GP4, GP5 inputok
  33.         GPIO = 0x00; // nullazza a labakat
  34.         OSCCON = 0b01100000// 4MHz
  35.         KIMENET = 1;
  36.         TMR2IF = 0;    // TMR2IF megszakítás kérést jelz? bit
  37.         TMR2IE = 0;    // TMR2IE megszakítást engedélyez? bit
  38.         PEIE = 1;    // Peripheral interrupt engedélyezése
  39.         GIE = 1;    // Globális interrupt engedélyezése
  40.         while(1){
  41.             if(!GOMB_IDO_NOVEL){
  42.                 while(!GOMB_IDO_NOVEL){
  43.                     csengetes_ido++;
  44.                 }
  45.             }
  46.  
  47.             if(!GOMB_IDO_CSOKKENT){
  48.                 while(!GOMB_IDO_CSOKKENT){
  49.                     csengetes_ido--;
  50.                 }
  51.             }
  52.  
  53.             if(!CSENGETES){
  54.                 while(!CSENGETES);
  55.                 while(KIMENET){
  56.                         KIMENET = 0;
  57.                        // TMR2 = 0;
  58.                         szamlalo = 0;
  59.                         TMR2IF = 1;
  60.                 }
  61.             }
  62.         }
  63.         return (EXIT_SUCCESS);
  64.     }


Köszönöm és üdv:
spgabor
(#) Taki33 válasza spgabor hozzászólására (») Máj 9, 2020 / 1
 
Összedobtam egy kis programot: Timer2 használata és gombkezelés!

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <pic12f683.h>
  4. #include <htc.h>
  5.  
  6. __CONFIG(INTIO & WDTDIS & PWRTDIS & MCLREN & UNPROTECT & BORDIS & IESODIS & FCMDIS);
  7.  
  8. #define _XTAL_FREQ 4000000      //4MHz
  9.  
  10. unsigned int beallitott_ido = 1000;      // 1000 * 1ms = 1mp
  11. unsigned int ido_szamlalo = 0;
  12.  
  13. #define TMR2_LED GPIO0
  14. #define GP4_GOMB GPIO4
  15. #define GP5_GOMB GPIO5
  16. #define GP1_GOMB GPIO1
  17. #define GP2_KIMENET GPIO2
  18.  
  19. //Megszakítások kezelése
  20. void interrupt ISR()
  21. {
  22.   if (TMR2IF)                             //Ha TMR2 megszakítás történt
  23.   {
  24.     TMR2IF = 0;                           //Jelzöbit törlése
  25.     ido_szamlalo++;                       //ido_szamlalo növelése
  26.    
  27.     if (ido_szamlalo >= beallitott_ido)   //Ha sz ido_szamlalo nagyobb vagy egyenl? mint a beallitot_ido
  28.     {
  29.       ido_szamlalo = 0;                   //ido_szamlalo törlése
  30.       TMR2_LED = !TMR2_LED;               //TMR2 LED invertálása
  31.     }
  32.   }
  33. }
  34.  
  35. //F?program
  36. int main()
  37. {
  38.   OSCCON = 0b01100000//Belsö oszcillátor 4MHz
  39.   ANSEL = 0;            //Analóg bemenetek kikapcsolva
  40.   TRISIO = 0b00110010//GP1, GP4, GP5 bemenet GP0, GP2 kimenet
  41.   GPIO = 0x00;          //Összes láb alacsony
  42.   CMCON0 = 0b00000111//Komparátor kikapcsolva
  43.   TMR2_LED = 0;         //TMR2 LED kikapcsolva
  44.   T2CON  = 0x1C;        //Prescaler 1:1; Postscaler 1:4; TMR2 Preload = 249;       
  45.   PR2 = 249;            //Timer2 1ms megszakítás beállítása
  46.   TMR2IF = 0;           //TMR2 megszakítás törlése
  47.   TMR2IE = 1;           //TMR2 megszakítás engedélyezése
  48.   PEIE = 1;             //Peripheral megszakítás engedélyezése
  49.   GIE = 1;              //Globális megszakítás engedélyezése
  50.   TMR2ON = 1;           //TMR2 bekapcsolva
  51.  
  52.   while (1)
  53.   {
  54.     if (!GP1_GOMB)                    //Ha GP1 Gomb alacsony
  55.     {
  56.       __delay_ms(150);                //Várakozás 150 ms-ig
  57.      
  58.       if (!GP1_GOMB)                  //Ha GB1 Gomb még mindíg alacsony
  59.       {
  60.         GP2_KIMENET = !GP2_KIMENET;   //GP2 kimenet invertálása
  61.       }
  62.     }
  63.  
  64.     if (!GP4_GOMB)                    //Ha GP4 Gomb alacsony
  65.     {
  66.       __delay_ms(150);                //Várakozás 150 ms-ig
  67.      
  68.       if (!GP4_GOMB)                  //Ha GB1 Gomb még mindíg alacsony
  69.       {
  70.         //Ha beallitott_ido kisebb mint 60 mp akkor növeljük 1 mp-el;
  71.         if (beallitott_ido < 60000) beallitott_ido += 1000;
  72.       }
  73.     }
  74.  
  75.     if (!GP5_GOMB)
  76.     {
  77.       __delay_ms(150);
  78.       if (!GP5_GOMB)
  79.       {
  80.         //Ha beallitott_ido nagyobb mint 1 mp akkor csökkentjük 1 mp-el;
  81.         if (beallitott_ido > 1000) beallitott_ido -= 1000;
  82.       }
  83.  
  84.     }
  85.   }
  86.   return (EXIT_SUCCESS);
  87. }
(#) spgabor válasza Taki33 hozzászólására (») Máj 10, 2020 /
 
Szia!

Nagyon köszönöm a példaprogramot. A Proteus fájlba valamiért a programom mindig belefagy, de átrajzoltam az enyémet és megcsináltam az alapján. A hibákat a kódomban javítottaam, így most működik hibátlanul.

Köszönöm és üdv:
spgabor
(#) Taki33 válasza spgabor hozzászólására (») Máj 11, 2020 /
 
Szívesen, örülök hogy segíthettem!
(#) gyoran hozzászólása Máj 11, 2020 /
 
Sziasztok
Új MacBook
Catalina 64 bites Mac OS
MPLAB X IDE 5.35 azt állítja, ő kompatibilis a 64 bittel
Patch csak 5.30-ig van rá
Feltelepítem az 5.35-öt, de azt mondja, hogy bebeeee! 64 biten nem megy, csak az XC8 assembler
De, ha megy akkor miért nem megy?
Kétszer újratelepítve.
Valahol azt olvasom, hogy csak 5.40-től megy 64 biten. De az még nincs.
Én vagyok a béna?

Előre is köszönet minden tippért, ami előre visz.
A hozzászólás módosítva: Máj 11, 2020
(#) Bakman válasza gyoran hozzászólására (») Máj 11, 2020 /
 
WMware Fusion alá egy virtuális gépet valamilyen Windows-zal, amíg fel nem ébrednek az MPLAB fejlesztői.
(#) gyoran válasza Bakman hozzászólására (») Máj 11, 2020 /
 
Aha, akkor jól sejtettem.
Köszi a tippet, előtte megpróbálom downgrade 5.30 és patch.
Ha nem jön be, marad a WMware.

Köszi
(#) gyoran válasza gyoran hozzászólására (») Máj 11, 2020 /
 
Ez félig bejött, de most meg az a gondja, hogy "bad CPU type in exelutable".
Feladom, visszamegyek a Windows gépemre, amíg a Microchip behozza a legalább 3/4 éves lemaradását az APPLE mögött.
A hozzászólás módosítva: Máj 11, 2020
(#) pipi válasza gyoran hozzászólására (») Máj 11, 2020 /
 
Hali!
Az 5.30 nálam gond nélkül megy w8 x64-en
(#) gyoran válasza pipi hozzászólására (») Máj 12, 2020 /
 
Igen, a Win8 tud 32 bites programokat futtatni, a Catalina sajnos már nem adja 64 bit alá. De most azt hiszem, az új intelt nem szereti. Legalábbis gondolom a "mpasmx: Bad CPU type in executable" üzenet ezt akarja sugallni.
(#) eSDi válasza gyoran hozzászólására (») Máj 18, 2020 /
 
Hali!

Ehhez csak annyit fűznék hozzá, állítólag 5.15-ös verziótól van nyűgje Windows alatt is. Nem megy a Debug, nem nyílik meg a Project Properties, stb. Nálam ez az 5.35-ös verzióval jött elő, ami már a Windows 64-bites "Program Files" mappájába települ. Én nem tudtam mit kezdeni vele. Valakinek Windows újra telepítés segített (ez nálam nem opció). A végére páran kaptak valami Patch-et a supportól, ami után jó lett. Addigra én visszaraktam a v5.00-t és az XC8 2.05-öt, ami gond nélkül megy. Szóval várni kell még egy két verzió frissítést.
(#) gyoran válasza gyoran hozzászólására (») Máj 23, 2020 /
 
Megjelent az 5.40 . Ez már fut Catalina 64 biten, csak hiányolja a compilert. Gondolom kifelejtették a csomagból. Ennyit a minőségbiztosításról.
(#) icserny válasza gyoran hozzászólására (») Máj 23, 2020 /
 
Nem kifelejtették, hanem egyszerűen nem része az IDE-nek.
Az XC fordítókat innen lehet letölteni. Már ha azokat akarod használni...
(#) gyoran válasza icserny hozzászólására (») Máj 23, 2020 /
 
Szia, köszi a segítséget.
Az IDE emlékeim szerint régen tartalmazott compilert,de lehet, hogy tévedek.
Az XC C fordítót pedig letöltöttem, de nem igazán csinálja azt, amit megszoktam. Tegnap még az INC fileokban is hibára futott. Megpróbálom még egyszer.
Ha létezik MPASM compiler külön, akkor valószínű az kell nekem.
A hozzászólás módosítva: Máj 23, 2020
(#) icserny válasza gyoran hozzászólására (») Máj 24, 2020 /
 
A régebbi fordítók (C18, C16, C32) az Archivumból tölthetők le.
(#) gyoran válasza icserny hozzászólására (») Máj 24, 2020 /
 
Nos úgy tűnik, az mpasm-nek tényleg vége. Az XC8 assembler fordítója meg - ha igaz - nem kompatibilis az mpasm-re írt forrásokkal. Korábbi mplab x nem kompatibilis a 64 bites Catalinával. A 12f és 16f-re pedig én még mindig jobban szeretek ASM kódot írni, főleg, ha időkritikus, egyszerű feladatról van szó.
5.35-ben még volt MPASM, de az meg nem szerette az új Mac-et.
A kör bezárult, nincs megoldás.
A hozzászólás módosítva: Máj 24, 2020
(#) gyoran válasza gyoran hozzászólására (») Máj 24, 2020 /
 
Tovább megyek, az 5.35 WIN 10 alatt is problémázik, az 5.30 megy. Az 5.40 -et meg sem próbálom. Az XC-ASM -ről eddig csak lesújtó híreket olvastam fórumokon.
Szép új világ. Lassan nem lesz használható ASM fordító, ezek szerint?
(#) Peet19 hozzászólása Máj 30, 2020 /
 
Sziasztok!
A PIC16F887 adatlapján mit jelent pontosan a 8kx14 ?
Nem vagyok benne biztos hogy jól értelmezem a tanulmányaimat, de azért leírom hogy gondolom.
Ha jól tudom akkor a 8k az 8 kilószót jelent (8 * 1024 szó), vagyis egy gépi szó egy utasításnak felel meg a programban amit 8biten tárol( vagy 14?). A 14 az a programmemória adatszélessége (14bit)?
Ha 8kx8 lenne akkor a memória mérete 8 * 1024 * 8bit (azaz 1 byte), akkor az 8kB?
Ha 14 bit széles akkor 8kB * (14 / 8) 1.75 = 14kB?
Lehet túl bonyolítom egy kicsit de ezt még nem értem teljesen. Ha valaki elmagyarázná hogy kell ezt pontosan értelmezni meg kiszámítani, akkor azt megköszönném.
Előre is köszi.
(#) proli007 válasza Peet19 hozzászólására (») Máj 30, 2020 /
 
Hello! Nem kell itt kiszámolni semmit, 8k a programtároló, de a RISC utasításkészlet tartalma miatt 14 bites. Itt a 4. oldalon megnézheted.
(#) Peet19 válasza proli007 hozzászólására (») Máj 30, 2020 /
 
Megnéztem, köszönöm. Ha jól értem akkor a 8kx14 nem pontosan a memória méretét adja meg, hanem hogy 8 kilószó tárolható 14 biten? Vagyis minden egyes utasítást 14 biten tárol, még akkor isl ha pl. 4biten is elférne?
(#) nedudgi válasza Peet19 hozzászólására (») Máj 30, 2020 /
 
Egyszerűen engedd el ezt a bájt alapú memóriaszámítást ilyem mikrokontrollerek esetén. A memória szavas szervezésű - itt 14 bit. Lehet trükközni hogy pár karakterrel többet zsúfolj bele, de a megvalósított algoritmus valószínűleg több memóriát használ el, mint amennyit meg tudsz spórolni - tekintettel a szűkös memóriaméretre.
(#) nedudgi válasza Peet19 hozzászólására (») Máj 31, 2020 /
 
Az ókorban voltak olyan számítógépek (processzorok, amelyek hat bites bájtokkal értelmezték az elérhető memóriát, mint például a PDP8 (=TPA1001). Ezeknél az utasítások mindig szóhatáron kezdődtek. Az ALU (aritmetikai-logikai egység) viszont 8 biten dolgozott.
A Neumann-féle processzorokon (melyek a programot RAM-ból futtatják) másképpen kell értelmezni a dolgot, mint a ROM-ból futtató processzoroknál, ahol a program/adat memória szigorúan el van választva egymástól.
A négy biten elférő utasítás kicsit félrevezető, mert ilyenkor a négy bites utasításkód bitjeihez hozzá kell számolni az operandus hosszát.
Meg kell különböztetni az adatmemóriát, (ami szinte mindig nyolc bites bájtokra van felosztva) a programmemóriától, ahol szóhatáron kezdődik minden utasítás.
A hozzászólás módosítva: Máj 31, 2020
(#) icserny válasza nedudgi hozzászólására (») Máj 31, 2020 /
 
Lehet, hogy a magas szintű programnyelvekben 6-bites "bájtokkal" is lehetett számolni, de fizikailag a PDP-8/TPA számítógépek 12 bites szószervezésűek voltak, ilyen egységekben lehetett a memóriához hozzáférni adatbeolvasásnál vagy írásnál is és az ALU is 12 bites adatokkal dolgozott, s 12 bites volt az akkumulátor regiszter, a "szorzó" regiszter és a programszámláló regiszter is.

A memória címzése három fokozatú volt:
- Közvetlenül 2x128 szó volt elérhető: a "saját" lap, vagy a nulladik lap (7+2 bit címzés)
- Indirekt címzéssel (egy 12 bites szó címként történő felhasználásával) 4096 szavas memória modul (field) volt címezhető
- Field váltó utasításokkal (ami a perifériás utasításokhoz volt besorolva!) lehetett váltani, hogy melyik 4096 szavas modult címezzük.

PDP-8 utasításkészlet
TPA-1001
(#) gyoran válasza Peet19 hozzászólására (») Máj 31, 2020 /
 
Egyébként az adott esetben a 8kx14 a tényleges memória méret. Egy szóban (14 bit) általában az MSB oldalon van a parancs és az LSB oldalon adat vagy paraméter van. A PIC16F628A leírásában - nálam - a 115. oldal alján látszik a legjobban a modell, (Figure 15-1). Ez alól pár operandus nélküli utasítás kivétel, ami a teljes 14-bitet egyértelműen foglalja pl NOP (00...00).
(#) Peet19 válasza nedudgi hozzászólására (») Máj 31, 2020 /
 
Köszi, értem.
gyoran. köszi neked is nézem az adatlapot.
Tehát akkor a 8kx14 re nem lehet egyértelműen kimondani hogy a memória mérete 8kB?
Csak akkor lenne így ha 8kx8 lenne?
(#) gyoran válasza Peet19 hozzászólására (») Máj 31, 2020 /
 
Igen, jól látod. Ez egyébként a programmemória, tudományosan mondva ez nem Neumann architektura hanem - talán - Harward. Külön van választva az adat (8bit) és programm (itt: 14 bit ) memória.
Következő: »»   1123 / 1127
Bejelentkezés

Belépés

Hirdetés
Lapoda.hu     XDT.hu     HEStore.hu