buffer.s90

Wind sensor for control speed air flow.

//////////////////////////////////////////////////////////////////////////////
//                                                                           /
//                                                     14/Nov/2007  16:06:18 /
// IAR Atmel AVR C/C++ Compiler V4.12A/W32, Evaluation Version               /
// Copyright 1996-2005 IAR Systems. All rights reserved.                     /
//                                                                           /
//    Source file  =  D:\Work\Devices\WindSensor\Software\buffer.c           /
//    Command line =  D:\Work\Devices\WindSensor\Software\buffer.c --cpu=m8  /
//                    -ms -o D:\Work\Devices\WindSensor\Software\Debug\Obj\  /
//                    -lB D:\Work\Devices\WindSensor\Software\Debug\List\    /
//                    --initializers_in_flash --version1_calls -s2 --no_cse  /
//                    --no_inline --no_code_motion --no_cross_call           /
//                    --no_clustering --no_tbaa --debug                      /
//                    -DENABLE_BIT_DEFINITIONS -e -I "C:\Program Files\IAR   /
//                    Systems\Embedded Workbench 4.0 Evaluation\avr\INC\"    /
//                    -I "C:\Program Files\IAR Systems\Embedded Workbench    /
//                    4.0 Evaluation\avr\INC\CLIB\" --eeprom_size 512        /
//    List file    =  D:\Work\Devices\WindSensor\Software\Debug\List\buffer. /
//                    s90                                                    /
//                                                                           /
//                                                                           /
//////////////////////////////////////////////////////////////////////////////

        NAME buffer

        RSEG CSTACK:DATA:NOROOT(0)
        RSEG RSTACK:DATA:NOROOT(0)

        EXTERN ?Register_R4_is_cg_reg
        EXTERN ?Register_R5_is_cg_reg

        PUBWEAK __?EEARH
        PUBWEAK __?EEARL
        PUBWEAK __?EECR
        PUBWEAK __?EEDR
        PUBLIC buInitBuffer
        PUBLIC buIsBufferEmpty
        PUBLIC buIsBufferFull
        PUBLIC buReadByte
        PUBLIC buWriteByte
        PUBLIC ibuNextIndex

// D:\Work\Devices\WindSensor\Software\buffer.c
//    1 /*
//    2    buffer.c - Simple implementation of a circular buffer.
//    3    */
//    4 #include "buffer.h"
//    5 // ibuNextIndex() - Internal buffer function.  Returns the next value
//    6 // for the head/tail values.

        RSEG CODE:CODE:NOROOT(1)
//    7 unsigned char ibuNextIndex(unsigned char nCurrentValue)
ibuNextIndex:
//    8 { nCurrentValue++;
        INC	R16
//    9   if(nCurrentValue == CIRCULAR_BUFFER_SIZE) nCurrentValue = 0;
        CPI	R16, 8
        BRNE	??ibuNextIndex_0
        LDI	R16, 0
//   10   return nCurrentValue;
??ibuNextIndex_0:
        RET
//   11 }
//   12 // buInitBuffer() - Initialises a provided circular buffer

        RSEG CODE:CODE:NOROOT(1)
//   13 void buInitBuffer(pbsCircBuffer pBuffer)
buInitBuffer:
//   14 { pBuffer->nHeadIndex = 0;
        LDI	R18, 0
        MOVW	R31:R30, R17:R16
        STD	Z+8, R18
//   15   pBuffer->nTailIndex = 0;
        LDI	R18, 0
        MOVW	R31:R30, R17:R16
        STD	Z+9, R18
//   16 }
        RET
//   17 // buWriteByte() - Write a byte to the buffer, if possible.
//   18 // Returns:
//   19 //   0 - success
//   20 // else - failed (buffer is full)

        RSEG CODE:CODE:NOROOT(1)
//   21 unsigned char buWriteByte(pbsCircBuffer pBuffer, unsigned char nData)
buWriteByte:
//   22 { unsigned char nHeadIndex, nNewIndex;
        ST	-Y, R5
        ST	-Y, R4
        ST	-Y, R27
        ST	-Y, R26
        ST	-Y, R25
        ST	-Y, R24
        REQUIRE	?Register_R4_is_cg_reg
        REQUIRE	?Register_R5_is_cg_reg
        MOVW	R27:R26, R17:R16
        MOV	R24, R20
//   23   nHeadIndex = pBuffer->nHeadIndex;
        MOVW	R31:R30, R27:R26
        LDD	R16, Z+8
        MOV	R4, R16
//   24   nNewIndex = ibuNextIndex(nHeadIndex);
        MOV	R16, R4
        RCALL	ibuNextIndex
        MOV	R25, R16
//   25   if(nNewIndex == pBuffer->nTailIndex) return 1;
        MOVW	R31:R30, R27:R26
        LDD	R16, Z+9
        CP	R25, R16
        BRNE	??buWriteByte_0
        LDI	R16, 1
        RJMP	??buWriteByte_1
//   26   pBuffer->nBuffer[nHeadIndex] = nData;
??buWriteByte_0:
        CLR	R5
        MOVW	R31:R30, R27:R26
        ADD	R30, R4
        ADC	R31, R5
        ST	Z, R24
