Fórum témák

» Több friss téma
Fórum » PIC programozása C nyelven, C-Compiler
Lapozás: OK   150 / 153
(#) sdrlab válasza Zsora hozzászólására (») Máj 5, 2021 /
 
Ez az, ezt kerestem..., köszi!!!
(#) Laja1 hozzászólása Máj 10, 2021 /
 
Sziasztok!
Ezt a programot szeretném UPP628-as programozóval beégetni:
  1. #include <xc.h>
  2. #define _XTAL_FREQ 2097120 //define crystal frequency to 20MHz
  3.  
  4. // CONFIG
  5. #pragma config FOSC = XT     // Oscillator Selection bits (RC oscillator)
  6. #pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
  7. #pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
  8. #pragma config BOREN = OFF       // Brown-out Reset Enable bit (BOR disabled)
  9. #pragma config CP = OFF      // Flash Program Memory Code Protection bit (Code protection off)
  10.  
  11.  
  12. #define gomb RA0
  13. int k=0;
  14. int z=3;
  15. int t;
  16. int n=1;
  17.  
  18.  
  19.  
  20.  
  21. void main() {
  22.     ADCON1 = 0x0F;  //digitális bemenet és nem analóg
  23.     TRISB = 0x00; //Port-B as Output
  24.     TRISA = 0x01; //RA as input
  25.     T1CON = 0x30;  //Timer beállítás. ki kell számolni 1 sec alatti m?veletek számát: XTAL_FREQ/4/Prescaler= 1 sec alatti m?veletszám
  26.  
  27.     // megszakítások beállítása
  28.     /* PIE1bits.TMR1IE=1;              // Timer1 megszak. engedélyezés
  29.      PIR1bits.TMR1IF=0;              // Timer1 megszakításjelz? törlése
  30.      INTCONbits.PEIE=1;              // periféria megszak. engedélyezés
  31.      INTCONbits.GIE=1;            */   // globális megszak. engedélyezés  
  32.        
  33.        // TMR1H=0x0B;  Feltöltés 16 bit-es timernél a fels? és als? 8 bitet külön adjuk meg. Vagy hexadec vagy rendes számmal.
  34.         //TMR1L=0xDB;  Innen fog indulni egyesével felfelé a számláló és FFFF-nél túlcsordul, akkor indul 0-ról vagy újabb feltöltésnél onnantól
  35.     //TMR1=3035;
  36.            
  37.      
  38.         T1CONbits.TMR1ON=0;   //Timer nem indul  
  39.         PIR1bits.TMR1IF=0;  //Nincs túlcsordulva
  40.        
  41.        
  42.     while (1)
  43.     {
  44.            
  45.       if (gomb==1)
  46.       {
  47.          
  48.           __delay_ms(300);
  49.      
  50.                  if (gomb==1)
  51.               {__delay_ms(2000);
  52.                  if (gomb==1)
  53.                  { PORTBbits.RB6=1;
  54.                  __delay_ms(1000);
  55.                  PORTBbits.RB6=0;
  56.                  
  57.                   __delay_ms(1000);
  58.                   PORTBbits.RB6=1;
  59.                  // T1CONbits.TMR1ON=1;
  60.                   z=0;
  61.                    while (n)
  62.           {__delay_ms(1000);
  63.           // if (PIR1bits.TMR1IF==1)  //ha túlcsordult
  64.            // { PIR1bits.TMR1IF=0;
  65.                 z=z+1;
  66.            if (gomb==1) {n=0;}
  67.                    }
  68.                
  69.                  
  70.                  // T1CONbits.TMR1ON=0;
  71.                   PORTBbits.RB6=0;
  72.            
  73.          
  74.                  
  75.                  }
  76.                  n=1;
  77.                  }
  78.                  
  79.      
  80.           PORTBbits.RB3=1;
  81.           T1CONbits.TMR1ON=1;
  82.           k=0;
  83.          
  84.           while (k<z+2)
  85.           {
  86.            if (PIR1bits.TMR1IF==1)  //ha túlcsordult
  87.             { PIR1bits.TMR1IF=0;
  88.        
  89.             k=k+1;}
  90.          if (k==1)
  91.          {
  92.           PORTBbits.RB5=1;  
  93.          }
  94.            if (gomb==1)
  95.            {PORTBbits.RB5=0;}
  96.          if (k==z+1)
  97.          {
  98.           PORTBbits.RB5=0;  
  99.          }
  100.          if (k==z+2)
  101.          {
  102.           PORTBbits.RB3=0;  
  103.          }
  104.           }
  105.           T1CONbits.TMR1ON=0;
  106.          
  107.          
  108.          
  109.          
  110.       }
  111.    
  112. }
  113. }


A program szépen lefordult, az égetés után azt írja "Konfig word hiba".
Az ellenőrzésre pedig ezt:
"Kód hiba itt:0x0000 Kiolvasva 0x3FFF, ellenőrizva: 0x2FF2"

Mi lehet az oka?
Köszönöm!
(#) Bakman válasza Laja1 hozzászólására (») Máj 10, 2021 /
 
Melyik PIC-ről van szó?
(#) Laja1 válasza Bakman hozzászólására (») Máj 10, 2021 /
 
(#) pipi válasza Laja1 hozzászólására (») Máj 10, 2021 /
 
Nem ismerem ezt a programozót... Ha csinálsz egy törlést és utána visszaolvasod, akkor mi van a config word-ben?
(#) Laja1 válasza pipi hozzászólására (») Máj 10, 2021 /
 
Töröltem, majd visszaolvastattam és mindenhol 3FFF szerepel. 0x2007:3FFF.
(#) pipi válasza Laja1 hozzászólására (») Máj 10, 2021 /
 
Próbáld ki hogy a konfigokat végig kikommenteled, újrafordítod, akkor így besül-e...
Esetleg utána egyesével visszarakod a konfig sorokat és mindig próbálsz egyet sütni...
(#) Laja1 válasza pipi hozzászólására (») Máj 10, 2021 /
 
Minden verzióra ugyanez a hibaüzenet jön...
(#) pipi válasza Laja1 hozzászólására (») Máj 10, 2021 /
 
Másik programozóval meg kellene próbálni, akkor kiderül hogy a pic, vagy az égető/sw a rossz
(#) Laja1 válasza pipi hozzászólására (») Máj 10, 2021 /
 
Köszönöm. Egy 10 perces ki/bekapcsolással most hibátlanul lefutott.
(#) Laja1 válasza pipi hozzászólására (») Máj 10, 2021 /
 
Most próbapanelen próbálom, de teljesen másképp működik, mint a program. 3 db 1,5 V-os elemről táplálom, stabil 4,71 V. Lehet, hogy kevés?
Vagy lehet, hogy a próbapanel nem mindig érintkezik biztosan? Vagy kipurcant a PIC?
Ha a kapcsolót be se kapcsolom, akkor is van a 9. kimeneten feszültség. Hol 3,8 V, hol 0 V, ingadozik.
(#) Bakman válasza Laja1 hozzászólására (») Máj 10, 2021 /
 
Húzd fel a bemenetet 1 - 10 kΩ-os ellenállással. 4.71 V-nak bőven elégnek kell lennie.
(#) Laja1 válasza Bakman hozzászólására (») Máj 10, 2021 /
 
És gondolod, hogy ezzel a zűrzavaros működés meg is oldodna?
(#) Laja1 válasza Laja1 hozzászólására (») Máj 10, 2021 /
 
Egyébként 4k7 ellenállással fel van húzva.
(#) Laja1 válasza Bakman hozzászólására (») Máj 11, 2021 /
 
Ha a PIC rossz, akkor már az égetés ellenőrzésekor felmerül hiba, vagy előfordulhat olyan is, hogy hibátlanul beég a szoftver, de fizikailag mégis hibás a PIC?
(#) Bakman válasza Laja1 hozzászólására (») Máj 11, 2021 /
 
Nem közöltél kapcsolási rajzot, az ilyen hibás működések egyik alapja általában az, hogy lebeg a bemenet.

Ha a programozáshoz használt lábak működnek, attól még a kontroller egyik-másik portja lehet hibás.

Egyszerűsítsd le a programot a végletekig. Ha a bemenet magas, a kimenet is magas, ha a bemenet alacsony, a kimenet is. Ezzel ellenőrizhető egy ki- és bemenet páros.
(#) Laja1 válasza Bakman hozzászólására (») Máj 11, 2021 /
 
Köszönöm! Ez önmagában is egyszerű volna, ha egy nyomógombot benyomunk, akkor meghúz egy relé tranzisztoron keresztül, majd 1 s után egy másik relé is meghúz. Utána kikapcsol a második relé, majd az első is. Ha hosszan nyomjuk a nyomógombot, akkor egy LED világít.
De nem működik, ezért leegyszerűsítettem egy nyomógombra és egy LED-es kimenetre, amit az első relé helyére tettem. De gombnyomás nélkül is világít a LED, hol erősebben, hol kevésbé. Ahogy a programban is látszik csak egy bemenetet hagytam bemenetnek, a többi kimenet. A nyomógombot bekötöttem a bemenetet (RA0) és + 5V-ra közé, és a földet összekötöttem a bemenettel 4k7 ellenálláson át.
Valószínű kuka a kontroller?
(#) Bakman válasza Laja1 hozzászólására (») Máj 11, 2021 /
 
Ettől sokkal egyszerűbb programot készíts, a feltöltött eléggé zavaros.
  1. if (gomb==1) {
  2.     PORTBbits.RB6=1;
  3. }
  4. else {
  5.     PORTBbits.RB6=0;
  6. }
(#) AZoli hozzászólása Júl 19, 2021 /
 
Sziasztok!
CRC32 -t próbálok ellenőrizni pic24 -el, de nem kapok jó eredményt.
Az adatokat, és a CRC -t ellenőriztem egy webes crc generátorral, ott jó eredményt kapok. De a C kódom valahol hibás, nem találom hogy mi a baj vele.
  1. byte testByteArray[177] = {0x82, 0x81, 0x80, //Header
  2.     0x54, //Lenght
  3.     0x00, 0x00, 0x00, 0x32, 0x03, 0xE8, 0x00, 0xC8, 0x03, 0x20, 0x06, 0x23, 0x06, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D,
  4.     0xC6, 0x00, 0x00, 0x0D, 0xCA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  5.     0x00, 0x00, 0x05, 0x1B, 0x00, 0xF7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  6.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB7,
  7.     0x00, 0x32, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  8.     0x00, 0x10, 0x53, 0x0F, 0x47, 0x00, 0x00, 0x00, 0x00, 0x01, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x08, 0x00, 0x00,
  9.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  10.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
  11.     0x69, 0x7A, 0xA6, 0x51}; //CRC32
  12.  
  13.     //uLong CRC_POLYNOM = 0xEDB88320;
  14.     uLong CRC_POLYNOM = 0x04C11DB7;    
  15.     //uLong CRC_POLYNOM = 0x82608EDB;        
  16.     //uLong CRC_POLYNOM = 0xDB710641;
  17.     uLong crc = 0;
  18.     uLong RecCrc =
  19.         (((uLong)(testByteArray [172]) << 24) & 0xFF000000) |
  20.         (((uLong)(testByteArray [173]) << 16) & 0x00FF0000) |
  21.         (((uLong)(testByteArray [174]) << 8) & 0x0000FF00) |
  22.          ((uLong)(testByteArray [175]) & 0x000000FF);
  23.    
  24.     int i = 0;
  25.     for (i = 0; i < 173; i++)//172
  26.     {
  27.         crc = crc ^ testByteArray[i];
  28.         int j = 0;
  29.         for (j = 0; j < 8; j++)
  30.         {
  31.             if (crc & 0x0001) crc = (crc >> 1) ^ CRC_POLYNOM;
  32.             else crc = (crc >> 1);
  33.         }
  34.        
  35.         if ((crc == RecCrc) && (RecCrc != 0))
  36.         {
  37.             Nop(); //Csak teszt, ha bárhol egyezés lenne...
  38.         }
  39.     }

A csatolt kép kijelölt sorában látszik, hogy kijön a helyes 0x697AA651 ellenőrző kód, de nekem nem sikerül ezt az eredményt kapnom.

CRC32.jpg
    
(#) majkimester válasza AZoli hozzászólására (») Júl 19, 2021 / 1
 
Szia,
A tömböd nem 177 hanem 176 hosszú. A rekord CRC-t a 172-175 index-ekről olvasod.
Ezt javítva meg, kicsit más algoritmust használva működik:

  1. byte testByteArray[176] = {0x82, 0x81, 0x80, //Header
  2.         0x54, //Lenght
  3.         0x00, 0x00, 0x00, 0x32, 0x03, 0xE8, 0x00, 0xC8, 0x03, 0x20, 0x06, 0x23, 0x06, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D,
  4.         0xC6, 0x00, 0x00, 0x0D, 0xCA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  5.         0x00, 0x00, 0x05, 0x1B, 0x00, 0xF7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  6.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB7,
  7.         0x00, 0x32, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  8.         0x00, 0x10, 0x53, 0x0F, 0x47, 0x00, 0x00, 0x00, 0x00, 0x01, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x08, 0x00, 0x00,
  9.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  10.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
  11.         0x69, 0x7A, 0xA6, 0x51}; //CRC32
  12.      
  13.         uLong CRC_POLYNOM = 0xEDB88320;
  14.         //uLong CRC_POLYNOM = 0x04C11DB7;    
  15.         //uLong CRC_POLYNOM = 0x82608EDB;        
  16.         //uLong CRC_POLYNOM = 0xDB710641;
  17.         uLong mask;
  18.         uLong crc = 0xFFFFFFFF;
  19.         uLong RecCrc =
  20.             (((uLong)(testByteArray [172]) << 24) & 0xFF000000) |
  21.             (((uLong)(testByteArray [173]) << 16) & 0x00FF0000) |
  22.             (((uLong)(testByteArray [174]) << 8) & 0x0000FF00) |
  23.              ((uLong)(testByteArray [175]) & 0x000000FF);
  24.        
  25.         int i = 0;
  26.         for (i = 0; i < 172; i++)//172
  27.         {
  28.             crc = crc ^ testByteArray[i];
  29.             int j = 0;
  30.             for (j = 0; j < 8; j++)
  31.             {
  32.                 mask = -(crc & 1);
  33.                 crc = (crc >> 1) ^ (CRC_POLYNOM & mask);
  34.             }
  35.         }
  36.         crc = ~crc;
  37.  
  38.         printf("CRC=%8.8X\n", crc);
  39.         printf("Rec CRC=%8.8X\n", RecCrc);
  40.        
  41.         if ((crc == RecCrc) && (RecCrc != 0))
  42.         {
  43.             printf("OK\n");
  44.         }
  45.         else {
  46.             printf("NOT OK\n");
  47.         }
(#) AZoli válasza majkimester hozzászólására (») Júl 19, 2021 /
 
Köszönöm, működik!
(#) Babakush hozzászólása Szept 20, 2021 /
 
Sziasztok!

Valaki próbálta már UART-nál Asynchronous Address Mode-t. Úgy olvastam, ha 9. bit be van állítva, akkor címet vár ellenőrzi is, hogy helyes-e a cím, ha pedig 0 a 9. bit akkor adatot vár. Viszont csak akkor fogadja az adatot, ha előtte a cím egyezett az előre beállított címmel. Én most egy raspberry-ről küldök neki adatot, de úgy veszem észre, bármi amit elküldök neki, azt ő beolvassa, akkor is ha rossz címmel küldöm ki. Esetleg van valakinek erre ötlete, mit ronthatok el? (PIC18F26K83, az rpi-nél meg a paritást bitet billentgetem,hogy éppen címet v adatot küldök.)
(#) superuser válasza Babakush hozzászólására (») Szept 20, 2021 /
 
Jó lenne kicsit konkrétabbá tenni a kérdést.
Csatolj egy ábrát (szkóp / logikai analizátor), hogy mit küldött a Pi és azt minek értelmezte a PIC (nyilván ez utóbbiról nem kell ábra, elég ha leírod).
(#) Babakush válasza superuser hozzászólására (») Szept 21, 2021 /
 
Egy számot(címet) és egy karakter sorozatot küldök a PI-ről és azt egy az egyben beolvasom UART-on és ki is küldöm UART-on, amit a PI beolvas és kiírja konzolon. A cím és minden karakter úgy ahogy van visszajön a PI-re, akkor is ha rossz címmel kezdem. Ugye ha rosszul értelmezne bármit is, akkor végképp nem kéne beolvasnia semmit.
A hozzászólás módosítva: Szept 21, 2021
(#) Babakush válasza Babakush hozzászólására (») Szept 21, 2021 /
 
Délutánra tudok csak csinálni szkóp képet. Viszont addig segítenél, az miben fog előre elvinni, mit kell majd keresnem rajta?
(#) Babakush hozzászólása Szept 21, 2021 /
 
Az első kép az cím byte (0x01) a második az adat (0x06) és 115200 a baudrate.
(#) superuser válasza Babakush hozzászólására (») Szept 21, 2021 /
 
Szerettem volna látni, hogy valóban megvan a 9 bit.
Szélesebb képen jobban lehetne látni, így eléggé találgatósba mondom, de én leginkább start bit + 8 adat bitet látok a képeken. Nem tudom mit gondolsz erről?
(Csak az ábra miatt):
http://esd.cs.ucr.edu/labs/serial/serial.html
(#) Babakush válasza superuser hozzászólására (») Szept 22, 2021 /
 
Szia!

Próbáltam szélesebb képeket csinálni és kijelölni mettől-meddig tarthat a jel. Elővettem egy másik PIC-et, ahol ugyanúgy beállítottam a 9bit-es módot és kiküldtem először egy address-t aztán egy data-t ezek láthatók a képeken, őszintén szólva, én először analizálok így UART jelet, de ahogy számoltam szerintem itt már meg van a 11bit(9+start+stop). Közben elég érdekes dolgot tapasztaltam, ha nem küldök ki cím byte-ot csak adatot, akkor a vevő PIC nem fogadja az adatokat, viszont ha kiküldtek bármilyen cím byte-ot mindegy, hogy egyezik-e a beállított vevő címmel, utána elkezdi fogadni a bejövő adat byte-okat. A datasheet erre vonatkozó részéről nekem az jön le, hogy a cím byte ellenőrzése hardware-esen történik, szóval most ötletem sincs, hogy mit lehetne ezzel kezdeni
(#) Babakush válasza Babakush hozzászólására (») Szept 22, 2021 /
 
Nah nem szóltam, világos a datasheet csak én vagyok sötét. A 2 PIC között sikeresen működik, rossz címnél eldobja az adatot. Már csak az RPI-ből kell értelmes jelet kicsikarnom és akkor működnie kéne azzal is. Köszönöm a segítségedet.
(#) cross51 válasza Babakush hozzászólására (») Szept 22, 2021 /
 
Nem ismerem az RPI-nek a soros port kezelését, de C#-ban "nem" tudsz 9 bites átvitelt csinálni a soros porton.
Pontosabban, tudsz csak a controller-ektől eltérően, C#-ban úgy lehet megoldani, hogy nem cím bit van hanem paritás bit, mikor címet küldesz mark (mindig '1') paritást kell állítani, mikor adatot akkor space-t (mindig '0').
Következő: »»   150 / 153
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