Эмулятор VMLAB.
Насколько я в курсе WinAVR/GCC он поддерживает.
Правда надо менять тип дебаговой информации для объектныъ модулей.

Features:
supports Atmel AVR Studio 4, Version 4.09, 4.10.356, 4.11.401 and 4.11.403-405.
simultaniously simulates one or more of each of the following components:
HD44780U compatible LC-Display with up to 40 x 2 characters.
Pushbuttons connected to Input Port Pins.
LEDs connected to Output Port Pins.
Terminal connected to USART, UART or TWI(I2C) ports.
easy configuration of the components.
configuration files are stored in future-save XML format.
target device selection with all devices supported by the AVR Simulator.

LCD features:
acts like a real HD44780U.
1 or 2 Display lines.
8 to 40 characters per line.
4bit AND 8bit I/O mode support.
supports the complete original character set (5 x 8 dot)
including all the characters above 0x80 ;-)
support for 8 user defined characters.
supports blinking cursor, display shifting, cursor movement.
selectable background color and display size (zoom factor).

How to use HAPSIM - Quickstart:
Download and unzip HYPERLINK "http://www.helmix.at/hapsim.htm" \l "hapsimdownload#hapsimdownload"
HAPSIM
and HYPERLINK "http://www.helmix.at/hapsim.htm" \l "hapsimdownload#hapsimdownload"
LCDTest

вот что-то подобное но сам не пробовал

Кто тут "С"шные библиотеки искал?

Есть в природе Procyon AVRlib от Pascal Stang, например, здесь:
http://ccrma.stanford.edu/courses/250a/docs/avrlib/main.html

Here is a list of all modules:

