WINAvr или IAR?, для тех, кто работал в обеих средах. Опции

[Karl]

Программирую в WinAvr. Собираюсь попробовать написать новый проект на IAR. В связи с этим вопрос: стоит ли тратить время и силы на освоение IAR? Кто какие плюсы и минусы видит в той или иной среде?

[_artem_]

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
********************************************************************************
******************************/