ucosii.lst

ucos如何移植到单片机mega128

    039A 8C0A      LDD	R0,Y+26
    039B 20A0      AND	R10,R0
(0462)              if (flags_rdy != (OS_FLAGS)0) {               /* See if any flag cleared                  */
    039C F0A1      BEQ	0x03B1
(0463)                  if (consume == TRUE) {                    /* See if we need to consume the flags      */
    039D 2D8E      MOV	R24,R14
    039E 3081      CPI	R24,1
    039F F431      BNE	0x03A6
(0464)                      pgrp->OSFlagFlags |= flags_rdy;       /* Set ONLY the flags that we got           */
    03A0 01C3      MOVW	R24,R6
    03A1 9603      ADIW	R24,3
    03A2 01FC      MOVW	R30,R24
    03A3 8040      LDD	R4,Z+0
    03A4 284A      OR	R4,R10
    03A5 8240      STD	Z+0,R4
(0465)                  }
(0466)                  flags_cur = pgrp->OSFlagFlags;            /* Will return the state of the group       */
    03A6 01F3      MOVW	R30,R6
    03A7 8143      LDD	R20,Z+3
(0467)                  OS_EXIT_CRITICAL();                       /* Yes, condition met, return to caller     */
    03A8 930A      ST	R16,-Y
    03A9 910F      POP	R16
    03AA BF0F      OUT	0x3F,R16
    03AB 9109      LD	R16,Y+
(0468)                  *err      = OS_NO_ERR;
    03AC 2422      CLR	R2
    03AD 01FB      MOVW	R30,R22
    03AE 8220      STD	Z+0,R2
(0469)                  return (flags_cur);
    03AF 2F04      MOV	R16,R20
    03B0 C081      RJMP	0x0432
(0470)              } else {                                      /* Block task until events occur or timeout */
(0471)                  OS_FlagBlock(pgrp, &node, flags, wait_type, timeout);
    03B1 8C0E      LDD	R0,Y+30
    03B2 8C1F      LDD	R1,Y+31
    03B3 821D      STD	Y+5,R1
    03B4 820C      STD	Y+4,R0
    03B5 82CA      STD	Y+2,R12
    03B6 8C0A      LDD	R0,Y+26
    03B7 8208      STD	Y+0,R0
    03B8 019E      MOVW	R18,R28
    03B9 5F2A      SUBI	R18,0xFA
    03BA 4F3F      SBCI	R19,0xFF
    03BB 0183      MOVW	R16,R6
    03BC 930F      PUSH	R16
    03BD 931F      PUSH	R17
    03BE D16D      RCALL	_OS_FlagBlock
    03BF 907F      POP	R7
    03C0 906F      POP	R6
(0472)                  OS_EXIT_CRITICAL();
    03C1 930A      ST	R16,-Y
    03C2 910F      POP	R16
    03C3 BF0F      OUT	0x3F,R16
    03C4 9109      LD	R16,Y+
(0473)              }
(0474)              break;
    03C5 C00A      RJMP	0x03D0
(0475) #endif
(0476) 
(0477)         default:
(0478)              OS_EXIT_CRITICAL();
    03C6 930A      ST	R16,-Y
    03C7 910F      POP	R16
    03C8 BF0F      OUT	0x3F,R16
    03C9 9109      LD	R16,Y+
(0479)              flags_cur = (OS_FLAGS)0;
    03CA 2744      CLR	R20
(0480)              *err      = OS_FLAG_ERR_WAIT_TYPE;
    03CB E987      LDI	R24,0x97
    03CC 01FB      MOVW	R30,R22
    03CD 8380      STD	Z+0,R24
(0481)              return (flags_cur);
    03CE 2F04      MOV	R16,R20
    03CF C062      RJMP	0x0432
(0482)     }
(0483)     OS_Sched();                                            /* Find next HPT ready to run               */
    03D0 926F      PUSH	R6
    03D1 927F      PUSH	R7
    03D2 940E0A51  CALL	_OS_Sched
    03D4 907F      POP	R7
    03D5 906F      POP	R6
(0484)     OS_ENTER_CRITICAL();
    03D6 930A      ST	R16,-Y
    03D7 B70F      IN	R16,0x3F
    03D8 94F8      BCLR	7
    03D9 930F      PUSH	R16
    03DA 9109      LD	R16,Y+