Drivers (for AVR peripherals)
A/D Converter Function Library (a2d.c)
I2C Serial Interface Function Library (i2c.c)
EEPROM Parameter Storage Library (param.c)
Pulse/Frequency Generation Function Library (pulse.c)
SPI (Serial Peripheral Interface) Function Library (spi.c)
Timer Function Library (timer.c)
Timer PWM Commands
Timer Function Library for ATmega128 (timer128.c)
Timer Function Library for ATmegaXX8 (timerx8.c)
Timer PWM Commands
UART Driver/Function Library (uart.c)
UART Driver/Function Library for dual-UART processors (uart2.c)
Drivers (for external hardware)
TI ADS7828 I2C A/D Converter Driver (ads7828.c)
TI ADS7870 SPI A/D Converter Driver (ads7870.c)
IDE/ATA Interface Driver (ata.c)
Dallas DS1631 Temperature Sensor Driver (ds1631.c)
Quadrature Encoder Driver (encoder.c)
Graphic LCD API (application programmer's interface) (glcd.c)
GPS Positioning and Navigation Function Library (gps.c)
Interface for standard I2C EEPROM memories (i2ceeprom.c)
Graphic LCD Driver for HD61202/KS0108-based Displays (ks0108.c)
Character LCD Driver for HD44780/SED1278-based displays (lcd.c)
ST LIS3L02 3-axis I2C Accelerometer Library (lis3l02.c)
MultiMedia and SD Flash Card Interface (mmc.c)
NMEA Packet Interface for GPS Receivers (nmea.c)
Interface for standard SPI EEPROM memories (spieeprom.c)
ST STA013 MP3 Player Driver (sta013.c)
TSIP Packet Interface for Trimble GPS Receivers (tsip.c)
Drivers (software-based)
Software I2C Serial Interface Function Library (i2csw.c)
Interrupt-driven RC Servo Function Library (servo.c)
Software Interrupt-driven UART Driver (uartsw.c)
Software Interrupt-driven UART Driver (uartsw2.c)
General Libraries
Generic Bit-Buffer Structure and Function Library (bitbuf.c)
Circular Byte-Buffer Structure and Function Library (buffer.c)
Command-line Implementation (cmdline.c)
FAT16/32 File System Interface (fat.c)
Fixed-Point Math Function Library (fixedpt.c)
printf() Function Library (rprintf.c)
STX/ETX Packet Protocol Library (stxetx.c)
VT100 Terminal Function Library (vt100.c)
Network Library
ARP Protocol Library (arp.c)
ASIX AX88796 Ethernet Interface Driver (ax88796.c)
Crystal CS8900 Ethernet Interface Driver (cs8900.c)
DHCP Protocol Library (dhcp.c)
ICMP Protocol Library (icmp.c)
IP (Internet Protocol) Library (ip.c)
Network support library (net.c)
Network Stack (netstack.c)
Network Interface Card (NIC) software definition (nic.h)
PrismII 802.11b WLAN Interface Driver (prism2.c)
Realtek RTL8019AS Ethernet Interface Driver (rtl8019.c)

--------------------------------------------------------------------------------
Приятель разбирался - "не все оптимально, но вроде работает"

Библиотека заточена под WinAVR/GCC

Большое спасибо за эти ценные ссылки.

Nate, mozet prigoditsya - drayver dlya uart ucos RTOS pod avr. Mozet prigoditsya. Pisal sam .

dobavte v os_cpu_a.s90

EXTERN uart_UDREIsrAvr
EXTERN uart_RXIsrAvr

COMMON INTVEC

DS 4 ; 1 RESET = $000 Reset interrupt Vector Address
DS 4 ; 2 INT0addr = $002 External Interrupt0 Vector Address
DS 4 ; 3 INT1addr = $004 External Interrupt1 Vector Address
DS 4 ; 4 INT2addr = $006 External Interrupt2 Vector Address
DS 4 ; 5 INT3addr = $008 External Interrupt3 Vector Address
DS 4 ; 6 INT4addr = $00a External Interrupt4 Vector Address
DS 4 ; 7 INT5addr = $00c External Interrupt5 Vector Address
DS 4 ; 8 INT6addr = $00e External Interrupt6 Vector Address
DS 4 ; 9 INT7addr = $010 External Interrupt7 Vector Address
DS 4 ; 10 OC2addr = $012 Output Compare2 Interrupt Vector Address
DS 4 ; 11 OVF2addr = $014 Overflow2 Interrupt Vector Address
DS 4 ; 12 ICP1addr = $016 Input Capture1 Interrupt Vector Address
DS 4 ; 13 OC1Aaddr = $018 Output Compare1A Interrupt Vector Address
DS 4 ; 14 OC1Baddr = $01a Output Compare1B Interrupt Vector Address
DS 4 ; 15 OVF1addr = $01c Overflow1 Interrupt Vector Address
DS 4 ; 16 OC0addr = $01e Output Compare0 Interrupt Vector Address
JMP OSTickISR ; 17 OVF0addr = $020 Overflow0 Interrupt Vector Address
JMP spi_SpiIsr ; 18 SPIaddr = $022 SPI Interrupt Vector Address
JMP uart_RXIsr0 ; 19 URXC0addr = $024 USART0 Receive Complete Interrupt Vector Address
JMP uart_UDREIsr0 ; 20 UDRE0addr = $026 USART0 Data Register Empty Interrupt Vector Address
DS 4 ; 21 UTXC0addr = $028 USART0 Transmit Complete Interrupt Vector Address
DS 4 ; 22 ADCCaddr = $02a ADC Conversion Complete Handle
JMP eep_ERDYIsr ; 23 ERDYaddr = $02c EEPROM Write Complete Handle
DS 4 ; 24 ACIaddr = $02e Analog Comparator Interrupt Vector Address
DS 4 ; 25 OC1Caddr = $030 Output Compare1C Interrupt Vector Address
DS 4 ; 26 ICP3addr = $032 Input Capture3 Interrupt Vector Address
DS 4 ; 27 OC3Aaddr = $034 Output Compare3A Interrupt Vector Address
DS 4 ; 28 OC3Baddr = $036 Output Compare3B Interrupt Vector Address
DS 4 ; 29 OC3Caddr = $038 Output Compare3C Interrupt Vector Address
DS 4 ; 30 OVF3addr = $03A Overflow3 Interrupt Vector Address
JMP uart_RXIsr1 ; 31 URXC1addr = $03C USART1 Receive Complete Interrupt Vector Address
JMP uart_UDREIsr1 ; 32 UDRE1addr = $03E USART1 Data Register Empty Interrupt Vector Address
DS 4 ; 33 UTXC1addr = $040 USART1 Transmit Complete Interrupt Vector Address
DS 4 ; 34 TWIaddr = $042 TWI Interrupt Vector Address
DS 4 ; 35 SPMRaddr = $044 Store Program Memory Ready Interrupt Vector Address

END


;*******************************************************************************
*************************
; USART0 RX Complete handling ISR Routine
;*******************************************************************************
*************************

uart_RXIsr0: PUSH_ALL ; Save all registers and status register
IN R16,SREG ; Save the SREG but with interrupts enabled
SBR R16,BIT07
ST -Y,R16
PUSH_SP ; Save the task's hardware stack pointer onto task's stack

LDS R16,OSIntNesting ; OSIntNexting++;
INC R16 ;
STS OSIntNesting,R16 ;

CPI R16,1 ; if (OSIntNesting == 1) {
BRNE uart_rxc0_lab1
LDS R30,OSTCBCur ; OSTCBCur->OSTCBStkPtr = Y
LDS R31,OSTCBCur+1
ST Z+,R28
ST Z+,R29 ; }

uart_rxc0_lab1:
LDI R16, 0 ; Set previously stored port number
CALL uart_RXIsrAvr ; Call ISR handling C Code function
CALL OSIntExit

POP_SP ; Restore the hardware stack pointer from task's stack
POP_SREG ; Restore the SREG register
POP_ALL ; Restore all registers

RET ; Note: RET instead of RETI


;*******************************************************************************
*************************
; UART0 DATA REGISTER EMPTY Interrupt handling Routine
;*******************************************************************************
*************************
uart_UDREIsr0:
PUSH_ALL ; Save all registers and status register
IN R16,SREG ; Save the SREG but with interrupts enabled
SBR R16,BIT07
ST -Y,R16
PUSH_SP ; Save the task's hardware stack pointer onto task's stack
LDS R16,OSIntNesting ; Notify uC/OS-II of ISR
INC R16 ;
STS OSIntNesting,R16 ;

CPI R16,1 ; if (OSIntNesting == 1) {
BRNE uart_udre0_lab1
LDS R30,OSTCBCur ; OSTCBCur->OSTCBStkPtr = Y
LDS R31,OSTCBCur+1
ST Z+,R28
ST Z+,R29 ; }

uart_udre0_lab1:
LDI R16, 0 ; Set port to 0
CALL uart_UDREIsrAvr ; Call ISR handling C Code function
CALL OSIntExit

POP_SP ; Restore the hardware stack pointer from task's stack
POP_SREG ; Restore the SREG register
POP_ALL ; Restore all registers

RET ; Note: RET instead of RETI


a eto programma dlya raboti s uartom - read write with timeouts


/*@******************************************************************************
******************************
*
*
* The comm.c module implementes platform independent functions for serial UART communication .
* It must be cooperate with port dependent fucntions which are platform dependent .
*
* Data types :
* typedef struct
* {
* INT8U state; // Port state
* INT8U txstate; // Tx state
* // Receive related data
* OS_EVENT *rxsem; // Rx waiting semaphore
* INT8U rxbuf[UART_RXBUF_SIZE]; // Pointer to UART Rx ring buffer
* INT8U rxput; // Pointer to first empty pos in Rx ring buffer
* INT8U rxget; // Pointer to first nonemtpy pos in Rx ring buffer
* INT16U rxtimer; // Byte receive timer
* // Transmit related data
* OS_EVENT *txsem; // Tx waiting semaphore
* INT8U txbuf[UART_TXBUF_SIZE]; // Pointer to UART Tx ring buffer
* INT8U txput; // Pointer to first empty pos in Tx ring buffer
* INT8U txget; // Pointer to first nonempty pos in Tx ring buffer
* INT16U txtimer; // Byte transmit timer
* }uart_uart;
*
* Functions :
* Externaly UART subsystem communicates using 5 functions :
* - uart_InitUart()
* - uart_OpenUart()
* - uart_CloseUart()
* - uart_PutByte()
* - uart_GetByte()
*
* Typical function usage is as follow :
* - Initialize the whole uart subsystem with uart_InitUart()
* - Then to use uart port invoke uart_OpenUart().
* - If result from uart_OpenUart() is not COM_NO_ERR it is possible to send and receive data to/from UART via
* uart_PutByte() and uart_GetByte().
* - Finally if particular uart port is not needed - its resources can be deallocated by uart_CloseUart().
*
********************************************************************************
******************************/
#include "uart.h"
#include "uart_avr.h"

/********************************************************************************
******************************
* . TYPEDEFS SECTION
********************************************************************************
******************************/
typedef struct
{
INT8U state; // Port state
INT8U txstate; // Tx state
// Receive related data
OS_EVENT *rxsem; // Rx waiting semaphore
INT8U rxbuf[UART_RXBUF_SIZE]; // Pointer to UART Rx ring buffer
INT8U rxput; // Pointer to first empty pos in Rx ring buffer
INT8U rxget; // Pointer to first nonemtpy pos in Rx ring buffer
INT16U rxtimer; // Byte receive timer
// Transmit related data */
OS_EVENT *txsem; // Tx waiting semaphore
INT8U txbuf[UART_TXBUF_SIZE]; // Pointer to UART Tx ring buffer
INT8U txput; // Pointer to first empty pos in Tx ring buffer
INT8U txget; // Pointer to first nonempty pos in Tx ring buffer
INT16U txtimer; // Byte transmit timer
}uart_uart;

/********************************************************************************
******************************
* . STATIC DATA SECTION
********************************************************************************
******************************/
static uart_uart uartbuf[UART_UART_SIZE];

/********************************************************************************
******************************
* . DEFINITION SECTION
********************************************************************************
******************************/
/*@-----------------------------------------------------------------------------------------------------------*
| uart_InitUart() INITIALIZE UART SUBSYSTEM
|
| Syntax :
| INT8S uart_InitUart(void)
|
| Arguments :
| -
|
| Returns :
| COM_NO_ERR - Function executed OK
|
| Description :
| This function must be called at system startup before any UART related functions can be used
| Function initializes UART internal data .
|
*------------------------------------------------------------------------------------------------------------*/
INT8S uart_InitUart(void)
{
INT8U cnt;

for(cnt =0; cnt < UART_UART_SIZE; cnt++) // Block all UARTs
uartbuf[cnt].state = UART_STATE_CLOSE;

return COM_NO_ERR;
}

/*@-----------------------------------------------------------------------------------------------------------*
| uart_OpenUart() OPEN AND CONFIGURE UART PORT
|
| Syntax :
| INT8S uart_OpenUart(INT8U port,INT16U rxtimer,INT16U txtimer,INT8U speed,INT8U length,INT8U parity,INT8U stopbit)
|
| Arguments :
| INT8U port Port Identifier - UART_1, or UART_2
| INT8U rxtimer Receive timer value in number of clock ticks
| INT8U txtimer Transmit timer value in number of clock ticks
| INT8U speed UART speed - in form UART_SPEED_XXX, where XXX could be (300, 600, 1200, 2400, 4800,
| 9600, 14400, 19200, 38400, 57600, 115200.
| INT8U length Word data length - in form UART_SIZE_X, where X could be 5, 6, 7, 8, 9
| INT8U parity Parity setting - one of the UART_PARITY_EVEN, UART_PARITY_ODD, UART_PARITY_NONE
| INT8U stopbit Stop bits setting - UART_STOPBIT_1, UART_STOPBT_15 and UART_STOPBIT_2
|
|
| Returns :
| COM_NO_ERR If function executes OK
| COM_ERR_PORTID If port identifier supplied is not correct
| COM_ERR_PORT_OPEN If port is already opened
| COM_ERR_TX_SEM Fault when creating Tx semaphore
| COM_ERR_RX_SEM Fault when creating Rx semaphore
|
| Description :
|
*------------------------------------------------------------------------------------------------------------*/
INT8S uart_OpenUart
(
INT8U port, // UART port ID
INT16U rxtimer, // UART receive timeout
INT16U txtimer, // UART transmit timeout
INT8U speed, // UART port speed
INT8U length, // UART data word size
INT8U parity, // UART parity settings
INT8U stopbit // UART stop bits
)
{
uart_uart *uart_p;

if(port >= UART_UART_SIZE ) // Check port value
return COM_ERR_PORTID; //
uart_p = &uartbuf[port]; // Fetch pointer to port data record
//
if((uart_p->rxsem = OSSemCreate(0)) == NULL) // Create RX Semaphore
return COM_ERR_RX_SEM; //
uart_p->rxput = 0; // Reset read position from Rx ring buffer
uart_p->rxget = 0; // Reset write position to Rx ring buffer
uart_p->rxtimer = rxtimer; // Set uart_uart receive timer
//
if((uart_p->txsem = OSSemCreate(UART_TXBUF_SIZE -1)) == NULL) // Create TX semaphore
return COM_ERR_TX_SEM; //
uart_p->txput = 0; // init read position from Tx ring buffer
uart_p->txget = 0; // init write position to Tx ring buffer
uart_p->txtimer = txtimer; // set uart_uart transmitt timer
uart_p->txstate = UART_TX_STATE_OFF; // Set txstate to OFF
//
uart_OpenPortAvr(port, speed, length, parity, stopbit); // initalize platform dependent port data
uart_p->state = UART_STATE_OPEN; // Bring port to traffic
//
return COM_NO_ERR; //
}


/*@-----------------------------------------------------------------------------------------------------------*
| uart_CloseUart() CLOSE UART PORT AND FREE ITS RESOURCES
|
| Syntax :
| INT8S uart_CloseUart(INT8U port)
|
| Arguments :
| COM_ERR_PORTID - Port Id assigned invalid value
| COM_ERR_PORT_CLOSED - Port already in closed state
| COM_NO_ERR - Function executed OK
|
| Returns :
| COM_ERR_PORTID - Invalid (nonexisting) port referred
| COM_NO_ERR - Function executed OK
|
| Description :
| Function closes uart port and release its allocated reasources.
|
*------------------------------------------------------------------------------------------------------------*/
INT8S uart_CloseUart(INT8U port)
{
uart_uart *uart_p;
INT8U err;

if(port >= UART_UART_SIZE ) // Validate port value
return COM_ERR_PORTID;
uart_p = &uartbuf[port]; // Select port to close
if(uart_p->state == UART_STATE_CLOSE) // Check port state
return COM_NO_ERR;

uart_p->state = UART_STATE_CLOSE; // Set port state
uart_ClosePortAvr(port); // Down the port on platform dependent side
OSSemDel(uart_p->rxsem, OS_DEL_ALWAYS, &err); // Delete receive semaphore
OSSemDel(uart_p->txsem, OS_DEL_ALWAYS, &err); // Delete transmit semaphore

return COM_NO_ERR;
}

/*@-----------------------------------------------------------------------------------------------------------*
| uart_PutByte() SEND BYTE OVER UART PORT FUNCTION
|
| Syntax :
| INT8S uart_PutByte(INT8U portid, INT8U byte )
|
| Arguments :
| INT8U portid - UART port identifier
| INT8U byte - byte to send
|
| Return values :
| COM_NO_ERR Character sent to transmit buffer OK
| COM_ERR_PORT_CLOSED The port where transmit is attempted is not opened
| COM_ERR_TX_SEM Problem occured on UART's TX semaphore
|
| Description :
| The function is used to transfer one single byte over UART port .
|
*------------------------------------------------------------------------------------------------------------*/
INT8S uart_PutByte(INT8U portid, INT8U byte )
{
#if OS_CRITICAL_METHOD == 3 // Allocate storage for CPU status register
OS_CPU_SR cpu_sr; //
#endif //
INT8U err; // temp var for error
uart_uart *uart_p; // pointer to uart data structure
//
if(portid >= UART_UART_SIZE) // Check port value
return -1; //
//
uart_p = &uartbuf[portid]; // Fetch pointer to uart data record
if(uart_p->state == UART_STATE_CLOSE) // Validate UART state
return COM_ERR_PORT_CLOSED; //
//
if(uart_p->txstate == UART_TX_STATE_OFF) // If no ongoing transmit is active - send byte directly to port
{ //
uart_p->txstate = UART_TX_STATE_ON; // Mar TX is active
uart_StartTxAvr(portid, byte); // Invoke port gunction to send byte to the port
} //
else // Else if Transmitt is ongoing - put byte to transmit buffer
{ //
OSSemPend(uart_p->txsem, 0, &err); // Wait on Tx Semaphore if buffer full
if(err != OS_NO_ERR) // If semaphore error
return COM_ERR_TX_SEM; // return error
//
OS_ENTER_CRITICAL(); //
uart_p->txbuf[uart_p->txput++] = byte; // Put byte into transmit ring buffer
if(uart_p->txput == UART_TXBUF_SIZE) // Increment ring buffer pointer
uart_p->txput = 0; //
OS_EXIT_CRITICAL(); //
} //
return COM_NO_ERR; // Return OK
}

/*@-----------------------------------------------------------------------------------------------------------*
| uart_GetByte() RECEIVE BYTE FORM UART PORT FUNCTION
|
| Syntax :
| INT8S uart_GetByte(INT8U port, INT8U* rxbyte)
|
| Arguments :
| INT8U port - UART port identifier
| INT8U* rxbyte - Pointer to memory where received character will be stored
|
| Returns :
| COM_NO_ERR - OK result
| COM_ERR_PORT_CLOSED - Port is not initialised
| COM_ERR_RX_TIMEOUT - Receive timeout occured
| COM_ERR_RX_SEM - Problem with Rx semaphore happened
|
| Description :
| Function receives one byte from the uart port. If byte is received OK it will be stored in memory
| pointed by *rxbyte. Function will return error:
| - if uart_OpenUart() fucntion was not invoked before on referred port
| - if no byte received within uart timeout
| - if system error with rx semaphore happened
|
*------------------------------------------------------------------------------------------------------------*/
INT8S uart_GetByte(INT8U port, INT8U* rxbyte)
{
#if OS_CRITICAL_METHOD == 3 // Allocate storage for CPU status register
OS_CPU_SR cpu_sr; //
#endif //
uart_uart *uart_p; // pointer to port data
INT8U err; // error var for semaphore handling
//
if(port >= UART_UART_SIZE) // Check uart port id
return COM_ERR_PORT_CLOSED; //
uart_p = &uartbuf[port]; // select port data to use
if(uart_p->state == UART_STATE_CLOSE) // if port is not opened
return COM_ERR_PORT_CLOSED; // return error - 'attempt to use closed port'
//
OSSemPend(uart_p->rxsem, uart_p->rxtimer, &err); // Wait for byte from Rx line
switch(err) // Branch on the result
{ //
case OS_NO_ERR : break; // Byte is ready - proceed
case OS_TIMEOUT: return COM_ERR_RX_TIMEOUT; // Semaphore timeout
default : return COM_ERR_RX_SEM; // Semaphore or OS problem
} //
//
if(uart_p->rxget == uart_p->rxput) // Check if there is byte to process
return COM_ERR_RX_TIMEOUT; // This is not needed as semaphore handles that
// Extract received character from ring buffer
OS_ENTER_CRITICAL(); //
*rxbyte = uart_p->rxbuf[uart_p->rxget++]; // read byte from Rx ring buffer
if(uart_p->rxget== UART_RXBUF_SIZE) // if overflow on Rx ring buffer ?
uart_p->rxget = 0; // wrap around ring buffer
OS_EXIT_CRITICAL();

return COM_NO_ERR;
}

/*------------------------------------------------------------------------------------------------------------*
| uart_PutByteIsr() - PUT RECEIVED BUFFER INTO RX BUFFER FUNCTION
|
| Syntax :
| INT8S uart_PutByteIsr(INT8U port, INT8U byte)
|
| Arguments :
| INT8U port - Uart port id
| INT8U byte - Byte to store in rx buffer
|
| Returns :
| COM_ERR_PORT_CLOSED - Port is not ready
| COM_ERR_RXBUF_FULL - RX buffer full
| COM_NO_ERR - Function executed OK
|
| Description :
| The function is called from ISR device dependent uart source when new character received
| from Rx line .
|
*------------------------------------------------------------------------------------------------------------*/
INT8S uart_PutByteIsr(INT8U port, INT8U byte)
{
#if OS_CRITICAL_METHOD == 3 // Allocate storage for CPU status register
OS_CPU_SR cpu_sr; //
#endif //
uart_uart *uart_p; //
//
uart_p = &uartbuf[port]; // Select port data to use
if(uart_p->state == UART_STATE_CLOSE) // If port is not ready
return COM_ERR_PORT_CLOSED; // return error - 'attempt to use closed port'
//
OS_ENTER_CRITICAL(); //
uart_p->rxbuf[uart_p->rxput] = byte; // Store byte in Rx ring buffer
if(++(uart_p->rxput) == UART_RXBUF_SIZE) // Increment write pointer to rx buffer
uart_p->rxput = 0; // wrap around Rx ring buffer read pointer
//
if(uart_p->rxput == uart_p->rxget) // if Rx ring buffer full ?
{ //
uart_p->rxget++; // discard oldest character in ring buffer
OS_EXIT_CRITICAL(); // disable interrupt and DO NOT POST SEMAPHORE
return COM_ERR_RXBUF_FULL; // return error - 'Rx ring buffer full'
} //
OSSemPost(uart_p->rxsem); // Post semaphore to user task
OS_EXIT_CRITICAL(); //
//
return COM_NO_ERR; // Return OK
}

/*------------------------------------------------------------------------------------------------------------*
| uart_GetByteIsr() - get byte from transmit buffer to send
|
| Syntax :
| INT8S uart_GetByteIsr(INT8U portid, INT8U *byte)
|
| Arguments :
| INT8U portid
| INT8U *byte
|
| Returns :
| Description :
| The function is called from ISR when hardware completes character transfer on Tx line and ready to
| transmit new character . When porting this code - hardware dependent function must analyse return
| code from this function as follow :
| - If return code is COM_NO_ERR transfer must proceed
| - If return code either COM_ERR_PORT_CLOSED or COM_ERR_TXBUF_EMPTY transfer must be stopped
| and Transmit interrupts must be disabled .
|
*------------------------------------------------------------------------------------------------------------*/
INT8S uart_GetByteIsr(INT8U portid, INT8U *byte)
{
#if OS_CRITICAL_METHOD == 3 // Allocate storage for CPU status register
OS_CPU_SR cpu_sr; //
#endif //
uart_uart *uart_p; // pointer to uart data structure
//
uart_p = &uartbuf[portid]; // select port data
//
if(uart_p->state == UART_STATE_CLOSE) // if port is not opened
return COM_ERR_PORT_CLOSED; // return error - 'attempt to use closed port'
// Fetch byte from TX buffer
if(uart_p->txget != uart_p->txput) // If TX buffer IS NOT EMPTY
{ //
OS_ENTER_CRITICAL(); // Disable interrupts
*byte = uart_p->txbuf[uart_p->txget]; // Get character from Tx ring buffer
if(++(uart_p->txget) == UART_TXBUF_SIZE) // Increment read pointer
uart_p->txget = 0; //
OS_EXIT_CRITICAL(); // Enable interrupts
OSSemPost(uart_p->txsem); // Post TX semaphore
} //
else // Else if Tx buffer is EMPTY
{ //
uart_p->txstate = UART_TX_STATE_OFF; // set transimt state to passive
return COM_ERR_TXBUF_EMPTY; // and report error - 'tx ring buffer empty'
} //
return COM_NO_ERR; //
}

/********************************************************************************
******************************
* . SECTIONS END
********************************************************************************
******************************/

тоже добавлю
http://www.procyonengineering.com/

Эта ссылка тоже на AVRlib.
Насколько я понял, этот AVRlib не годится для IAR, т.к. в его сырцах ссылки на отстуствующие в IAR заголовки. Можно ли побороть эту проблему или лучше найти специализированную библиотеку подобного типа для IAR?

Но вопос ведь темы WINAvr или IAR? или уже ИАР?

Спасибо за
http://ccrma.stanford.edu/courses/250a/docs/avrlib/main.html

Но всетаки хотелось бы подобную библиотеку для ИАР!!!
Можно конечно править эту. Так и делаю пока. Просто достало уже.
Неужели таких для ИАР несуществует в мире?!!!

Поделитесь пожалуйста люди добрыи, кто чем сможет!
Можно даже сборную такую библиотечку собрать, типа с миру по нитке...

Сообщение отредактировал Waso - Dec 17 2005, 20:11