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

» Több friss téma
Fórum » PIC kezdőknek
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   1091 / 1210
(#) Hp41C válasza benjami hozzászólására (») Jún 5, 2019 /
 
Továbbá:
- Ha egy módosítható (Peripheral Pin Select) lábat kétirányú funkcióra (pl. I2C vonalnak) használunk fel, mind a kimeneti mind a bemeneti beállítást el kell végezni (a digitálissá állításon kívül).
Egy egész litániát írtunk, de csak ennyi maradt a sárga mezőben.
(#) lastewer válasza Tasznka hozzászólására (») Jún 5, 2019 /
 
Kijavítottam erre :

  1. if (pp < PUFF_SIZE)
  2.        { puffer[pp++]= UART1_Read(); // Get received byte
  3.     if (pp < 20){puffer[pp] = 0;}
  4.        }


Mellékeltem egy képet a kimenetről. Megduplázza a választ.

test.jpg		    
(#) lastewer válasza Hp41C hozzászólására (») Jún 5, 2019 /
 
Akkor az rx és tx lábat be és kimenetre kell állítanom ? Így?

  1. TRISB.F1 = 1; // RB1 RX
  2. TRISB.F2 = 0; // RB2 TX
A hozzászólás módosítva: Jún 5, 2019
(#) Hp41C válasza lastewer hozzászólására (») Jún 5, 2019 /
 
Típustól függ a beállítás. ld. Adatlap (E)USART fejezet.

18F252: TRISC7 = 1; TRISC6 = 0;
18F2550:TRISC7 = 1; TRISC6 = 1;
(#) lastewer válasza Hp41C hozzászólására (») Jún 5, 2019 /
 
Ez egy 16f628A , megnéztem az adatlapját, de én nem találom benne.

Adatlap

TX9: 9-bit Transmit Enable bit van , de hogy kimenet vagy bemenetre hogyan állítom , nem látom.

Jah , de :
Idézet:
„1.TRISB<1> and TRISB<2> should both be set to‘1’ to configure the RB1/RX/DT and RB2/TX/CKpins as inputs. Output drive, when required, iscontrolled by the peripheral circuitry”


Ezek szerint akkor a tx kimenet és rx bemenetre van állítva.
A hozzászólás módosítva: Jún 5, 2019

40044G.pdf		    
(#) lastewer válasza Hp41C hozzászólására (») Jún 5, 2019 /
 
Na most kinulláztam a tömb összes elemét :

  1. #define PUFF_SIZE 6  
  2.  
  3.  
  4.  if (UART1_Data_ready())
  5.         {
  6.            if (pp < PUFF_SIZE)
  7.            {
  8.              puffer[pp++]= UART1_Read(); // Get received byte
  9.              if (pp < 20)
  10.              {
  11.               puffer[pp] = 0;
  12.              }
  13.            }
  14.        
  15.               // Bekapcsolás
  16.               if(strstr(puffer, on_cm))
  17.               {
  18.                    UART1_Write(13);
  19.                    UART1_Write_text("Bekapcs.");
  20.                    UART1_Write(13);
  21.                    PORTB.F7 = 1;
  22.                    puffer[0] = 0;
  23.                    puffer[1] = 0;
  24.                    puffer[2] = 0;
  25.                    puffer[3] = 0;
  26.                    puffer[4] = 0;
  27.                    puffer[5] = 0;
  28.                    pp = 0;
  29.               }
  30.               //Kikapcsolás
  31.               if(strstr(puffer, off_cm))
  32.               {
  33.                  UART1_Write(13);
  34.                  UART1_Write_text("Kikapcs.");
  35.                  UART1_Write(13);
  36.                  PORTB.F7 = 0;
  37.  
  38.                    puffer[0] = 0;
  39.                    puffer[1] = 0;
  40.                    puffer[2] = 0;
  41.                    puffer[3] = 0;
  42.                    puffer[4] = 0;
  43.                    puffer[5] = 0;
  44.                  pp = 0;
  45.               }
  46.         }


De változatlan a helyzet.
A hozzászólás módosítva: Jún 5, 2019
(#) cross51 válasza NickE hozzászólására (») Jún 5, 2019 /
 
8 bitről váltáskor szerintem az esetek többségében mindenki így van.

A 16 és 32 bites PIC-ek doksijában sosincs részletekbe bele menő leírás a reference manual ban találsz mindig részletesebb leírást adott esetben example-t.

Viszont ha nézted az UART-os reference manual-t egy szó sincs erről benne, mivel ez nem az UART része hanem a PPS-é (IO).

Section 12. I/O Ports with Peripheral Pin Select (PPS) doksiban található egy ilyen szekciót:
Idézet:
„
When a remappable peripheral is active on a given I/O pin, it takes priority over all other digital
I/O and digital communication peripherals associated with the pin. Priority is given regardless of
the type of peripheral that is mapped.Remappable peripherals never take priority over any
analog functions associated with the pin.”


Érdemes (teljes,projet) example-t keresni rengeteg ilyen időhúzó dolgot elkerülhetsz.
A másik lehetőség MCC-vel vagy Harmony-val (32 bit) generáltatni egy kódot és megnézni az initet sokat segíthet.
A hozzászólás módosítva: Jún 5, 2019
(#) c27 hozzászólása Jún 5, 2019 /
 
Sziasztok!

Egy 18F4431-nél elakadtam ott, hogy 2 ADC csatornát akarok beolvasni, de sehogy se sikerül.
Beállítom a Multi-Channel Mode bit ACSCH 1-re. Minden más alapon. Az ADCON1 0-1 bitjét próbálom állítgatni, de sehogy se jövök rá, hogy lehet a 2 csatorna értékeit 2 külön változóba beírni.
Csak 1 csatorna olvasása működik, de multi channel már nem. Az Adatlapba se tudok elmenni, hogy mikor és hogy lehet kiolvasni. A BFEMT bitet kéne figyelni?

ADCON0bits.ADON = 1; //ADC ENEABLE
Delay10TCYx(3); //WAIT 3uSEC
ADCON0bits.GODONE = 1; //ADC START
while(ADCON0bits.GODONE); //WAITING FOR ADC FINISHED
ADCON0bits.ADON = 0;
ADCON1bits.ADPNT0=0;
ADCON1bits.ADPNT1=0;
ADC_ACT=ADRESH;
ADC_ACT<<=8;
ADC_ACT+=ADRESL;

Így mindig a 2. csatorna értékeit írja bele a változóba. Nem tudom, hogy lehetne lépkedni a kettő között.
(#) cross51 válasza Hp41C hozzászólására (») Jún 5, 2019 /
 
És az I2C-vel ezt nem is teheted meg mindig 8 biten PPS-el van felette még nem láttam olyat ami I2C-re PPS-el lenne maximum átváltható egy másik kijelölt alternatív lábra
A hozzászólás módosítva: Jún 5, 2019
(#) c27 válasza c27 hozzászólására (») Jún 5, 2019 /
 
Közbe megtaláltam a hibát a Buffer nem volt engedélyezve.
(#) lastewer válasza c27 hozzászólására (») Jún 5, 2019 /
 
Mázlista
(#) Hp41C válasza cross51 hozzászólására (») Jún 5, 2019 /
 
Kiragadtad a lényeget....
16 és 32 bites kontrollereken is be kell állítani ilyen esetben a lábat bemenetnek is és kimenetnek is.
Ezenkívül megjelent, kapható a 8 bites 18F2xK42, 18F4xK42, amiken az adatlap (DS40001869C-page 265) szerint a két I2C modul vonalai átkonfigurálható (remappable) lábakon vannak.
(#) rolandgw válasza lastewer hozzászólására (») Jún 5, 2019 /
 
Az strstr függvény visszatérési értéke egy char típusú mutató, nem a mutatott érték, vagy NULL pointer, ha nincs egyezőség. Ezt teszed if-be. Ring buffer-es feladat, ahogy már írták is.
(#) lastewer válasza rolandgw hozzászólására (») Jún 5, 2019 /
 
Nem értem miért kell ring buffer ehhez.

Én nem fogadok és küldök egyszerre. Küldök és várom az adatot , majd ha kaptam vissza választ küldök tovább, de egyszerre nem fogadok és küldök.

( Nem mondom hogy nem lenne szebb és gyorsabb és jobb, de nekem nincs meg még a tudásom hozzá, hogy azt megcsináljam.)

Csináltam egy ilyet :

  1. char puffer=0;
  2.    char i=0;
  3.  
  4.  
  5.        if (UART1_Data_Ready())
  6.         {
  7.             for(i = 0; i < 3; i++)
  8.             {
  9.              puffer[i] = UART1_Read(); // Így elméletileg lesz 0,1,2 helyem a tömbbben.
  10.             }
  11.                         // Bekapcsolás rész ------------------------
  12.               if(puffer[0] == 'o' && puffer[1] == 'n')
  13.               {
  14.                     UART1_Write(13);
  15.                     UART1_Write_text("Bekapcs.");
  16.                     UART1_Write(13);
  17.                     // Puffer ürítése
  18.                     puffer[0] = 0;
  19.                     puffer[1] = 0;
  20.               }
  21.                           // Kikapcsolás rész ------------------------
  22.               if(puffer[0] == 'o' && puffer[1] == 'f' && puffer[2] == 'f')
  23.               {
  24.                     UART1_Write(13);
  25.                     UART1_Write_text("Kikapcs.");
  26.                     UART1_Write(13);
  27.                     // Puffer ürítése
  28.                     puffer[0] = 0;
  29.                     puffer[1] = 0;
  30.                     puffer[2] = 0;
  31.               }
  32.         }


De nem fordul le. Beolvasom a kapott karaktereket szépen sorban , 0 ás , 1 es és 2 es helyre a puffer tömbbe.

Majd karakterenként vizsgálom , hogy a várt karakterek benne vannak e az adott 0 - 1- 2 helyen.

Ha benne vannak, akkor mehet a be és kikapcs szöveg vissza válaszként és ürítem ezeket a helyeket a következő on és off parancs számára.


Idézet:
„Pointer requed és Operator '' is not applicable to these operands ''”
hibákat kapok a fordításkor.

Mit rontok el?
A hozzászólás módosítva: Jún 5, 2019
(#) lóri hozzászólása Jún 5, 2019 /
 
Sziasztok!
A múltkori i2c-kérdésem tárgyát képező kódot csatolom.
Hátha találtok benne valami kivetnivalót.
Légyszi nézzétek meg.
Köszi:L.
  1. // PIC24EP512GU810 Configuration Bit Settings
  2.  
  3. // 'C' source line config statements
  4.  
  5. // FGS
  6. #pragma config GWRP = OFF               // General Segment Write-Protect bit (General Segment may be written)
  7. #pragma config GSS = OFF                // General Segment Code-Protect bit (General Segment Code protect is disabled)
  8. #pragma config GSSK = OFF               // General Segment Key bits (General Segment Write Protection and Code Protection is Disabled)
  9.  
  10. // FOSCSEL
  11. #pragma config FNOSC = PRIPLL           // Initial Oscillator Source ion bits (Primary Oscillator (XT, HS, EC) with PLL)
  12. #pragma config IESO = OFF               // Two-speed Oscillator Start-up Enable bit (Start up with user-ed oscillator source)
  13.  
  14. // FOSC
  15. #pragma config POSCMD = HS              // Primary Oscillator Mode  bits (HS Crystal Oscillator Mode)
  16. #pragma config OSCIOFNC = OFF           // OSC2 Pin Function bit (OSC2 is clock output)
  17. #pragma config IOL1WAY = ON            // Peripheral pin  configuration (ow multiple reconfigurations)
  18. #pragma config FCKSM = CSECME           // Clock Switching Mode bits (Both Clock switching and Fail-safe Clock Monitor are enabled)
  19.  
  20. // FWDT
  21. #pragma config WDTPOST = PS32768        // Watchdog Timer Postscaler bits (1:32,768)
  22. #pragma config WDTPRE = PR128           // Watchdog Timer Prescaler bit (1:128)
  23. #pragma config PLLKEN = ON              // PLL Lock Wait Enable bit (Clock switch to PLL source will wait until the PLL lock signal is valid.)
  24. #pragma config WINDIS = OFF             // Watchdog Timer Window Enable bit (Watchdog Timer in Non-Window mode)
  25. #pragma config FWDTEN = OFF             // Watchdog Timer Enable bit (Watchdog timer enabled/disabled by user software)
  26.  
  27. // FPOR
  28. #pragma config FPWRT = PWR128           // Power-on Reset Timer Value  bits (128ms)
  29. #pragma config BOREN = OFF              // Brown-out Reset (BOR) Detection Enable bit (BOR is disabled)
  30. #pragma config ALTI2C1 = OFF            // Alternate I2C pins for I2C1 (SDA1/SCK1 pins are ed as the I/O pins for I2C1)
  31. #pragma config ALTI2C2 = ON             // Alternate I2C pins for I2C2 (ASDA2/ASCK2 pins are ed as the I/O pins for I2C2)
  32.  
  33. // FICD
  34. #pragma config ICS = PGD2               // ICD Communication Channel  bits (Communicate on PGEC2 and PGED2)
  35. #pragma config RSTPRI = AF              // Reset Target Vector  bit (Device will obtain reset instruction  Primary flash)
  36. #pragma config JTAGEN = OFF             // JTAG Enable bit (JTAG is disabled)
  37.  
  38. // FAS
  39. #pragma config AWRP = OFF               // Auxiliary Segment Write-protect bit (Aux Flash may be written)
  40. #pragma config APL = OFF                // Auxiliary Segment Code-protect bit (Aux Flash Code protect is disabled)
  41. #pragma config APLK = OFF               // Auxiliary Segment Key bits (Aux Flash Write Protection and Code Protection is Disabled)
  42.  
  43. // #pragma config statements should precede project file includes.
  44. // Use project enums instead of #define for ON and OFF.
  45.  
  46. #include <xc.h>
  47. #include <string.h>
  48. #include <stdlib.h>
  49. #include <p24EP512GU810.h>
  50.  
  51.  
  52. #define i2c_idle()  while ((I2C2CONbits.I2CSIDL) | (I2C2STATbits.R_W))
  53. #define i2c_start() I2C2CONbits.SEN = 1; while(I2C2CONbits.SEN)
  54. #define i2c_rstart() I2C2CONbits.RSEN = 1; while(I2C2CONbits.RSEN)
  55. #define i2c_stop()  I2C2CONbits.PEN = 1; while(I2C2CONbits.PEN)
  56. #define i2c_ack(ackbit) I2C2CONbits.ACKDT = ackbit; I2C2CONbits.ACKEN = 1; while(I2C2CONbits.ACKEN)
  57.  
  58. #define FCY  40000000       // Instruction cycle frequency, Hz - required for __delayXXX() to work
  59. #include <libpic30.h>         // __delayXXX() functions macros defined here
  60.  
  61.  
  62. #define I2C_SDA   TRISAbits.TRISA3
  63. #define I2C_SCL   TRISAbits.TRISA2
  64. #define I2C_ACK     0   //pozitív nyugtázás
  65. #define I2C_NAK     1   //negatív nyugtázás
  66.  
  67.  
  68.  
  69. /*  Változótípusok és uniók definiálása ******************************/
  70. typedef unsigned char uint8; // 8 bites, el?jel nélküli szám
  71. typedef unsigned int uint16; //16 bites, el?jel nélküli szám
  72. typedef unsigned long uint32; //32 bites, el?jel nélküli szám
  73. typedef signed char int8; // 8 bites, el?jeles szám
  74. typedef signed int int16; //16 bites, el?jeles szám
  75. typedef signed long int32; //32 bites, el?jeles szám
  76.  
  77. typedef  _16 {
  78.     uint16 word;
  79.  
  80.     struct {
  81.         uint8 lo_byte;
  82.         uint8 hi_byte;
  83.     } ;
  84. } 16;
  85.  
  86. typedef  _32 {
  87.     uint32 dword;
  88.  
  89.     struct {
  90.         uint16 lo_word;
  91.         uint16 hi_word;
  92.     } ;
  93.     uint8 byte[4];
  94. } 32;
  95.  
  96.  
  97.  
  98.  
  99. 16 adat2;
  100. 32 adat4;
  101. unsigned char ee_buffer[64];
  102.  
  103.  
  104. void I2C_PRG( void );
  105. void IOSetup( void );
  106. void ee_read( void );
  107. void ee_read_sync( void );
  108. void ee_write( void );
  109. void Init( void );
  110.  
  111.  
  112. void i2c_init( void );
  113. uint8 i2c_getc( uint8 ack2send );
  114. uint8 i2c_putc( uint8 data );
  115. //void i2c_write1(uint8 addr,uint8 data);
  116. void i2c_write2( uint8 addr, uint8 d1, uint8 d2 );
  117. void i2c_writeN( uint8 addr, uint8* data, uint8 cnt );
  118. //void i2c_read1(uint8 addr,uint8* p1);
  119. void i2c_read2( uint8 addr, uint8* p1, uint8* p2 );
  120. void i2c_readN( uint8 addr, uint8* p1, uint8 cnt );
  121.  
  122.  
  123.  
  124. void i2c_init( void ) {
  125.     I2C_SCL = 1;
  126.     I2C_SDA = 1;
  127.     I2C2BRG = 99;
  128.     OSCTUN = 0;
  129.     I2C1ADD = 0;
  130.     I2C2MSK = 0;
  131.     I2C2CONbits.SMEN = 0;     /* SMBUS specifikus bemenet tiltása  */
  132.     I2C2CONbits.DISSLW = 0;    /* Slew rate vezérlés engedélyezve (400kHz mód) */
  133.     //  I2C2CONbits.I2CSIDL = 0;
  134.  
  135.  
  136.  
  137.     //  CLKDIVbits.DOZE = 0;
  138.     //  CLKDIVbits.PLLPOST = 0;
  139.     //  CLKDIVbits.PLLPRE = 0;
  140.     //  CLKDIVbits.FRCDIV = 0;
  141.  
  142.     // Configre SCA/SDA pin as open-drain. This may change  device to device.
  143.     //Refer the datasheet for more information.
  144.     //  ODCAbits.ODCA2 = 1;
  145.     //  ODCAbits.ODCA3 = 1;
  146.     I2C2CONbits.A10M = 0;
  147.     I2C1CONbits.SCLREL = 1;
  148.  
  149.     I2C2CONbits.I2CEN = 1;            // az MSSP egység engedélyezése
  150. }
  151.  
  152. uint8 i2c_getc( uint8 ack2send ) {
  153.     i2c_idle( );
  154.     I2C2CONbits.RCEN = 1;                 // a master engedélyezése egy bájt vételére
  155.     while ( !I2C2STATbits.RBF );            // megvárjuk, amíg a bájt beérkezik
  156.     i2c_ack( ack2send );                    // kiküldjük a nyugtázó bitet
  157.     return ( I2C2RCV );                    // visszatérünk a bájttal
  158. }
  159.  
  160. uint8 i2c_putc( uint8 data ) {
  161.     I2C2TRN = data;                        // kirakunk egy bájtot SSPBUF-ba
  162.     while ( I2C2STATbits.TBF );              // megvárjuk,amíg az íráslezajlik
  163.     i2c_idle( );                           // megvárjuk a busz aktivitás végét
  164.     return ( I2C2STATbits.ACKSTAT );       // a nyugtázó bittel térünk vissza
  165. }
  166.  
  167. void i2c_write2( uint8 addr, uint8 d1, uint8 d2 ) {
  168.     i2c_start( );
  169.     i2c_putc( addr & 0xFE );
  170.     i2c_putc( d1 );
  171.     i2c_putc( d2 );
  172.     i2c_stop( );
  173. }
  174.  
  175. void i2c_writeN( uint8 addr, uint8* data, uint8 cnt ) {
  176.     uint8 i;
  177.     i2c_start( );
  178.     i2c_putc( addr & 0xFE );
  179.     for ( i = 0; i < cnt; i++ ) {
  180.         i2c_putc( *data );
  181.         data++;
  182.     }
  183.     i2c_stop( );
  184. }
  185.  
  186. void i2c_read2( uint8 addr, uint8* p1, uint8* p2 ) {
  187.     i2c_start( );
  188.     i2c_putc( addr | 0x01 );
  189.     *p1 = i2c_getc( I2C_ACK );
  190.     *p2 = i2c_getc( I2C_NAK );
  191.     i2c_stop( );
  192. }
  193.  
  194. void i2c_readN( uint8 addr, uint8* p1, uint8 cnt ) {
  195.     uint8 i;
  196.     i2c_start( );
  197.     i2c_putc( addr | 0x01 );
  198.     for ( i = 0; i < cnt; i++ ) {
  199.         if ( i != cnt - 1 ) *p1 = i2c_getc( I2C_ACK );
  200.         else  *p1 = i2c_getc( I2C_NAK );
  201.         p1++;
  202.     }
  203.     i2c_stop( );
  204. }
  205.  
  206. void IOSetup( void ) {
  207.     ANSELA = 0; // Minden port digitalis
  208.     ANSELB = 0;
  209.     ANSELC = 0;
  210.     ANSELD = 0;
  211.     ANSELE = 0;
  212.     ANSELG = 0;
  213.  
  214.     TRISA = 0b0000000000001100;         // I2C bemenetekre állítva..
  215.     TRISB = 0b0000000011111111;
  216.     TRISC = 0b1111000000000000;
  217.     TRISD = 0b0000000000000001;
  218.     TRISE = 0b0000000000000000;
  219.     TRISF = 0b0000000000000000;
  220.     TRISG = 0b0000000000001100;
  221.  
  222.  
  223.     PORTA = 0; // 0b0100 0110 0000 0000
  224.     PORTB = 0;
  225.     PORTC = 0;
  226.     PORTD = 0;
  227.     PORTE = 0;
  228.     PORTF = 0;
  229.     PORTG = 0;
  230.    
  231.  
  232.     //    OSCCONbits.COSC = 0b011;    //011 = Primary Oscillator (XT, HS, EC) with PLL
  233.     //    OSCCONbits.NOSC = 0b011;    //011 = Primary Oscillator (XT, HS, EC) with PLL
  234.     CLKDIVbits.DOZE = 0;            //000 = FCY divided by 1  Processor Clock Reduction  bits
  235.     CLKDIVbits.DOZEN = 0;          //0 = Processor clock and peripheral clock ratio forced to 1:1
  236.     //    CLKDIVbits.FRCDIV = 0b111;          //000 = FRC divided by 1 (default)
  237.     CLKDIVbits.PLLPOST = 0;         //00 = Output divided by 2
  238.     PLLFBDbits.PLLDIV = 38; //M40
  239.     // Initiate Clock Switch to Primary Oscillator with PLL (NOSC=0b011)
  240.     __builtin_write_OSCCONH( 0x03 );
  241.     __builtin_write_OSCCONL( OSCCON | 0x01 );
  242.     // Wait for Clock switch to occur
  243.     while ( OSCCONbits.COSC != 0b011 );
  244.     // Wait for PLL to lock
  245.     while ( OSCCONbits.LOCK != 1 );
  246. }
  247.  
  248. void I2C_PRG( void ) {
  249.     //    unsigned char c;
  250.     //write
  251.     i2c_init( );
  252.     //   __delay_ms(5);
  253.     i2c_idle( );
  254.     i2c_start( );
  255.     i2c_putc( 0xA0 );   //címzés
  256.     i2c_putc( 0x00 );   // szkóppal vizsgálva csak az 0xA0 része hajtódik végre
  257.     i2c_putc( 0x00 );   // ha eléggé fel veszem az órajelet kb 1.2MHz re akkor belefér a címzés része is
  258.                                                 // Látszólag csak 35-45 us idő keret áll rendelkezésre az íráskor.
  259.                                                 //olyan mintha valami letiltaná a kimenetet.
  260.        
  261.     i2c_putc( 0x20 );   // itt már az adat írása lenne ha menne....
  262.     i2c_putc( 0x40 );
  263.     i2c_putc( 0x30 );
  264.     i2c_putc( 0x55 );
  265.     i2c_putc( 0x34 );
  266.     i2c_stop( );
  267.  
  268.  
  269.     __delay_ms( 5 );            //írási folyamat kivárása
  270.  
  271. }
  272.  
  273. void ee_read( void ) {
  274.     unsigned char i, u;
  275.     u = 64;
  276.  
  277.     i2c_idle( );
  278.     i2c_start( );
  279.     i2c_putc( 0xA0 );
  280.     i2c_putc( 0x00 );
  281.     i2c_putc( 0x00 );
  282.     i2c_start( );
  283.     i2c_putc( 0xA0 | 0x01 );            // eeprom-ból való olvasás egy 64 bájtos szegmens  ez a rész úgytünik, hogy müködik de csak nullákat olvas
  284.     for ( i = 0; i < u; i++ ) {         // mivel nem tudtam bele írni semmit
  285.         if ( i != (u - 1) ) {
  286.             ee_buffer[i] = i2c_getc( 0 );
  287.         } else  ee_buffer[i] = i2c_getc( 1 );
  288.     }
  289.     i2c_stop( );
  290. }
  291.  
  292. void ee_write( void ) {
  293.     unsigned char i, u;
  294.     u = 64;
  295.     //
  296.     //    i2c_idle( );
  297.     //    i2c_start( );
  298.     //    i2c_putc( 0xA0 );
  299.     //    i2c_putc( 0x00 );
  300.     //    i2c_putc( 0x00 );
  301.     //    for ( i = 0; i < u; i++ ) {
  302.     //        i2c_putc( ee_buffer[i] );
  303.     //    }
  304.     //    i2c_stop( );
  305.     //    __delay_ms(5);
  306. }
  307.  
  308.  
  309.  
  310.  
  311. int main( ) {
  312.  
  313.     IOSetup( );
  314.  
  315.         I2C_PRG();  // írnánk az epromba..
  316.        
  317.  
  318.  
  319.     // Fo Menu
  320.     while ( 1 ) {
  321.  
  322.  
  323.         PORTGbits.RG15 = (!PORTGbits.RG15);  // led villogtatás
  324.         __delay_ms( 50 );
  325.     }
  326. }
(#) lastewer hozzászólása Jún 5, 2019 /
 
Megpróbálom megcsinálni ring bufferben. Proteusban szimulálva tökéletes. Élesben viszont 1x 2x jön vissza válasz és utána rossz lesz.

Szerintetek?

  1. #define PUFF_SIZE 3  //20 volt
  2.  
  3.  
  4. // Változók beállítása
  5.    char puffer[PUFF_SIZE];
  6.    char tail = 0;
  7.    char head = 0;
  8.    char full = 0;
  9.  
  10. // Vezérlő parancsok beállítása
  11.    char off_cm[]      = "off";
  12.    char on_cm[]       = "one";
  13. void main()
  14. {
  15.   // uart init stb...
  16.  
  17.    TRISB.F1 = 1;      // RX bemenet
  18.    TRISB.F2 = 0;      // TX kimenet
  19.  
  20.  
  21.  
  22. while(1)
  23. {
  24.  
  25.  if (UART1_Data_ready())
  26.         {
  27.                        
  28.            if (full == 1)
  29.            {
  30.                   head = 0;
  31.                   full = 0;
  32.            }
  33.            else
  34.            {
  35.                puffer[head]= UART1_Read(); // Get received byte
  36.                 head = (head +1) % PUFF_SIZE;
  37.                 if(head == tail)
  38.                 {
  39.                   full = 1;
  40.                 }
  41.              }
  42.                        
  43.        
  44.               // Bekapcsolás
  45.               if(strstr(puffer, on_cm))
  46.               {
  47.                    UART1_Write(13);
  48.                    UART1_Write_text("Bekapcs.");
  49.                    UART1_Write(13);
  50.                    PORTB.F7 = 1;
  51.                      memset(puffer, 0, sizeof puffer);
  52.  
  53.               }
  54.               //Kikapcsolás
  55.               if(strstr(puffer, off_cm))
  56.               {
  57.                  UART1_Write(13);
  58.                  UART1_Write_text("Kikapcs.");
  59.                  UART1_Write(13);
  60.                  PORTB.F7 = 0;
  61.  
  62.                   memset(puffer, 0, sizeof puffer);
  63.  
  64.               }
  65.         }
  66.  
  67.  
  68. }
  69. }
A hozzászólás módosítva: Jún 5, 2019
(#) rolandgw válasza rolandgw hozzászólására (») Jún 5, 2019 /
 
Elnézést, már nem tudtam törölni, badarság az első mondat. Rosszul paramétereztem a printf-et a CodeBloks-ban.
(#) c27 hozzászólása Jún 6, 2019 /
 
Sziasztok!

Az meg lehet csinálni, hogy van egy változóm 0-127 között és ki szeretném íratni printf-el LCD-re mégpedig úgy, hogy az egyes helyi érték előtt legyen egy pont is? Az a változó lényegében pont a 10 szeresét tartalmazza a nekem kellő értéknek egy tizedespont pontossággal, csak az a fránya pontot kellene beszúrni valamilyen egyszerű módszerrel.
(#) Lamprologus válasza c27 hozzászólására (») Jún 6, 2019 /
 
Igen!

Milyen program nyelven?
A hozzászólás módosítva: Jún 6, 2019
(#) c27 válasza Lamprologus hozzászólására (») Jún 6, 2019 /
 
C, de a változóm unsigned char és a picet sem akarok terhelgetni, ha bonyolult.
(#) Lamprologus válasza c27 hozzászólására (») Jún 6, 2019 /
 
De melyik C?

Mert pl CCS-C-ben valahogy így nézne ki:

printf(lcd_putc,"TEMP: %3.1f ", temperature);


Kőbaltás megoldás: osztod tízzel, printf - eredmény, pont, maradék
(#) Tasznka válasza lóri hozzászólására (») Jún 6, 2019 /
 
Ajjaj
Eléggé furin vannak az elnevezések.Ha az I2C2-t használod,akkor mindnek legyen az a nevében,mert így könnyen belemész abba,hogy a másik I2C-nek írsz be valamit .Pl: 129. ,147. sor.
Ja,és csak while-ket annyira nem jó használni,mert megakadhat a progi,dobj mellé timert,WD-t.
A hozzászólás módosítva: Jún 6, 2019
(#) c27 válasza Lamprologus hozzászólására (») Jún 6, 2019 /
 
C18 fordító.

A változóm unsigned char típus esetleg lehet unsigned int, de jobb lenne ha 8 bitnél nem lenne nagyobb.
Nem tudom a fordító hogy kezelné le. Osztom tízzel unsigned charból nem lesz maradék.
(#) Lamprologus válasza c27 hozzászólására (») Jún 6, 2019 /
 
C18-at nem ismerem ... nincs maradékos osztás művelete?
Esetleg osztod 10-el, majd az eredményt szorzod tízzel és a kivonod az eredeti értékből!
(#) Tasznka válasza lastewer hozzászólására (») Jún 6, 2019 /
 
Így mindig ki fog maradni 1 válasz. Talán ez segít
  1. if (UART1_Data_ready())
  2. {
  3.    if (!full)
  4.            {
  5.            puffer[head]= UART1_Read(); // Get received byte
  6.            head = (head +1) % PUFF_SIZE;
  7.            if(head == tail)
  8.                 {
  9.                   full = 1;
  10.                 }
  11.              }
  12.    if (full)
  13.            {
  14.                head = 0;
  15.                full = 0;
  16.            }
  17.                        
  18.        
  19.               // Bekapcsolás
  20.               if(strstr(puffer, on_cm))
  21.               {
  22.                    UART1_Write(13);
  23.                    UART1_Write_text("Bekapcs.");
  24.                    UART1_Write(13);
  25.                    PORTB.F7 = 1;
  26.                      memset(puffer, 0, sizeof puffer);
  27.  
  28.               }
  29.               //Kikapcsolás
  30.               if(strstr(puffer, off_cm))
  31.               {
  32.                  UART1_Write(13);
  33.                  UART1_Write_text("Kikapcs.");
  34.                  UART1_Write(13);
  35.                  PORTB.F7 = 0;
  36.  
  37.                   memset(puffer, 0, sizeof puffer);
  38.  
  39.               }
  40. }
(#) c27 válasza kissi hozzászólására (») Jún 6, 2019 /
 
Ehhez szét kéne bontanom a számot tehát 0-127 között van egy unsigned char típusú változóm.
Én azt szeretném, hogy így nézzen ki: 0.0-12.7.
A szétbontáson gondolkodok melyik a jobb a picnek ha elosztom 10-el és kivonom az eredetiből megkapva a maradékot, pár sor talán nem olyan vészes, vagy floatként kezdem kezelni, típuskényszerítéssel nem tudom működik e és ha igen akkor a fordító mire fordítja.
Megpróbálom megnézni mindkét megoldást, bár az első lehet gyorsabb és egyszerűbb.
(#) kissi válasza c27 hozzászólására (») Jún 6, 2019 /
 
Szia!

Karakterenként írd ki!

Szazas = valtozo/100;
Tizes = (valtozo - 100*Szazas)/10;
Egyes = valtozo%10;

Ezeket egyesével kiírva, megfelelő helyen közéjük a pont ( ASCII kódhoz kell hozzá még 0x30!)!

De kiírathatod a százast és a tízest egyszerre:
SzT= valtozo/10; <-- ezt Printf-el !
A többi ugyanúgy!
A hozzászólás módosítva: Jún 6, 2019
(#) lastewer válasza Tasznka hozzászólására (») Jún 6, 2019 /
 
Köszi , az a helyzet, hogy így pedig minden 3. küldött adatra válaszol csak. Ez mitől lehet?

Mellékeltem egy képet.

megj. A váltózók így vannak beállítva :

  1. // Órajel beállítása (Kvarc)
  2. #define _XTAL_FREQ 16000000
  3. #define PUFF_SIZE 3  
  4.  
  5.  
  6. // Változók beállítása
  7.    unsigned int cnt;
  8.    char puffer[PUFF_SIZE];
  9.    char tail = 0;
  10.    char head = 0;
  11.    char full = 0;
  12.    
  13. // Vezérlő parancsok beállítása
  14.    char off_cm[]      = "off";
  15.    char on_cm[]       = "one";
  16.    char dev_id[]      = "ID: sh";
A hozzászólás módosítva: Jún 6, 2019

t3.jpg		    
(#) kissi válasza c27 hozzászólására (») Jún 6, 2019 /
 
Közben töröltem, mert rosszul értelmeztem, amit írtál !
(#) lóri válasza Tasznka hozzászólására (») Jún 6, 2019 /
 
Köszönöm, hogy ránéztél. Elvileg csak az egyik i2c-t használjuk.
Következő: »»   1091 / 1210
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