(0485)     if (OSTCBCur->OSTCBStat & OS_STAT_FLAG) {              /* Have we timed-out?                       */
    03DB 91E0029C  LDS	R30,OSTCBCur
    03DD 91F0029D  LDS	R31,OSTCBCur+1
    03DF 8423      LDD	R2,Z+11
    03E0 FE25      SBRS	R2,5
    03E1 C017      RJMP	0x03F9
(0486)         OS_FlagUnlink(&node);
    03E2 018E      MOVW	R16,R28
    03E3 5F0A      SUBI	R16,0xFA
    03E4 4F1F      SBCI	R17,0xFF
    03E5 926F      PUSH	R6
    03E6 927F      PUSH	R7
    03E7 D1FB      RCALL	_OS_FlagUnlink
    03E8 907F      POP	R7
    03E9 906F      POP	R6
(0487)         OSTCBCur->OSTCBStat = OS_STAT_RDY;                 /* Yes, make task ready-to-run              */
    03EA 2422      CLR	R2
    03EB 91E0029C  LDS	R30,OSTCBCur
    03ED 91F0029D  LDS	R31,OSTCBCur+1
    03EF 8623      STD	Z+11,R2
(0488)         OS_EXIT_CRITICAL();
    03F0 930A      ST	R16,-Y
    03F1 910F      POP	R16
    03F2 BF0F      OUT	0x3F,R16
    03F3 9109      LD	R16,Y+
(0489)         flags_cur           = (OS_FLAGS)0;
    03F4 2744      CLR	R20
(0490)         *err                = OS_TIMEOUT;                  /* Indicate that we timed-out waiting       */
    03F5 E08A      LDI	R24,0xA
    03F6 01FB      MOVW	R30,R22
    03F7 8380      STD	Z+0,R24
(0491)     } else {
    03F8 C038      RJMP	0x0431
(0492)         if (consume == TRUE) {                             /* See if we need to consume the flags      */
    03F9 2D8E      MOV	R24,R14
    03FA 3081      CPI	R24,1
    03FB F009      BEQ	0x03FD
    03FC C02B      RJMP	0x0428
(0493)             switch (wait_type) {
    03FD 24DD      CLR	R13
    03FE 20CC      TST	R12
    03FF F411      BNE	0x0402
    0400 20DD      TST	R13
    0401 F0D9      BEQ	0x041D
    0402 01C6      MOVW	R24,R12
    0403 3081      CPI	R24,1
    0404 E0E0      LDI	R30,0
    0405 079E      CPC	R25,R30
    0406 F0B1      BEQ	0x041D
    0407 3082      CPI	R24,2
    0408 E0E0      LDI	R30,0
    0409 079E      CPC	R25,R30
    040A F029      BEQ	0x0410
    040B 3083      CPI	R24,3
    040C E0E0      LDI	R30,0
    040D 079E      CPC	R25,R30
    040E F009      BEQ	0x0410
    040F C018      RJMP	0x0428
(0494)                 case OS_FLAG_WAIT_SET_ALL:
(0495)                 case OS_FLAG_WAIT_SET_ANY:                 /* Clear ONLY the flags we got              */
(0496)                      pgrp->OSFlagFlags &= ~OSTCBCur->OSTCBFlagsRdy;
    0410 01C3      MOVW	R24,R6
    0411 9603      ADIW	R24,3
    0412 91E0029C  LDS	R30,OSTCBCur
    0414 91F0029D  LDS	R31,OSTCBCur+1
    0416 8440      LDD	R4,Z+8
    0417 9440      COM	R4
    0418 01FC      MOVW	R30,R24
    0419 8050      LDD	R5,Z+0
    041A 2054      AND	R5,R4
    041B 8250      STD	Z+0,R5
(0497)                      break;
    041C C00B      RJMP	0x0428
(0498) 
(0499) #if OS_FLAG_WAIT_CLR_EN > 0
(0500)                 case OS_FLAG_WAIT_CLR_ALL:
(0501)                 case OS_FLAG_WAIT_CLR_ANY:                 /* Set   ONLY the flags we got              */
(0502)                      pgrp->OSFlagFlags |= OSTCBCur->OSTCBFlagsRdy;
    041D 01C3      MOVW	R24,R6
    041E 9603      ADIW	R24,3
    041F 91E0029C  LDS	R30,OSTCBCur
    0421 91F0029D  LDS	R31,OSTCBCur+1
    0423 8440      LDD	R4,Z+8
    0424 01FC      MOVW	R30,R24
    0425 8050      LDD	R5,Z+0
    0426 2854      OR	R5,R4
    0427 8250      STD	Z+0,R5
(0503)                      break;
(0504) #endif
(0505)             }
(0506)         }
(0507)         flags_cur = pgrp->OSFlagFlags;
    0428 01F3      MOVW	R30,R6
    0429 8143      LDD	R20,Z+3
(0508)         OS_EXIT_CRITICAL();
    042A 930A      ST	R16,-Y
    042B 910F      POP	R16
    042C BF0F      OUT	0x3F,R16
    042D 9109      LD	R16,Y+
(0509)         *err      = OS_NO_ERR;                             /* Event(s) must have occurred              */
    042E 2422      CLR	R2
    042F 01FB      MOVW	R30,R22
    0430 8220      STD	Z+0,R2
(0510)     }
(0511)     return (flags_cur);
    0431 2F04      MOV	R16,R20
    0432 9660      ADIW	R28,0x10
    0433 940E0DD7  CALL	pop_gset5
    0435 9622      ADIW	R28,2
    0436 9508      RET
