Pause in UART Transmitted Values

Discussion in 'Embedded Systems and Microcontrollers' started by Harnee15, Apr 16, 2016.

  1. Harnee15

    Thread Starter New Member

    Sep 14, 2015
    24
    0
    Hi,
    I am working with dspic33fj128mc804. UART used to send values from the PCB to the computer., transmits all the values but there is a tiny pause between the readings. I am sampling data at 8KHz . As the data is time critical I dont want to loose any values.
    Could anyone please suggest something for this problem?

    Many Thanks!!
     
  2. dannyf

    Well-Known Member

    Sep 13, 2015
    1,811
    362
    Post your code and we will help you.
     
  3. Harnee15

    Thread Starter New Member

    Sep 14, 2015
    24
    0
    Thank you very much! Below is my code.

    Code (C):
    1.  
    2. #define FIFO_SIZE 656
    3. #define FIFO_MASK (FIFO_SIZE-1)
    4. #define  MAX_CHNUM                7        // Highest Analog input number in Channel Scan
    5. #define  SAMP_BUFF_SIZE            8        // Size of the input buffer per analog input
    6. #define  NUM_CHS2SCAN            8        // Number of channels enabled for channel scan
    7.  
    8.  
    9. unsigned int BufferA[8]__attribute__((space(dma)));
    10. unsigned int BufferB[8]__attribute__((space(dma)));
    11.  
    12. /*=======================================================================
    13. Used to set operating speed and default port directions along with setting
    14. remappable peripherals
    15. ========================================================================= */
    16.  
    17. void setupPIC(void)
    18.     {
    19.         AD1PCFGL = 0xff00;
    20.         CLKDIV=0;                    //reset DOZE
    21.         //Setup for 7.37MIPS operation (internal FRC is 7.37MHz). To get mips, we need to x2 the OSC frequency
    22.         PLLFBD=30;                    //32*(7.37/2)=117.92MHz
    23.         CLKDIVbits.PLLPOST = 3;        //M=16, N1=2, N2=8
    24.         CLKDIVbits.PLLPRE=0;        //Fosc = 7.37M*32/(2*8)=14.74MHz
    25.         OSCTUN = 0;
    26.         RCONbits.SWDTEN = 0;        //Disable watchdog timer
    27.         __builtin_write_OSCCONH(0x01);        //Initiate Clock Switch
    28.         __builtin_write_OSCCONL(0x01);        //Start Clock Switch
    29.         while(OSCCONbits.COSC != 0b001);    //Wait for clock switching
    30.         while (OSCCONbits.LOCK != 1);        //Wait for PLL to lock
    31.         //Port mappings
    32.         __builtin_write_OSCCONL(OSCCON & ~(1<<6));
    33.         //inputs
    34.         RPINR18bits.U1RXR = 20;    //txdto Pin RP19
    35.         //outputs
    36.         RPOR9bits.RP19R = 3;   // TXD of pic to RXD of UART(RP19)
    37.         RPOR4bits.RP9R = 0x8;   //SCK to Pin RP9
    38.         RPOR11bits.RP22R= 0x7; // SDO to Pin R22
    39.         __builtin_write_OSCCONL(OSCCON | (1<<6));
    40.         //Setup port directions
    41.         LATA = 0x0000; TRISA = 0x0003;
    42.         LATB = 0x2860; TRISB = 0x006f;
    43.         LATC = 0x0100; TRISC = 0x0013;
    44.         // Writing 0 means line On is pulled to ground
    45.         B1L1=0; B1L2=0;
    46.         B2L1=0; B2L2=0;
    47.         B3L1=0; B3L2=0;
    48.         B4L1=0; B4L2=0;
    49.         //initializing resistance values
    50.         res1=0x000;
    51.         res2=0x000;
    52.         res3=0x000;
    53.         res4=0x000;
    54.           // For random number generation
    55.         max= 30;
    56.         min= 10;
    57.         range= max-min+1;
    58.         // Set up Timer for Temperature Sensor. Prescaler 1:256; PR4 Preload = 57580; 2 sec
    59.           PR4    = 57580;
    60.         T4CON    = 0x8030;
    61.         TMR4 = PR4>>1;
    62.         _T4IE    = 0;
    63.         _T4IF    = 0;
    64.         // Set up Timer for schedule. Prescaler 1:256; PR3 Preload = 28790 for 1 sec;
    65.         TMR2 = 0x0000;
    66.         PR2    = 4999;
    67.         T2CON    = 0x8000;
    68.         _T2IE    = 0;
    69.         _T2IF    = 0;
    70.  
    71.         //Timer 3 for ADC trigger
    72.         TMR3 = 0x0000;
    73.         T3CON    = 0x8000;
    74.         PR3 = 4999; // Trigger ADC1 every  for 800Hz
    75.         IFS0bits.T3IF = 0; // Clear Timer 3 interrupt
    76.         IEC0bits.T3IE = 0; // Disable Timer 3 interrupt
    77.         T3CONbits.TON = 1; //Start Timer 3
    78.  
    79.     }
    80.  
    81. /*=======================================================================
    82. Initialize ADC
    83. ========================================================================= */
    84.  
    85. void initadc(void)
    86. {
    87.  
    88.     AD1CON1bits.FORM = 0;        // Data Output Format: Integer
    89.     AD1CON1bits.SSRC = 2;    //  GP Timer3 starts conversion
    90.     AD1CON1bits.ASAM = 1;        // ADC Sample Control: Sampling begins immediately after conversion
    91.     AD1CON1bits.AD12B = 1;        // SHEN : 12-bit ADC operation
    92.     AD1CON2bits.CSCNA = 1;        // Scan Input Selections for CH0+ during Sample A bit
    93.     AD1CON2bits.CHPS  = 0;        // Converts CH0
    94.     AD1CON3bits.ADRC = 0;        // ADC Clock is derived from Systems Clock
    95.     AD1CON3bits.ADCS = 65;        // ADC Conversion Clock Tad=Tcy*(ADCS+1)= (1/7.37M)*64 = 1.6us (625Khz).
    96.     AD1CON1bits.ADDMABM = 1;     // 1= Conversion order mode and 0 is DMA buffers are built in scatter/gather mode
    97.     AD1CON2bits.SMPI    = (NUM_CHS2SCAN-1);    // 8 ADC Channels are scanned
    98.     AD1CON4bits.DMABL   = 0;    //shen : Each buffer contains 1 word
    99.     AD1CSSLbits.CSS0=1;        
    100.     AD1CSSLbits.CSS1=1;        
    101.     AD1CSSLbits.CSS2=1;        
    102.     AD1CSSLbits.CSS3=1;        
    103.     AD1CSSLbits.CSS4=1;
    104.     AD1CSSLbits.CSS5=1;
    105.     AD1CSSLbits.CSS6=1;
    106.     AD1CSSLbits.CSS7=1;
    107.     AD1CHS0=0;
    108.     IFS0bits.AD1IF   = 0;        // Clear the A/D interrupt flag bit
    109.     IEC0bits.AD1IE   = 0;        // Do Not Enable A/D interrupt
    110.     AD1CON1bits.ADON = 1;        // Turn on the A/D converter
    111. }
    112.  
    113. /*=======================================================================
    114. Initialize DMA
    115. ========================================================================= */
    116.  
    117. void initDma0(void)
    118. {
    119.     DMA0CONbits.AMODE = 0;            // Configure DMA for Register Indirect Mode
    120.     DMA0CONbits.MODE  = 0;            // Configure DMA for Continuous Ping-Pong mode disabled
    121.     DMA0PAD=0x0300 ;                //shen : Point DMA to ADC1BUF0
    122.     DMA0CNT = (SAMP_BUFF_SIZE*NUM_CHS2SCAN)-1;
    123.     DMA0REQ = 13;                    // Select ADC1 as DMA Request source
    124.     DMA0STA = __builtin_dmaoffset(&BufferA);
    125.     DMA0STA = __builtin_dmaoffset(&BufferB);
    126.     IFS0bits.DMA0IF = 0;            //Clear the DMA interrupt flag bit
    127.     IEC0bits.DMA0IE = 1;            //Set the DMA interrupt enable bit
    128.  
    129.     DMA0CONbits.CHEN=1;                // Enable DMA
    130.  
    131. }
    132.  
    133. unsigned int DmaBuffer = 0;
    134.  
    135. /*=============================================================================
    136. _DMA0Interrupt()
    137. =============================================================================*/
    138.  
    139. void __attribute__((interrupt, no_auto_psv)) _DMA0Interrupt(void)
    140. {
    141.     if(DmaBuffer == 0)
    142.     {
    143.      
    144. ProcessADCSamples(BufferA[0]);
    145.         ProcessADCSamples(BufferA[1]);
    146.         ProcessADCSamples(BufferA[2]);
    147.         ProcessADCSamples(BufferA[3]);
    148.         ProcessADCSamples(BufferA[4]);
    149.         ProcessADCSamples(BufferA[5]);
    150.         ProcessADCSamples(BufferA[6]);
    151.         ProcessADCSamples(BufferA[7]);
    152.     }
    153.     else
    154. {
    155.         ProcessADCSamples(BufferB[0]);
    156.         ProcessADCSamples(BufferB[1]);
    157.         ProcessADCSamples(BufferB[2]);
    158.         ProcessADCSamples(BufferB[3]);
    159.         ProcessADCSamples(BufferB[4]);
    160.         ProcessADCSamples(BufferB[5]);
    161.         ProcessADCSamples(BufferB[6]);
    162.         ProcessADCSamples(BufferB[7]);
    163.  
    164.  
    165. }
    166.  
    167.     DmaBuffer ^= 1;
    168.     IFS0bits.DMA0IF = 0;        // Clear the DMA0 Interrupt Flag
    169. }
    170.  
    171. void ProcessADCSamples(unsigned int AdcBuffer)
    172. {
    173.     //check=1;
    174.     adResults[adChannelCounter]= AdcBuffer;
    175.     adChannelCounter++;
    176. //    adChannelCounter&=0x7;                     //Allows 0-7
    177.     AD1CHS0=adChannelMap[adChannelCounter];    //set the channel
    178.     if (adChannelCounter==7)        //rolled over, to have 8 samples
    179.     {
    180.     shouldWriteResults = 1;        //set flag.
    181. adChannelCounter=0;
    182. }
    183. //check=1;
    184. }
    185.  
    186. /*=======================================================================
    187. Turns a numeric 0-F to ASCII 0-9 and A-F
    188. ========================================================================= */
    189.  
    190. unsigned int nibbleToHex(int v)
    191.     {
    192.         v&=0xf;
    193.         if (v>9) return (v+'A'-10); else return v+'0';
    194.     }
    195.  
    196. /*=======================================================================
    197. Convert ascii hex 0-F to int 0-F. Returns -1 if conversion not possible
    198. ========================================================================= */
    199.  
    200. int hexToNibble(char v)
    201.     {
    202.         if (v>47 && v<58)  return (v-48); else
    203.         if (v>64 && v<71)  return (v-55); else
    204.         if (v>96 && v<103) return (v-87); else return -1;
    205.     }
    206.  
    207.  
    208. /*=======================================================================
    209. UART Set UP
    210. ========================================================================= */
    211.  
    212. void initUART()
    213.     {
    214.         txFIFOtail = txFIFOhead = 0;
    215.  
    216.     U1MODE=0;
    217. //    U1MODEbits.BRGH = 1;
    218.     U1BRG=3;            //Baud Rate 1574400
    219.     U1MODE = 0x8800;    //EN, no flow control, no BRGH
    220.     U1STA = 0x0400;        //only TXEN
    221.     }
    222.  
    223. /*=======================================================================
    224. Process UART FIFOs
    225. ========================================================================= */
    226.  
    227. void processUART()
    228.     {
    229.         char dummy=0;
    230.         U1STA&=0xFFFD; //lear the OERR bit
    231.         if (_U1RXIF)
    232.             {
    233.                 dummy = U1RXREG;
    234.                 _U1RXIF = 0;
    235.         //echo back //uartWriteByte(dummy);
    236.                 if (dummy!=0x0d) //% 0xd 0xa  is the ending of the line
    237.                     {
    238.                         if (uartCMDpos<16)
    239.                             {
    240.                                 uartCMD[uartCMDpos++]=dummy;
    241.                             } else
    242.                                 processUARTcmd();
    243.                     } else
    244.                         {
    245.                             processUARTcmd();
    246.                         }
    247.           }
    248.  
    249.      if (!U1STAbits.UTXBF)
    250.           {
    251.                 if (txFIFOtail != txFIFOhead)
    252.                     {
    253.                         U1TXREG = txFIFO[txFIFOtail];
    254.                         txFIFOtail = (txFIFOtail + 1) & FIFO_MASK;
    255.                     }
    256.             }
    257.     }
    258.  
    259.  
    260.  
    261. unsigned int portValues[5];
    262.  
    263. void processUARTcmd()
    264.     {
    265.         int i, dummy, wasError;
    266.         //    unsigned int newOutput;
    267.         if (uartCMDpos==5)
    268.             {
    269.                 //    uartWriteString("!OK - applying values\r\n");
    270.                 wasError=0;
    271.                 //take each letter from uartCMDpos, must be 0-9, A-F. if okay, apply to relevant output. if not okay, break out and say so
    272.                 for (i=0; i<5; i++)
    273.                     {
    274.                         dummy = hexToNibble(uartCMD[I]);
    275.                         if (dummy!=-1) portValues[I]=dummy; else { wasError=i+1; break; }
    276.                     }
    277.                 if (wasError)
    278.                     {
    279.                         uartWriteString("!ERROR - expected 5 HEX values\r\n");
    280.                     }
    281.                 else
    282.                     {
    283.                         LATB&=0x0FFF; LATB|=(portValues[4]<<12);
    284.                     }
    285.             } else uartWriteString("!ERROR - must be 5 letters followed by \\r\\n\r\n");
    286.  
    287.     uartCMDpos=0;
    288.     uartCMD[0]='\0';
    289.     }
    290. /*=======================================================================
    291. Writing to UART
    292. ========================================================================= */
    293.  
    294.  
    295. /*=======================================================================
    296. Sending a Byte
    297. ========================================================================= */
    298. void uartWriteByte(unsigned int v)
    299.     {
    300.         txFIFO[txFIFOhead] = v & 0xFF;
    301.         txFIFOhead = (txFIFOhead+1) & FIFO_MASK;
    302.     }
    303.  
    304. /*=======================================================================
    305. Send an Int, LSB first
    306. ========================================================================= */
    307.  
    308. void uartWriteInt(unsigned int v)
    309.     {
    310.         uartWriteByte(nibbleToHex(v>>4));
    311.         uartWriteByte(nibbleToHex(v));
    312.         uartWriteByte(nibbleToHex(v>>12));
    313.         uartWriteByte(nibbleToHex(v>>8));
    314.     }
    315.  
    316. /*=======================================================================
    317. Send a word, LSB first
    318. ========================================================================= */
    319.  
    320. void uartWriteShort(unsigned char v)
    321.     {
    322.         uartWriteByte(nibbleToHex(v>>4));
    323.         uartWriteByte(nibbleToHex(v));
    324.     }
    325.  
    326. /*=======================================================================
    327. Send a Decimal, LSB first
    328. ========================================================================= */
    329. void uartWriteDecimal(unsigned int v)
    330.     {
    331.         unsigned int a=v/10000; char lead=0;
    332.         if (a)       { uartWriteByte('0'+a); lead=1;  v-=a*10000; }
    333.         a=v/1000;
    334.         if (a||lead) { uartWriteByte('0'+a); lead=1;  v-=a*1000; }
    335.         a=v/100;
    336.         if (a||lead) { uartWriteByte('0'+a); lead=1;  v-=a*100; }
    337.         a=v/10;
    338.         if (a||lead) { uartWriteByte('0'+a); lead=1;  v-=a*10; }
    339.         uartWriteByte('0'+v);
    340.     }
    341. /*=======================================================================
    342. Write New Line 0x0d 0x0a values
    343. ========================================================================= */
    344.  
    345. void uartWriteNL(void)
    346.     {
    347.         //uartWriteByte(0x0d);
    348.         uartWriteByte(0x0a);
    349.     }
    350. /*=======================================================================
    351. Writes a string into the txFIFO_USB
    352. ========================================================================= */
    353.  
    354. void uartWriteString(const char* v)
    355.     {
    356.         while (*v) uartWriteByte(*v++);
    357.     }
    358.  
    359.  
    360.  
    361. /*=======================================================================
    362. Initialize DAC
    363. ========================================================================= */
    364.  
    365. void initDACs(void)
    366.     {
    367.         TRISB&=~0x4010;
    368.         DAC1CS=DAC2CS=1;
    369.         _SPI1IF = 0; // Clear the interrupt flag
    370.         _SPI1IE = 0; // Disable the interrupt
    371.         //Initialize SPI
    372.         SPI1CON1=0x073e; //16bit, master, prescale 4, CKP0 CKE1 SMP 1
    373.         SPI1STAT=0x8000; //enable SPI
    374.         DAC1CS=0;DAC2CS=0;
    375.         SPI1BUF = 0x3000;    //Set output of A to 0V
    376.         while(!_SPI1IF); //wait until SPI has finished
    377.         _SPI1IF = 0;
    378.         DAC1CS=DAC2CS=1;
    379.         SPI1STAT &=~0x40;
    380.         DAC1CS=0;
    381.         DAC2CS=0;
    382.         SPI1BUF = 0xb000; // Set output of B to 0V
    383.         while(!_SPI1IF); //wait until SPI has finished..****
    384.         _SPI1IF = 0;
    385.         DAC1CS=DAC2CS=1;
    386.         SPI1STAT &=~0x40;
    387.   }
    388.  
    389. /*=======================================================================
    390. Function to set values on the DAC
    391. ========================================================================= */
    392.  
    393. void channelSetDACtwo(int v, int ch)
    394.     {
    395.         unsigned int sendData;
    396.         if(ch>3) return;//wrong values
    397.         if(ch &1)
    398.             {
    399.                 sendData= 0x3000 | (v & 0xfff);
    400.             }
    401.         else
    402.             {
    403.                 sendData= 0xb000 | (v & 0xfff);
    404.             }
    405.  
    406.         if (ch <2) DAC1CS=0; else DAC2CS=0;
    407.         SPI1BUF=sendData;
    408.         while(!_SPI1IF); //wait until SPI has finished
    409.         _SPI1IF = 0;
    410.         DAC1CS=DAC2CS=1;
    411.         SPI1STAT &=~0x40;//same like in init.... ****
    412.         spiReady=1;
    413.     }
    414.  
    Moderators note: Please use code tags for pieces of code
     
    Last edited by a moderator: Apr 16, 2016
  4. Harnee15

    Thread Starter New Member

    Sep 14, 2015
    24
    0
    Is it possible that this is because of inappropriate FIFO size? If yes, how to determine appropriate FIFO size?
     
  5. dannyf

    Well-Known Member

    Sep 13, 2015
    1,811
    362
    where do you think the tiny pause take place? how tiny is tiny?
     
Loading...