📄 hal_uart.lst
字号:
785 else
786 {
787 cfg->rxTick = 0;
788 }
789
790 #if HAL_UART_ISR
791 #if HAL_UART_DMA
792 if ( cfg->flag & UART_CFG_DMA )
793 {
794 pollDMA( cfg );
795 }
796 else
797 #endif
798 {
799 pollISR( cfg );
800 }
801 #elif HAL_UART_DMA
802 pollDMA( cfg );
803 #endif
804
805 /* The following logic makes continuous callbacks on any eligible flag
806 * until the condition corresponding to the flag is rectified.
807 * So even if new data is not received, continuous callbacks are made.
808 */
809 if ( cfg->rxHead != cfg->rxTail )
810 {
811 uint8 evt;
812
813 if ( cfg->rxHead >= (cfg->rxMax - SAFE_RX_MIN) )
814 {
815 evt = HAL_UART_RX_FULL;
816 }
817 else if ( cfg->rxHigh && (cfg->rxHead >= cfg->rxHigh) )
818 {
819 evt = HAL_UART_RX_ABOUT_FULL;
820 }
821 else if ( cfg->rxTick == 0 )
822 {
823 evt = HAL_UART_RX_TIMEOUT;
824 }
825 else
826 {
827 evt = 0;
828 }
829
830 if ( evt && cfg->rxCB )
831 {
832 cfg->rxCB( ((cfg->flag & UART_CFG_U1F)!=0), evt );
833 }
834 }
835
836 #if HAL_UART_0_ENABLE
837 if ( cfg == cfg0 )
838 {
839 #if HAL_UART_1_ENABLE
840 if ( cfg1 )
841 {
842 cfg = cfg1;
843 }
844 else
845 #endif
846 break;
847 }
848 else
849 #endif
850 break;
851
852 } while ( TRUE );
853 #else
854 return;
\ 000000 02.... LJMP ?BRET
855 #endif
856 }
857
858 /**************************************************************************************************
859 * @fn Hal_UART_RxBufLen()
860 *
861 * @brief Calculate Rx Buffer length - the number of bytes in the buffer.
862 *
863 * @param port - UART port
864 *
865 * @return length of current Rx Buffer
866 **************************************************************************************************/
\ In segment BANKED_CODE, align 1, keep-with-next
867 uint16 Hal_UART_RxBufLen( uint8 port )
\ Hal_UART_RxBufLen:
868 {
\ 000000 C082 PUSH DPL
\ 000002 C083 PUSH DPH
\ 000004 ; Saved register size: 2
\ 000004 ; Auto size: 0
869 uartCfg_t *cfg = NULL;
870
871 #if HAL_UART_0_ENABLE
872 if ( port == HAL_UART_PORT_0 )
873 {
874 cfg = cfg0;
875 }
876 #endif
877 #if HAL_UART_1_ENABLE
878 if ( port == HAL_UART_PORT_1 )
879 {
880 cfg = cfg1;
881 }
882 #endif
883
884 HAL_UART_ASSERT( cfg );
885
886 return UART_RX_AVAIL( cfg );
\ 000004 900002 MOV DPTR,#0x2
\ 000007 E0 MOVX A,@DPTR
\ 000008 C0E0 PUSH A
\ 00000A 900003 MOV DPTR,#0x3
\ 00000D E0 MOVX A,@DPTR
\ 00000E FA MOV R2,A
\ 00000F D0E0 POP A
\ 000011 C3 CLR C
\ 000012 9A SUBB A,R2
\ 000013 400C JC ??Hal_UART_RxBufLen_0
\ 000015 900002 MOV DPTR,#0x2
\ 000018 E0 MOVX A,@DPTR
\ 000019 C3 CLR C
\ 00001A 9A SUBB A,R2
\ 00001B FA MOV R2,A
\ 00001C E4 CLR A
\ 00001D 9400 SUBB A,#0x0
\ 00001F 801A SJMP ??Hal_UART_RxBufLen_1
\ ??Hal_UART_RxBufLen_0:
\ 000021 900004 MOV DPTR,#0x4
\ 000024 E0 MOVX A,@DPTR
\ 000025 C3 CLR C
\ 000026 9A SUBB A,R2
\ 000027 F8 MOV R0,A
\ 000028 E4 CLR A
\ 000029 9400 SUBB A,#0x0
\ 00002B F9 MOV R1,A
\ 00002C 900002 MOV DPTR,#0x2
\ 00002F E0 MOVX A,@DPTR
\ 000030 28 ADD A,R0
\ 000031 F8 MOV R0,A
\ 000032 E4 CLR A
\ 000033 39 ADDC A,R1
\ 000034 F9 MOV R1,A
\ 000035 7401 MOV A,#0x1
\ 000037 28 ADD A,R0
\ 000038 FA MOV R2,A
\ 000039 E4 CLR A
\ 00003A 39 ADDC A,R1
\ ??Hal_UART_RxBufLen_1:
\ 00003B FB MOV R3,A
\ 00003C D083 POP DPH
\ 00003E D082 POP DPL
\ 000040 02.... LJMP ?BRET
887 }
888
889 /*****************************************************************************
890 * @fn HalUARTRead
891 *
892 * @brief Read a buffer from the UART
893 *
894 * @param port - USART module designation
895 * buf - valid data buffer at least 'len' bytes in size
896 * len - max length number of bytes to copy to 'buf'
897 *
898 * @return length of buffer that was read
899 *****************************************************************************/
\ In segment BANKED_CODE, align 1, keep-with-next
900 uint16 HalUARTRead( uint8 port, uint8 *buf, uint16 len )
\ HalUARTRead:
901 {
\ 000000 74F6 MOV A,#-0xa
\ 000002 12.... LCALL ?BANKED_ENTER_XDATA
\ 000005 ; Saved register size: 10
\ 000005 ; Auto size: 0
902 uartCfg_t *cfg = NULL;
903 uint8 cnt = 0;
\ 000005 7F00 MOV R7,#0x0
\ 000007 8007 SJMP ??HalUARTRead_0
904
905 #if HAL_UART_0_ENABLE
906 if ( port == HAL_UART_PORT_0 )
907 {
908 cfg = cfg0;
909 }
910 #endif
911 #if HAL_UART_1_ENABLE
912 if ( port == HAL_UART_PORT_1 )
913 {
914 cfg = cfg1;
915 }
916 #endif
917
918 HAL_UART_ASSERT( cfg );
919
920 while ( (cfg->rxTail != cfg->rxHead) && (cnt < len) )
921 {
922 *buf++ = cfg->rxBuf[cfg->rxTail];
923 if ( cfg->rxTail == cfg->rxMax )
924 {
925 cfg->rxTail = 0;
926 }
927 else
928 {
929 cfg->rxTail++;
\ ??HalUARTRead_1:
\ 000009 900003 MOV DPTR,#0x3
\ 00000C E0 MOVX A,@DPTR
\ 00000D 04 INC A
\ ??HalUARTRead_2:
\ 00000E F0 MOVX @DPTR,A
930 }
931 cnt++;
\ 00000F 0F INC R7
\ ??HalUARTRead_0:
\ 000010 900003 MOV DPTR,#0x3
\ 000013 E0 MOVX A,@DPTR
\ 000014 FE MOV R6,A
\ 000015 900002 MOV DPTR,#0x2
\ 000018 E0 MOVX A,@DPTR
\ 000019 6E XRL A,R6
\ 00001A 6032 JZ ??HalUARTRead_3
\ 00001C 8F.. MOV ?V0 + 0,R7
\ 00001E C3 CLR C
\ 00001F E5.. MOV A,?V0 + 0
\ 000021 9C SUBB A,R4
\ 000022 E4 CLR A
\ 000023 9D SUBB A,R5
\ 000024 5028 JNC ??HalUARTRead_3
\ 000026 900003 MOV DPTR,#0x3
\ 000029 E0 MOVX A,@DPTR
\ 00002A F8 MOV R0,A
\ 00002B 900000 MOV DPTR,#0x0
\ 00002E 12.... LCALL ?Subroutine1 & 0xFFFF
\ ??CrossCallReturnLabel_2:
\ 000031 E0 MOVX A,@DPTR
\ 000032 8A82 MOV DPL,R2
\ 000034 8B83 MOV DPH,R3
\ 000036 F0 MOVX @DPTR,A
\ 000037 A3 INC DPTR
\ 000038 AA82 MOV R2,DPL
\ 00003A AB83 MOV R3,DPH
\ 00003C 900003 MOV DPTR,#0x3
\ 00003F E0 MOVX A,@DPTR
\ 000040 FE MOV R6,A
\ 000041 900004 MOV DPTR,#0x4
\ 000044 E0 MOVX A,@DPTR
\ 000045 6E XRL A,R6
\ 000046 70C1 JNZ ??HalUARTRead_1
\ 000048 E4 CLR A
\ 000049 900003 MOV DPTR,#0x3
\ 00004C 80C0 SJMP ??HalUARTRead_2
932 }
933
934 #if HAL_UART_DMA
935 #if HAL_UART_ISR
936 if ( cfg->flag & UART_CFG_DMA )
937 #endif
938 {
939 /* If there is no flow control on a DMA-driven UART, the Rx Head & Tail
940 * pointers must be reset to zero after every read in order to preserve the
941 * full length of the Rx buffer. This implies that every Read must read all
942 * of the Rx bytes available, or the pointers will not be reset and the
943 * next incoming packet may not fit in the Rx buffer space remaining - thus
944 * the end portion of the incoming packet that does not fit would be lost.
945 */
946 if ( !(cfg->flag & UART_CFG_FLW) )
947 {
948 // This is a trick to trigger the DMA abort and restart logic in pollDMA.
949 cfg->flag |= UART_CFG_RXF;
950 }
951 }
952 #endi⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -