matthias/diplomarbeit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added Software projects

Browse Source 
git-svn-id: file:///srv/dev-disk-by-uuid-17e88007-4d0c-45e0-8757-cacfcc458630/repositories/svn/Diplomarbeit@55 9fe90eed-be63-e94b-8204-d34ff4c2ff93
This commit is contained in:
Matthias
2008-12-23 10:34:08 +00:00
parent ee5a771818
commit 373a8c32b2
348 changed files with 86781 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Tester/SW/lib/Drivers/uart2.c
+331
View File
@@ -0,0 +1,331 @@
/******************************************************************************
*
* $RCSfile: $
* $Revision: $
*
* This module provides interface routines to the LPC ARM UARTs.
* Copyright 2004, R O SoftWare
* No guarantees, warrantees, or promises, implied or otherwise.
* May be used for hobby or commercial purposes provided copyright
* notice remains intact.
*
* Modified by Martin Thomas for LPC23xx 24xx
*****************************************************************************/
#include "app_types.h"
#include "LPC_REGS.h"
#include "sys_config.h"
#include "uart2.h"
#ifndef USHRT_MAX
#define USHRT_MAX 16
#endif
#include "armVIC.h"
#include "uart2ISR.h"
#define U2_TX_PINSEL_REG PINSEL4
#define U2_TX_PINSEL (2UL<<16) /* PINSEL4 Value for UART2 TX */
#define U2_TX_PINMASK (3UL<<16) /* PINSEL4 Mask for UART2 RX */
#define U2_RX_PINSEL_REG PINSEL4
#define U2_RX_PINSEL (2UL<<18) /* PINSEL4 Value for UART2 TX */
#define U2_RX_PINMASK (3UL<<18) /* PINSEL4 Mask for UART2 RX */
uint8_t uart2_rx_buffer[UART2_RX_BUFFER_SIZE];
uint16_t uart2_rx_insert_idx, uart2_rx_extract_idx;
uint8_t uart2_tx_buffer[UART2_TX_BUFFER_SIZE];
uint16_t uart2_tx_insert_idx, uart2_tx_extract_idx;
int uart2_tx_running;
t_uart2_txcomplete uart2_tx_complete_callback;
void uart2TxFinished(void);
void uart2Init(uint16_t baud, uint8_t mode, uint8_t fmode)
{
PCONP |= BIT( 24 ); // power on UART2
// set port pins for UART2
// mthomas PINSEL0 = (PINSEL0 & ~U0_PINMASK) | U0_PINSEL;
// set port pins for UART2
// PINSEL0 = (PINSEL0 & ~U0_PINMASK) | U0_PINSEL;
U2_TX_PINSEL_REG = ( U2_TX_PINSEL_REG & ~U2_TX_PINMASK ) | U2_TX_PINSEL;
U2_RX_PINSEL_REG = ( U2_RX_PINSEL_REG & ~U2_RX_PINMASK ) | U2_RX_PINSEL;
U2IER = 0x00; // disable all interrupts
U2IIR; // clear interrupt ID
U2RBR; // clear receive register
U2LSR; // clear line status register
// Set CLOCK for UART2 device (4x)
//PCLKSEL1 = 0x00010000;
// Set CLOCK for UART2 device (div 2)
PCLKSEL1 &= 0xFFFDFFFF;
PCLKSEL1 |= 0x00020000;
// Preset callback function to none
uart2_tx_complete_callback = 0;
// set the baudrate
U2LCR = ULCR_DLAB_ENABLE; // select divisor latches
U2DLL = (uint8_t)baud; // set for baud low byte
U2DLM = (uint8_t)(baud >> 8); // set for baud high byte
// set the number of characters and other
// user specified operating parameters
U2LCR = (mode & ~ULCR_DLAB_ENABLE);
U2FCR = fmode;
// initialize the interrupt vector
VICIntSelect &= ~VIC_CHAN_TO_MASK(VIC_CHAN_NUM_UART2);
VICIntEnClr = VIC_CHAN_TO_MASK(VIC_CHAN_NUM_UART2);
VICVectAddr28 = (uint32_t)uart2ISR;
VICVectPriority28 = 0xF;
VICIntEnable = VIC_CHAN_TO_MASK(VIC_CHAN_NUM_UART2);
// initialize the transmit data queue
uart2_tx_extract_idx = uart2_tx_insert_idx = 0;
uart2_tx_running = 0;
// initialize the receive data queue
uart2_rx_extract_idx = uart2_rx_insert_idx = 0;
// enable receiver interrupts
U2IER = UIER_RBR;
}
/******************************************************************************
*
* Function Name: uart2Putch()
*
* Description:
* This function puts a character into the UART output queue for
* transmission.
*
* Calling Sequence:
* character to be transmitted
*
* Returns:
* ch on success, -1 on error (queue full)
*
*****************************************************************************/
int uart2Putch(int ch)
{
uint16_t temp;
unsigned cpsr;
temp = (uart2_tx_insert_idx + 1) % UART2_TX_BUFFER_SIZE;
if (temp == uart2_tx_extract_idx)
return -1; // no room
cpsr = disableIRQ(); // disable global interrupts
U2IER &= ~UIER_THRE; // disable TX interrupts
restoreIRQ(cpsr); // restore global interrupts
// check if in process of sending data
if (uart2_tx_running)
{
// add to queue
uart2_tx_buffer[uart2_tx_insert_idx] = (uint8_t)ch;
uart2_tx_insert_idx = temp;
}
else
{
// set running flag and write to output register
uart2_tx_running = 1;
U2THR = (uint8_t)ch;
}
cpsr = disableIRQ(); // disable global interrupts
U2IER |= UIER_THRE; // enable TX interrupts
restoreIRQ(cpsr); // restore global interrupts
return (uint8_t)ch;
}
/******************************************************************************
*
* Function Name: uart2Space()
*
* Description:
* This function gets the available space in the transmit queue
*
* Calling Sequence:
* void
*
* Returns:
* available space in the transmit queue
*
*****************************************************************************/
uint16_t uart2Space(void)
{
int space;
if ((space = (uart2_tx_extract_idx - uart2_tx_insert_idx)) <= 0)
space += UART2_TX_BUFFER_SIZE;
return (uint16_t)(space - 1);
}
/******************************************************************************
*
* Function Name: uart2Puts()
*
* Description:
* This function writes a NULL terminated 'string' to the UART output
* queue, returning a pointer to the next character to be written.
*
* Calling Sequence:
* address of the string
*
* Returns:
* a pointer to the next character to be written
* (\0 if full string is written)
*
*****************************************************************************/
const char *uart2Puts(const char *string)
{
register char ch;
while ((ch = *string) && (uart2Putch(ch) >= 0))
string++;
return string;
}
/******************************************************************************
*
* Function Name: uart2Write()
*
* Description:
* This function writes 'count' characters from 'buffer' to the UART
* output queue.
*
* Calling Sequence:
*
*
* Returns:
* 0 on success, -1 if insufficient room, -2 on error
* NOTE: if insufficient room, no characters are written.
*
*****************************************************************************/
int uart2Write(const char *buffer, uint16_t count)
{
if (count > uart2Space())
return -1;
while (count && (uart2Putch(*buffer++) >= 0))
count--;
return (count ? -2 : 0);
}
/******************************************************************************
*
* Function Name: uart2TxEmpty()
*
* Description:
* This function returns the status of the UART transmit data
* registers.
*
* Calling Sequence:
* void
*
* Returns:
* FALSE - either the tx holding or shift register is not empty
* !FALSE - if both the tx holding & shift registers are empty
*
*****************************************************************************/
int uart2TxEmpty(void)
{
return (U2LSR & (ULSR_THRE | ULSR_TEMT)) == (ULSR_THRE | ULSR_TEMT);
}
int uart2RxEmpty(void)
{
if (uart2_rx_insert_idx == uart2_rx_extract_idx) // check if character is available
{
return 1;
}
else
{
return 0;
}
}
/******************************************************************************
*
* Function Name: uart2TxFlush()
*
* Description:
* This function removes all characters from the UART transmit queue
* (without transmitting them).
*
* Calling Sequence:
* void
*
* Returns:
* void
*
*****************************************************************************/
void uart2TxFlush(void)
{
unsigned cpsr;
U2FCR |= UFCR_TX_FIFO_RESET; // clear the TX fifo
// "Empty" the transmit buffer.
cpsr = disableIRQ(); // disable global interrupts
U2IER &= ~UIER_THRE; // disable TX interrupts
restoreIRQ(cpsr); // restore global interrupts
uart2_tx_insert_idx = uart2_tx_extract_idx = 0;
}
/******************************************************************************
*
* Function Name: uart2Getch()
*
* Description:
* This function gets a character from the UART receive queue
*
* Calling Sequence:
* void
*
* Returns:
* character on success, -1 if no character is available
*
*****************************************************************************/
int uart2Getch(void)
{
uint8_t ch;
if (uart2_rx_insert_idx == uart2_rx_extract_idx) // check if character is available
return -1;
ch = uart2_rx_buffer[uart2_rx_extract_idx++]; // get character, bump pointer
uart2_rx_extract_idx %= UART2_RX_BUFFER_SIZE; // limit the pointer
return ch;
}
void uart2SubscribeTxFinished( t_uart2_txcomplete callback )
{
uart2_tx_complete_callback = callback;
}
void uart2UnsubsribeTxFinished( t_uart2_txcomplete callback )
{
uart2_tx_complete_callback = 0;
}
void uart2TxFinished(void)
{
if (uart2_tx_complete_callback != 0)
{
uart2_tx_complete_callback();
}
}