_OSFlagPost:
  flags_cur            --> R20
  sched                --> R14
  flags_rdy            --> R10
  pnode                --> R12
  err                  --> R22
  opt                  --> Y+14
  flags                --> R20
  pgrp                 --> Y+10
    0437 940E0DC9  CALL	push_arg4
    0439 940E0DDA  CALL	push_gset5
    043B 2F42      MOV	R20,R18
    043C 8968      LDD	R22,Y+16
    043D 8979      LDD	R23,Y+17
(0512) }
(0513) /*$PAGE*/
(0514) /*
(0515) *********************************************************************************************************
(0516) *                                         POST EVENT FLAG BIT(S)
(0517) *
(0518) * Description: This function is called to set or clear some bits in an event flag group.  The bits to
(0519) *              set or clear are specified by a 'bit mask'.
(0520) *
(0521) * Arguments  : pgrp          is a pointer to the desired event flag group.
(0522) *
(0523) *              flags         If 'opt' (see below) is OS_FLAG_SET, each bit that is set in 'flags' will
(0524) *                            set the corresponding bit in the event flag group.  e.g. to set bits 0, 4
(0525) *                            and 5 you would set 'flags' to:
(0526) *
(0527) *                                0x31     (note, bit 0 is least significant bit)
(0528) *
(0529) *                            If 'opt' (see below) is OS_FLAG_CLR, each bit that is set in 'flags' will
(0530) *                            CLEAR the corresponding bit in the event flag group.  e.g. to clear bits 0,
(0531) *                            4 and 5 you would specify 'flags' as:
(0532) *
(0533) *                                0x31     (note, bit 0 is least significant bit)
(0534) *
(0535) *              opt           indicates whether the flags will be:
(0536) *                                set     (OS_FLAG_SET) or
(0537) *                                cleared (OS_FLAG_CLR)
(0538) *
(0539) *              err           is a pointer to an error code and can be:
(0540) *                            OS_NO_ERR              The call was successfull
(0541) *                            OS_FLAG_INVALID_PGRP   You passed a NULL pointer
(0542) *                            OS_ERR_EVENT_TYPE      You are not pointing to an event flag group
(0543) *                            OS_FLAG_INVALID_OPT    You specified an invalid option
(0544) *
(0545) * Returns    : the new value of the event flags bits that are still set.
(0546) *
(0547) * Called From: Task or ISR
(0548) *
(0549) * WARNING(s) : 1) The execution time of this function depends on the number of tasks waiting on the event
(0550) *                 flag group.
(0551) *              2) The amount of time interrupts are DISABLED depends on the number of tasks waiting on
(0552) *                 the event flag group.
(0553) *********************************************************************************************************
(0554) */
(0555) OS_FLAGS  OSFlagPost (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U opt, INT8U *err)
(0556) {
(0557) #if OS_CRITICAL_METHOD == 3                          /* Allocate storage for CPU status register       */
(0558)     OS_CPU_SR     cpu_sr;
(0559) #endif
(0560)     OS_FLAG_NODE *pnode;
(0561)     BOOLEAN       sched;
(0562)     OS_FLAGS      flags_cur;
(0563)     OS_FLAGS      flags_rdy;
(0564) 
(0565) 
(0566) #if OS_ARG_CHK_EN > 0
(0567)     if (pgrp == (OS_FLAG_GRP *)0) {                  /* Validate 'pgrp'                                */
    043E 840A      LDD	R0,Y+10
    043F 841B      LDD	R1,Y+11
    0440 2000      TST	R0
    0441 F439      BNE	0x0449
    0442 2011      TST	R1
    0443 F429      BNE	0x0449
(0568)         *err = OS_FLAG_INVALID_PGRP;
    0444 E986      LDI	R24,0x96
    0445 01FB      MOVW	R30,R22
    0446 8380      STD	Z+0,R24
(0569)         return ((OS_FLAGS)0);
    0447 2700      CLR	R16
    0448 C0BA      RJMP	0x0503
(0570)     }
(0571)     if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {    /* Make sure we are pointing to an event flag grp */
    0449 85EA      LDD	R30,Y+10
    044A 85FB      LDD	R31,Y+11
    044B 8180      LDD	R24,Z+0
    044C 3085      CPI	R24,5
    044D F029      BEQ	0x0453
(0572)         *err = OS_ERR_EVENT_TYPE;
    044E E081      LDI	R24,1
    044F 01FB      MOVW	R30,R22
    0450 8380      STD	Z+0,R24
(0573)         return ((OS_FLAGS)0);
    0451 2700      CLR	R16
    0452 C0B0      RJMP	0x0503
(0574)     }
(0575) #endif
(0576) /*$PAGE*/
(0577)     OS_ENTER_CRITICAL();
    0453 930A      ST	R16,-Y
    0454 B70F      IN	R16,0x3F
    0455 94F8      BCLR	7
    0456 930F      PUSH	R16
    0457 9109      LD	R16,Y+
(0578)     switch (opt) {
    0458 84AE      LDD	R10,Y+14
    0459 24BB      CLR	R11
    045A 20AA      TST	R10
    045B F411      BNE	0x045E
    045C 20BB      TST	R11
    045D F031      BEQ	0x0464
    045E 01C5      MOVW	R24,R10
    045F 3081      CPI	R24,1
    046