Microchip%20TCP_IP%20stack/TCPIP%20Stack/UART.c

/*********************************************************************
 *
 *     UART access routines for C18 and C30
 *
 *********************************************************************
 * FileName:        UART.c
 * Dependencies:    UART.h
 * Processor:       PIC18, PIC24F/H, dsPIC30F, dsPIC33F
 * Complier:        Microchip C18 v3.03 or higher
 * Complier:        Microchip C30 v2.01 or higher
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * Copyright © 2002-2007 Microchip Technology Inc.  All rights 
 * reserved.
 *
 * Microchip licenses to you the right to use, modify, copy, and 
 * distribute: 
 * (i)  the Software when embedded on a Microchip microcontroller or 
 *      digital signal controller product (“Device”) which is 
 *      integrated into Licensee’s product; or
 * (ii) ONLY the Software driver source files ENC28J60.c and 
 *      ENC28J60.h ported to a non-Microchip device used in 
 *      conjunction with a Microchip ethernet controller for the 
 *      sole purpose of interfacing with the ethernet controller. 
 *
 * You should refer to the license agreement accompanying this 
 * Software for additional information regarding your rights and 
 * obligations.
 *
 * THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT 
 * WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT 
 * LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A 
 * PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL 
 * MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR 
 * CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF 
 * PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS 
 * BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE 
 * THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER 
 * SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT 
 * (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
 *
 *
 * Author               Date            Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Howard Schlunder             4/04/06         Copied from dsPIC30 libraries
 * Howard Schlunder             6/16/06         Added PIC18
********************************************************************/
#define __UART_C

#include "TCPIP Stack/TCPIP.h"

#if defined(STACK_USE_UART)

BYTE ReadStringUART(BYTE *Dest, BYTE BufferLen)
{
        BYTE c;
        BYTE count = 0;

        while(BufferLen--)
        {
                *Dest = '\0';

                while(!DataRdyUART());
                c = ReadUART();

                if(c == '\r' || c == '\n')
                        break;

                count++;
                *Dest++ = c;
        }

        return count;
}


#if defined(__dsPIC33F__) || defined(__dsPIC30F__) || defined(__PIC24H__) || defined(__PIC24F__)


/***************************************************************************
* Function Name     : putsUART2                                            *
* Description       : This function puts the data string to be transmitted *
*                     into the transmit buffer (till NULL character)       * 
* Parameters        : unsigned int * address of the string buffer to be    *
*                     transmitted                                          *
* Return Value      : None                                                 *  
***************************************************************************/

void putsUART2(unsigned int *buffer)
{
    char * temp_ptr = (char *) buffer;

    /* transmit till NULL character is encountered */

    if(U2MODEbits.PDSEL == 3)        /* check if TX is 8bits or 9bits */
    {
        while(*buffer != '\0') 
        {
            while(U2STAbits.UTXBF); /* wait if the buffer is full */
            U2TXREG = *buffer++;    /* transfer data word to TX reg */
        }
    }
    else
    {
        while(*temp_ptr != '\0')
        {
            while(U2STAbits.UTXBF);  /* wait if the buffer is full */
            U2TXREG = *temp_ptr++;   /* transfer data byte to TX reg */
        }
    }
}


/******************************************************************************
* Function Name     : getsUART2                                               *
* Description       : This function gets a string of data of specified length * 
*                     if available in the UxRXREG buffer into the buffer      *
*                     specified.                                              *
* Parameters        : unsigned int length the length expected                 *
*                     unsigned int *buffer  the received data to be           * 
*                                  recorded to this array                     *
*                     unsigned int uart_data_wait timeout value               *
* Return Value      : unsigned int number of data bytes yet to be received    * 
******************************************************************************/

unsigned int getsUART2(unsigned int length,unsigned int *buffer,
                       unsigned int uart_data_wait)

{
    unsigned int wait = 0;
    char *temp_ptr = (char *) buffer;

    while(length)                         /* read till length is 0 */
    {
        while(!DataRdyUART2())
        {
            if(wait < uart_data_wait)
                wait++ ;                  /*wait for more data */
            else
                return(length);           /*Time out- Return words/bytes to be read */
        }
        wait=0;
        if(U2MODEbits.PDSEL == 3)         /* check if TX/RX is 8bits or 9bits */
            *buffer++ = U2RXREG;          /* data word from HW buffer to SW buffer */
                else
            *temp_ptr++ = U2RXREG & 0xFF; /* data byte from HW buffer to SW buffer */

        length--;
    }

    return(length);                       /* number of data yet to be received i.e.,0 */
}


/*********************************************************************
* Function Name     : DataRdyUart2                                   *
* Description       : This function checks whether there is any data *
*                     that can be read from the input buffer, by     *
*                     checking URXDA bit                             *
* Parameters        : None                                           *
* Return Value      : char if any data available in buffer           *
*********************************************************************/

char DataRdyUART2(void)
{
    return(U2STAbits.URXDA);
}


/*************************************************************************
* Function Name     : BusyUART2                                          *
* Description       : This returns status whether the transmission       *  
*                     is in progress or not, by checking Status bit TRMT *
* Parameters        : None                                               *
* Return Value      : char info whether transmission is in progress      *
*************************************************************************/

char BusyUART2(void)
{  
    return(!U2STAbits.TRMT);
}


/***************************************************************************
* Function Name     : ReadUART2                                            *
* Description       : This function returns the contents of UxRXREG buffer *
* Parameters        : None                                                 *  
* Return Value      : unsigned int value from UxRXREG receive buffer       * 
***************************************************************************/

unsigned int ReadUART2(void)
{
    if(U2MODEbits.PDSEL == 3)
        return (U2RXREG);
    else
        return (U2RXREG & 0xFF);
}


/*********************************************************************
* Function Name     : WriteUART2                                     *
* Description       : This function writes data into the UxTXREG,    *
* Parameters        : unsigned int data the data to be written       *
* Return Value      : None                                           *
*********************************************************************/

void WriteUART2(unsigned int data)
{
    if(U2MODEbits.PDSEL == 3)
        U2TXREG = data;
    else
        U2TXREG = data & 0xFF;  
}


#elif defined(__18CXX)
//
// PIC18
//


char BusyUSART(void)
{
        return !TXSTAbits.TRMT;
}

void CloseUSART(void)
{
  RCSTA &= 0x4F;  // Disable the receiver
  TXSTAbits.TXEN = 0;   // and transmitter

  PIE1 &= 0xCF;   // Disable both interrupts
}

char DataRdyUSART(void)
{
        if(RCSTAbits.OERR)
        {
                RCSTAbits.CREN = 0;
                RCSTAbits.CREN = 1;
        }
  return PIR1bits.RCIF;
}

char ReadUSART(void)
{
  return RCREG;                     // Return the received data
}

void WriteUSART(char data)
{
  TXREG = data;      // Write the data byte to the USART
}

void getsUSART(char *buffer, unsigned char len)
{
  char i;    // Length counter
  unsigned char data;

  for(i=0;i<len;i++)  // Only retrieve len characters
  {
    while(!DataRdyUSART());// Wait for data to be received

    data = getcUART();    // Get a character from the USART
                           // and save in the string
    *buffer = data;
    buffer++;              // Increment the string pointer
  }
}

void putsUSART( char *data)
{
  do
  {  // Transmit a byte
    while(BusyUSART());
    putcUART(*data);
  } while( *data++ );
}

void putrsUSART(const rom char *data)
{
  do
  {  // Transmit a byte
    while(BusyUSART());
    putcUART(*data);
  } while( *data++ );
}

#endif