//   27   pBuffer->nHeadIndex = nNewIndex;
        MOVW	R31:R30, R27:R26
        STD	Z+8, R25
//   28   return 0;
        LDI	R16, 0
??buWriteByte_1:
        LD	R24, Y+
        LD	R25, Y+
        LD	R26, Y+
        LD	R27, Y+
        LD	R4, Y+
        LD	R5, Y+
        RET
//   29 }
//   30 // buReadByte() - Reads a byte from the buffer if possible.
//   31 // Returns:
//   32 //   The byte from the buffer
//   33 // NOTE:
//   34 //   * If a previous call to buGetBytesUsed() returns 0, then this function
//   35 // will return 0, which may not be distinguishable from actual data in the
//   36 // buffer.

        RSEG CODE:CODE:NOROOT(1)
//   37 unsigned char buReadByte(pbsCircBuffer pBuffer)
buReadByte:
//   38 { unsigned char nTailIndex, nReadByte;
        ST	-Y, R4
        ST	-Y, R27
        ST	-Y, R26
        ST	-Y, R25
        ST	-Y, R24
        REQUIRE	?Register_R4_is_cg_reg
        MOVW	R27:R26, R17:R16
//   39   nTailIndex = pBuffer->nTailIndex;
        MOVW	R31:R30, R27:R26
        LDD	R16, Z+9
        MOV	R24, R16
//   40   if(nTailIndex == pBuffer->nHeadIndex) return 0;
        MOVW	R31:R30, R27:R26
        LDD	R16, Z+8
        CP	R24, R16
        BRNE	??buReadByte_0
        LDI	R16, 0
        RJMP	??buReadByte_1
//   41   nReadByte = pBuffer->nBuffer[nTailIndex];
??buReadByte_0:
        LDI	R25, 0
        MOVW	R31:R30, R27:R26
        ADD	R30, R24
        ADC	R31, R25
        LD	R16, Z
        MOV	R4, R16
//   42   nTailIndex = ibuNextIndex(nTailIndex);
        MOV	R16, R24
        RCALL	ibuNextIndex
        MOV	R24, R16
//   43   pBuffer->nTailIndex = nTailIndex;
        MOVW	R31:R30, R27:R26
        STD	Z+9, R24
//   44   return nReadByte;
        MOV	R16, R4
??buReadByte_1:
        LD	R24, Y+
        LD	R25, Y+
        LD	R26, Y+
        LD	R27, Y+
        LD	R4, Y+
        RET
//   45 }
//   46 // buIsBufferEmpty() - Indicates whether or not the buffer is empty.
//   47 //   pBuffer - The buffer to look at
//   48 // Returns:
//   49 //   zero - Not empty
//   50 // non-zero - Empty buffer

        RSEG CODE:CODE:NOROOT(1)
//   51 unsigned char buIsBufferEmpty(pbsCircBuffer pBuffer)
buIsBufferEmpty:
//   52 { return ((pBuffer->nHeadIndex == pBuffer->nTailIndex) ? 1 : 0);
        MOVW	R31:R30, R17:R16
        LDD	R18, Z+8
        MOVW	R31:R30, R17:R16
        LDD	R16, Z+9
        CP	R18, R16
        BRNE	??buIsBufferEmpty_0
        LDI	R16, 1
        RET
??buIsBufferEmpty_0:
        LDI	R16, 0
        RET
//   53 }
//   54 
//   55 // buIsBufferFull() - Indicates whether or not the buffer is full
//   56 //   pBuffer - The buffer in question
//   57 // Returns:
//   58 //   zero - Buffer is not full
//   59 // non-zero - Buffer is full

        RSEG CODE:CODE:NOROOT(1)
//   60 unsigned char buIsBufferFull(pbsCircBuffer pBuffer)
buIsBufferFull:
//   61 { unsigned char nNewHead;
        ST	-Y, R27
        ST	-Y, R26
        ST	-Y, R24
        MOVW	R27:R26, R17:R16
//   62   nNewHead = ibuNextIndex(pBuffer->nHeadIndex);
        ADIW	R27:R26, 8
        LD	R16, X
        SBIW	R27:R26, 8
        RCALL	ibuNextIndex
        MOV	R24, R16
//   63   return ((nNewHead == pBuffer->nTailIndex) ? 1 : 0);
        ADIW	R27:R26, 9
        LD	R16, X
        CP	R24, R16
        BRNE	??buIsBufferFull_0
        LDI	R16, 1
        RJMP	??buIsBufferFull_1
??buIsBufferFull_0:
        LDI	R16, 0
??buIsBufferFull_1:
        LD	R24, Y+
        LD	R26, Y+
        LD	R27, Y+
        RET
//   64 }

        ASEGN ABSOLUTE:DATA:NOROOT,01cH
__?EECR:

        ASEGN ABSOLUTE:DATA:NOROOT,01dH
__?EEDR:

        ASEGN ABSOLUTE:DATA:NOROOT,01eH
__?EEARL:

        ASEGN ABSOLUTE:DATA:NOROOT,01fH
__?EEARH:

        END
//   65 
// 
// 220 bytes in segment CODE
// 
// 220 bytes of CODE memory
//
//Errors: none
//Warnings: none