[lazycamel 0]

Есть ли программные эмуляторы HD44780 для IAR или AVRStudio?

Нужен такой плагин, т.к. у меня нет возможности проверить вывод на lcd на реальном железе.

<{POST_SNAPBACK}>

 

Эмулятор VMLAB.

Насколько я в курсе WinAVR/GCC он поддерживает.

Правда надо менять тип дебаговой информации для объектныъ модулей.

[m16 0]

Есть ли программные эмуляторы HD44780 для IAR или AVRStudio?

Нужен такой плагин, т.к. у меня нет возможности проверить вывод на lcd на реальном железе.

<{POST_SNAPBACK}>

 

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

 

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

hapsim.rar

[ROC 0]

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

 

Есть в природе 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

[1891ВМ12Я 0]

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

[_artem_ 0]

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

********************************************************************************

******************************/

[INT1 0]

тоже добавлю :)

http://www.procyonengineering.com/

[1891ВМ12Я 0]

тоже добавлю :)

http://www.procyonengineering.com/

<{POST_SNAPBACK}>

Эта ссылка тоже на AVRlib.

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

[INT1 0]

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

[Waso 1]

Спасибо за

http://ccrma.stanford.edu/courses/250a/docs/avrlib/main.html

 

Но всетаки хотелось бы подобную библиотеку для ИАР!!!

Можно конечно править эту. Так и делаю пока. Просто достало уже.

Неужели таких для ИАР несуществует в мире?!!!

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

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

Изменено 17 декабря, 2005 пользователем Waso