#endif  //STACK_USE_UART
1	hedin	15	/*********************************************************************
2			*
3			* UART access routines for C18 and C30
4			*
5			*********************************************************************
6			* FileName: UART.c
7			* Dependencies: UART.h
8			* Processor: PIC18, PIC24F/H, dsPIC30F, dsPIC33F
9			* Complier: Microchip C18 v3.03 or higher
10			* Complier: Microchip C30 v2.01 or higher
11			* Company: Microchip Technology, Inc.
12			*
13			* Software License Agreement
14			*
15			* Copyright © 2002-2007 Microchip Technology Inc. All rights
16			* reserved.
17			*
18			* Microchip licenses to you the right to use, modify, copy, and
19			* distribute:
20			* (i) the Software when embedded on a Microchip microcontroller or
21			* digital signal controller product (“Device”) which is
22			* integrated into Licensee’s product; or
23			* (ii) ONLY the Software driver source files ENC28J60.c and
24			* ENC28J60.h ported to a non-Microchip device used in
25			* conjunction with a Microchip ethernet controller for the
26			* sole purpose of interfacing with the ethernet controller.
27			*
28			* You should refer to the license agreement accompanying this
29			* Software for additional information regarding your rights and
30			* obligations.
31			*
32			* THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT
33			* WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
34			* LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A
35			* PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL
36			* MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR
37			* CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF
38			* PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS
39			* BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE
40			* THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER
41			* SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT
42			* (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
43			*
44			*
45			* Author Date Comment
46			*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
47			* Howard Schlunder 4/04/06 Copied from dsPIC30 libraries
48			* Howard Schlunder 6/16/06 Added PIC18
49			********************************************************************/
50			#define __UART_C
51
52			#include "TCPIP Stack/TCPIP.h"
53
54			#if defined(STACK_USE_UART)
55
56			BYTE ReadStringUART(BYTE *Dest, BYTE BufferLen)
57			{
58			BYTE c;
59			BYTE count = 0;
60
61			while(BufferLen--)
62			{
63			*Dest = '\0';
64
65			while(!DataRdyUART());
66			c = ReadUART();
67
68			if(c == '\r' \|\| c == '\n')
69			break;
70
71			count++;
72			*Dest++ = c;
73			}
74
75			return count;
76			}
77
78
79			#if defined(__dsPIC33F__) \|\| defined(__dsPIC30F__) \|\| defined(__PIC24H__) \|\| defined(__PIC24F__)
80
81
82			/***************************************************************************
83			* Function Name : putsUART2 *
84			* Description : This function puts the data string to be transmitted *
85			* into the transmit buffer (till NULL character) *
86			* Parameters : unsigned int * address of the string buffer to be *
87			* transmitted *
88			* Return Value : None *
89			***************************************************************************/
90
91			void putsUART2(unsigned int *buffer)
92			{
93			char * temp_ptr = (char *) buffer;
94
95			/* transmit till NULL character is encountered */
96
97			if(U2MODEbits.PDSEL == 3) /* check if TX is 8bits or 9bits */
98			{
99			while(*buffer != '\0')
100			{
101			while(U2STAbits.UTXBF); /* wait if the buffer is full */
102			U2TXREG = buffer++; / transfer data word to TX reg */
103			}
104			}
105			else
106			{
107			while(*temp_ptr != '\0')
108			{
109			while(U2STAbits.UTXBF); /* wait if the buffer is full */
110			U2TXREG = temp_ptr++; / transfer data byte to TX reg */
111			}
112			}
113			}
114
115
116			/******************************************************************************
117			* Function Name : getsUART2 *
118			* Description : This function gets a string of data of specified length *
119			* if available in the UxRXREG buffer into the buffer *
120			* specified. *
121			* Parameters : unsigned int length the length expected *
122			* unsigned int buffer the received data to be
123			* recorded to this array *
124			* unsigned int uart_data_wait timeout value *
125			* Return Value : unsigned int number of data bytes yet to be received *
126			******************************************************************************/
127
128			unsigned int getsUART2(unsigned int length,unsigned int *buffer,
129			unsigned int uart_data_wait)
130
131			{
132			unsigned int wait = 0;
133			char temp_ptr = (char ) buffer;
134
135			while(length) /* read till length is 0 */
136			{
137			while(!DataRdyUART2())
138			{
139			if(wait < uart_data_wait)
140			wait++ ; /wait for more data /
141			else
142			return(length); /Time out- Return words/bytes to be read /
143			}
144			wait=0;
145			if(U2MODEbits.PDSEL == 3) /* check if TX/RX is 8bits or 9bits */
146			buffer++ = U2RXREG; / data word from HW buffer to SW buffer */
147			else
148			temp_ptr++ = U2RXREG & 0xFF; / data byte from HW buffer to SW buffer */
149
150			length--;
151			}
152
153			return(length); /* number of data yet to be received i.e.,0 */
154			}
155
156
157			/*********************************************************************
158			* Function Name : DataRdyUart2 *
159			* Description : This function checks whether there is any data *
160			* that can be read from the input buffer, by *
161			* checking URXDA bit *
162			* Parameters : None *
163			* Return Value : char if any data available in buffer *
164			*********************************************************************/
165
166			char DataRdyUART2(void)
167			{
168			return(U2STAbits.URXDA);
169			}
170
171
172			/*************************************************************************
173			* Function Name : BusyUART2 *
174			* Description : This returns status whether the transmission *
175			* is in progress or not, by checking Status bit TRMT *
176			* Parameters : None *
177			* Return Value : char info whether transmission is in progress *
178			*************************************************************************/
179
180			char BusyUART2(void)
181			{
182			return(!U2STAbits.TRMT);
183			}
184
185
186			/***************************************************************************
187			* Function Name : ReadUART2 *
188			* Description : This function returns the contents of UxRXREG buffer *
189			* Parameters : None *
190			* Return Value : unsigned int value from UxRXREG receive buffer *
191			***************************************************************************/
192
193			unsigned int ReadUART2(void)
194			{
195			if(U2MODEbits.PDSEL == 3)
196			return (U2RXREG);
197			else
198			return (U2RXREG & 0xFF);
199			}
200
201
202			/*********************************************************************
203			* Function Name : WriteUART2 *
204			* Description : This function writes data into the UxTXREG, *
205			* Parameters : unsigned int data the data to be written *
206			* Return Value : None *
207			*********************************************************************/
208
209			void WriteUART2(unsigned int data)
210			{
211			if(U2MODEbits.PDSEL == 3)
212			U2TXREG = data;
213			else
214			U2TXREG = data & 0xFF;
215			}
216
217
218			#elif defined(__18CXX)
219			//
220			// PIC18
221			//
222
223
224			char BusyUSART(void)
225			{
226			return !TXSTAbits.TRMT;
227			}
228
229			void CloseUSART(void)
230			{
231			RCSTA &= 0x4F; // Disable the receiver
232			TXSTAbits.TXEN = 0; // and transmitter
233
234			PIE1 &= 0xCF; // Disable both interrupts
235			}
236
237			char DataRdyUSART(void)
238			{
239			if(RCSTAbits.OERR)
240			{
241			RCSTAbits.CREN = 0;
242			RCSTAbits.CREN = 1;
243			}
244			return PIR1bits.RCIF;
245			}
246
247			char ReadUSART(void)
248			{
249			return RCREG; // Return the received data
250			}
251
252			void WriteUSART(char data)
253			{
254			TXREG = data; // Write the data byte to the USART
255			}
256
257			void getsUSART(char *buffer, unsigned char len)
258			{
259			char i; // Length counter
260			unsigned char data;
261
262			for(i=0;i<len;i++) // Only retrieve len characters
263			{
264			while(!DataRdyUSART());// Wait for data to be received
265
266			data = getcUART(); // Get a character from the USART
267			// and save in the string
268			*buffer = data;
269			buffer++; // Increment the string pointer
270			}
271			}
272
273			void putsUSART( char *data)
274			{
275			do
276			{ // Transmit a byte
277			while(BusyUSART());
278			putcUART(*data);
279			} while( *data++ );
280			}
281
282			void putrsUSART(const rom char *data)
283			{
284			do
285			{ // Transmit a byte
286			while(BusyUSART());
287			putcUART(*data);
288			} while( *data++ );
289			}
290
291			#endif
292
293
294			#endif //STACK_USE_UART