hangpersonal/TI_C2000_F28377S_FreeRTOS
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update repo

Browse Source
This commit is contained in:
hangpersonal committed 2026-09-05 12:09:21 -07:00
1 parent ef5f9a563e
commit dfe8ec02bd
12 files changed
+723 -341
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

freertos_driverlib_f28377s/source/uart_drv.c
+144
View File
@@ -0,0 +1,144 @@
/*****************************************************************************/
/* UART_LOWLEV.C - Example user-defined device. */
/*****************************************************************************/
#include <file.h>
#include "uart_drv.h"
//#include "uart.h"
extern void UartSetup();
extern void UartPutChar(int charToWrite);
/*****************************************************************************/
/* This is a sample implementation of a user-defined device. The device */
/* must define the seven basic functions (open, close, read, write, lseek, */
/* unlink, rename). These are expected to behave just like the Unix */
/* functions of these names. Some devices might not have a reasonable */
/* action to take for some functions; a UART or TTY device might not be */
/* lseek-able, but can still be opened and written to. A device is added */
/* using the add_device() RTS function call (q.v.). */
/*****************************************************************************/
/* The low-level interface is based on file names and file descriptors. */
/* The file names don't need to be valid Unix file names, but must mean */
/* something to the device. The device must keep track of its own file */
/* descriptors, which will be used by the calling functions to read and */
/* write to the device. If there can only be one instance of a "file" on a */
/* device, the file descriptor doesn't matter much, so just pass a */
/* non-negative integer such as zero. */
/*****************************************************************************/
/*****************************************************************************/
/* */
/* UART_open() */
/* */
/*****************************************************************************/
int UART_open(const char *path, unsigned flags, int llv_fd)
{
/*-----------------------------------------------------------------------*/
/* Only one UART device exists (_SSA). For an _SSA device, file names */
/* are not meaningful, so ignore the file name. */
/*-----------------------------------------------------------------------*/
/*-----------------------------------------------------------------------*/
/* Don't allow attempts to open the UART device that aren't O_WRONLY. */
/*-----------------------------------------------------------------------*/
if (!(flags & O_WRONLY)) return -1;
/*-----------------------------------------------------------------------*/
/* Set up the UART */
/*-----------------------------------------------------------------------*/
UartSetup();
/*-----------------------------------------------------------------------*/
/* Arbitrarily give it file descriptor 1. File descriptors are */
/* device-specific; this file descriptor 1 is not the same as HOST file */
/* descriptor 1 (stdout). */
/*-----------------------------------------------------------------------*/
return 1;
}
/*****************************************************************************/
/* */
/* UART_close() */
/* */
/*****************************************************************************/
int UART_close(int dev_fd)
{
/*-----------------------------------------------------------------------*/
/* Only one UART device exists, so we don't do anything upon close. */
/*-----------------------------------------------------------------------*/
return 0;
}
/*****************************************************************************/
/* */
/* UART_read() reads *at most* count bytes. */
/* */
/*****************************************************************************/
int UART_read(int dev_fd, char *buf, unsigned count)
{
/*-----------------------------------------------------------------------*/
/* Only one UART device exists, and it is write-only, so return error */
/*-----------------------------------------------------------------------*/
return -1;
}
/*****************************************************************************/
/* */
/* UART_write() */
/* */
/*****************************************************************************/
int UART_write(int dev_fd, const char *buf, unsigned count)
{
unsigned i;
/*-----------------------------------------------------------------------*/
/* Output character-by-character */
/*-----------------------------------------------------------------------*/
for (i=0; i < count; i++)
UartPutChar(buf[i]);
return count;
}
/*****************************************************************************/
/* */
/* UART_lseek() */
/* */
/*****************************************************************************/
off_t UART_lseek(int dev_fd, off_t offset, int origin)
{
/*-----------------------------------------------------------------------*/
/* lseek is not possible on UART. */
/*-----------------------------------------------------------------------*/
return -1;
}
/*****************************************************************************/
/* */
/* UART_unlink() */
/* */
/*****************************************************************************/
int UART_unlink(const char *path)
{
/*-----------------------------------------------------------------------*/
/* unlink is not possible on UART */
/*-----------------------------------------------------------------------*/
return -1;
}
/*****************************************************************************/
/* */
/* UART_rename() */
/* */
/*****************************************************************************/
/* rename is unusual among the low-level functions in that it is also */
/* specified in the ISO C standard. It has the same prototype and */
/* semantics, so it's not really an issue. */
/*****************************************************************************/
int UART_rename(const char *old_name, const char *new_name)
{
/*-----------------------------------------------------------------------*/
/* rename is not possible on UART */
/*-----------------------------------------------------------------------*/
return -1;
}