A Step by Step Guide on UART Programming for VxWorks 7

Introduction

#

UART (Universal Asynchronous Receiver/Transmitter) programming is essential for embedded systems, providing a simple, cost-effective way to achieve serial communication. VxWorks 7, renowned for its real-time capabilities, supports UART programming, making it an excellent choice for applications requiring deterministic behavior. This article will guide you through the process of UART programming under VxWorks 7, from setup to debugging.

Understanding UART

#

VxWorks 7, like many real-time operating systems, treats hardware peripherals such as UART as file descriptors. This abstraction allows developers to interact with hardware using familiar file I/O system calls, simplifying the programming model.

Prerequisites

#

• VxWorks 7 Development Environment: Ensure you have the VxWorks 7 SDK installed, which includes Wind River Workbench for development.
• Target Hardware: A board or simulator that supports VxWorks 7 with a UART interface.
• Basic Knowledge: Understanding of C programming and familiarity with VxWorks concepts like tasks, semaphores, and interrupts.

Setting Up the Environment

#

1. Board Support Package (BSP): Choose or configure a BSP that supports your target hardware. VxWorks provides BSPs for various platforms, each tailored to specific hardware.
2. Install Drivers: Ensure that UART drivers are included in your VxWorks image. This might involve configuring your VxWorks Image Project (VIP) to include the necessary drivers.

Opening and Configuring UART

#

1. Open UART Device:

• Use the open() system call to acquire a file descriptor for the UART. In VxWorks, UART devices are typically represented as /tyCo/x, where ‘x’ is the number of the COM port.

int fd = open("/tyCo/0", O_RDWR | O_NOCTTY | O_NDELAY);
if (fd < 0) {
    perror("Error opening UART");
    return -1;
}

2. Configure UART Settings:

Use ioctl() to set up baud rate, parity, stop bits, etc. Below is a function to set these parameters:

void configureUART(int fd, int baud, int parity, int databits, int stopbits) {
    struct termios options;
    tcgetattr(fd, &options);

    // Set baud rate
    cfsetispeed(&options, baud);
    cfsetospeed(&options, baud);

    // Set parity
    options.c_cflag &= ~PARENB;
    options.c_cflag &= ~CSTOPB;
    options.c_cflag &= ~CSIZE;
    switch (databits) {
        case 5: options.c_cflag |= CS5; break;
        case 6: options.c_cflag |= CS6; break;
        case 7: options.c_cflag |= CS7; break;
        case 8: options.c_cflag |= CS8; break;
    }
    if (parity == 'O') options.c_cflag |= PARENB | PARODD;
    else if (parity == 'E') options.c_cflag |= PARENB;
    else options.c_cflag &= ~PARENB;

    if (stopbits == 2) options.c_cflag |= CSTOPB;

    // Apply configuration
    tcsetattr(fd, TCSANOW, &options);
}

Reading/Writing to UART

#

• Writing Data:

char *message = "Hello, UART!";
write(fd, message, strlen(message));

• Reading Data:

char buffer[256];
ssize_t ret = read(fd, buffer, sizeof(buffer) - 1);
if (ret > 0) {
    buffer[ret] = '\0';  // Null-terminate the string
    printf("Received: %s\n", buffer);
}

Handling Interrupts

#

Interrupts are crucial in UART (Universal Asynchronous Receiver/Transmitter) programming, especially within embedded systems where performance and responsiveness are key. Here’s how you can approach UART interrupt handling, specifically focusing on general principles and implementation details:

Basics of UART Interrupts

#

UART interrupts typically occur for:

• Data Reception (RX): When new data is received.
• Data Transmission (TX): When the transmitter buffer is empty and ready for more data.
• Errors: Such as framing errors, parity errors, or overflow.

Implementing UART Interrupt Handling

#

1. Enable UART Interrupts:

• Configure your UART hardware to enable interrupts for the events you wish to handle. This usually involves setting bits in control registers.

2. Connect Interrupt Handler:

• In your software, you need to connect an interrupt service routine (ISR) to the UART interrupt vector. Here’s a conceptual example:

// Example in a generic context, specifics depend on your OS or bare-metal environment
void connectUARTInterrupt() {
    // Assuming INT_UART is the vector for UART interrupts
    intConnect(INT_UART, uartInterruptHandler, 0);  // '0' could be a parameter for the handler
}

3. Write the ISR:

• The ISR should handle the interrupt quickly, acknowledging the interrupt and performing minimal processing to not block the system for too long.

void uartInterruptHandler(void *parameter) {
    // Acknowledge the interrupt
    uartClearInterruptFlags();

    // Check which interrupt occurred (RX, TX, or error)
    if (uartIsRxInterrupt()) {
        // Handle received data
        char receivedChar = uartReadData();
        processReceivedChar(receivedChar);
    } else if (uartIsTxInterrupt()) {
        // Handle transmitter empty
        if (thereIsDataToSend()) {
            uartSendNextByte();
        }
    } else {
        // Handle errors
        handleUARTError();
    }
}

• Note: Functions like uartClearInterruptFlags, uartIsRxInterrupt, etc., are placeholders for actual hardware-specific operations.

4. Data Buffering:

• For RX, implement a buffer to store incoming data since interrupts should be short.
• For TX, if using interrupts, you might buffer data to be sent, triggering the next byte send when the TX interrupt fires.

5. Error Handling:

• Implement checks for errors in your ISR and handle or log them appropriately.

6. Real-Time Considerations:

• If working with an RTOS, ensure your ISR is as brief as possible, offloading any heavy processing to a task that can be woken by the ISR.

7. Testing:

• Test your interrupt handler with different scenarios like high data rates, error conditions, and edge cases like buffer overflows.

Considerations:

#

• Priority: UART interrupts might need to have a specific priority, especially if other interrupts are in use.
• Context Switching: Understand how your system handles context switching in ISRs, particularly if you’re using an RTOS like VxWorks.
• Atomic Operations: Ensure operations within the ISR are atomic if necessary to prevent data corruption.

Conclusion

#

UART interrupt handling allows your system to respond promptly to serial communication events, which is vital for real-time systems or any application where timing is crucial. Always ensure your implementation is tested thoroughly to guarantee reliability under all expected conditions. If you’re working with a specific OS or hardware, refer to the detailed documentation for exact register settings and API functions.

Example code

#

For real-time applications, managing UART interrupts can enhance performance. VxWorks allows you to attach interrupt handlers:

void uart_interrupt_handler(int arg) {
    // Handle interrupt logic here
}

// Attach handler to UART interrupt
int vector = ...; // Vector number for UART interrupt
void *parameter = ...;
int status = intConnect((VOIDFUNCPTR *)INUM_TO_IVEC(vector), uart_interrupt_handler, parameter);
if (status == OK) {
    intEnable(vector);
}

Debugging and Testing

#

Use VxWorks Shell: For debugging, run your application in the VxWorks shell on the target hardware where you can interact with your UART directly. Logging: Implement logging within your application to track UART operations and debug communication issues.

Conclusion

#

UART programming under VxWorks 7 leverages the system’s robust real-time features, providing developers with a stable environment for serial communication. By following these steps, you can effectively integrate UART functionality into your embedded system, ensuring reliable data transmission with minimal latency, which is crucial for time-sensitive applications. Remember, the exact implementation might vary slightly depending on your specific hardware and BSP, so always refer to the vendor’s documentation for precise configurations.