Rigidbody2d Very Innaccurate

I am making a 2d platformer. Currently the player moves through a combination of rigidbody and a custom script, however I have noticed problems with the player's velocity. While not moving, the x velocity will sometimes be very inaccurate, around 5.7 while the player is completely still. The y velocity has similar problems. This is very important as I use both velocities to calculate values for my game. Thanks!

 using UnityEngine;
 using UnityEngine.Events;
 using UnityEngine.UI;
 using UnityEngine.SceneManagement;
 using System.Collections;
 using System.Collections.Generic; 
 
 public class CharacterController2D : MonoBehaviour
 {
     [Range(0, .3f)] 
     public float m_MovementSmoothing = .05f;
     public LayerMask m_WhatIsGround;
     public LayerMask m_WhatIsCeiling;
     public float jumpForce;
     public int jumpDuration;
     public int jumpReleaseForce;
     public float baseMass;
     public float slideSpeed;
     public float wallJumpForce;
     public int wallJumpDuration;
     public float finalWallJumpForce;
     public float wallJumpSideMultiplier;
 
     //[HideInInspector]
     public bool m_Grounded;
     [HideInInspector]
     public Rigidbody2D m_Rigidbody2D;
     [HideInInspector]
     public bool frozen;
     [HideInInspector]
     public bool wallJump;
     [HideInInspector]
     public Transform currentWeapon;
 
     bool stick;
     bool m_FacingRight;
     bool m_FacingRightLastFrame;
     Transform m_CeilingCheck;
     AnimationManager animationManager;
     Transform m_GroundCheck;
     Vector3 m_Velocity = Vector3.zero;
     int i;
     int n;
     bool isPressed;
     bool jumpingAndReleased;
     bool wasGrounded;
     public bool isJumping;
     float velocityLastFrame;
     bool wallPairedLeft;
     bool wallPairedRight;
     bool walledLastFrame;
     bool isWallJumping;
     WeaponsManager wm;
 
     bool wallTouch;
     bool wallPush;
     float move;
     bool jump;
 
     //Jump Queuing
     public int jumpQueueLength;
     [SerializeField]
     bool jumpQueued;
     int jq;
 
     //Coyote Time
     public int coyoteTimeLength;
     bool coyoteFloating;
     int ct;
 
     const float k_CeilingRadius = .2f; 
     const float k_GroundedRadius = .2f;
 
     private void Awake()
     {
         m_Rigidbody2D = GetComponent<Rigidbody2D>();
         wm = this.gameObject.GetComponent<WeaponsManager>();
         m_CeilingCheck = GameObject.FindWithTag("Ceiling Check").transform;
         m_GroundCheck = GameObject.FindWithTag("Ground Check").transform;
         animationManager = GetComponent<AnimationManager>();
     }
 
     private void FixedUpdate()
     {    
         m_Grounded = false;
 
         Collider2D[] colliders = Physics2D.OverlapCircleAll(m_GroundCheck.position, k_GroundedRadius, m_WhatIsGround);
         for (int i = 0; i < colliders.Length; i++)
         {
             if (colliders[i].gameObject != gameObject)
                 m_Grounded = true;
         }
 
         if (m_Grounded)
         {
             wallPairedLeft = false;
             wallPairedRight = false;
             stick = false;
             isWallJumping = false;
             animationManager.peak = false;
         }
     }
 
     public void Move(float move2, bool crouch2, bool jump2, bool wallPush2, bool wallTouch2)
     {                
         move = move2;
         wallPush = wallPush2;
         wallTouch = wallTouch2;
         jump = jump2;
         
         animationManager.frozen = frozen;
         
         //Setting isPressed to the jump input value
         isPressed = Input.GetButton("Jump");
 
         if (Mathf.Abs(Mathf.Round(m_Rigidbody2D.velocity.x)) > 10f)
             animationManager.isTurning = false;
 
         //Wall jump movement code
         if (wallJump)
         {
             doWallJump();
         }
 
         //Moving the player 
         
         if (!frozen)
         {
             Vector3 targetVelocity = new Vector2(move * 10f, m_Rigidbody2D.velocity.y);
 
             m_Rigidbody2D.velocity = Vector3.SmoothDamp(m_Rigidbody2D.velocity, targetVelocity, ref m_Velocity, m_MovementSmoothing);
 
             if (move > 0 && !m_FacingRight && !animationManager.wallJump)
                 Flip();
             else if (move < 0 && m_FacingRight && !animationManager.wallJump)
                 Flip();
         }
         else
         {
             Vector3 targetVelocity = new Vector2(0f, m_Rigidbody2D.velocity.y);
             m_Rigidbody2D.velocity = Vector3.SmoothDamp(m_Rigidbody2D.velocity, targetVelocity, ref m_Velocity, m_MovementSmoothing);
         }
         
 
         /*
         Presses the jump button;
             If the player is on the ground:
                 Set the animation values
                 Set the jump value
                 Set the grounded value
 
             If the player is in the air:
                 Queue a jump for when the player lands
                 Set the jump queue value to zero
         */
 
         if (jump)
         {
             if (m_Grounded)
             {
                 isJumping = true;
                 i = 0;
                 m_Grounded = false;
                 animationManager.jumping = true;
                 animationManager.launch = true;
                 animationManager.land = false;
             }
             else
             {
                 jumpQueued = true;
                 jq = 0;
             }
 
             if (coyoteFloating && !isJumping)
             {
                 isJumping = true;
                 i = 0;
                 m_Grounded = false;
                 animationManager.jumping = true;
                 animationManager.launch = true;
                 animationManager.land = false;
             }
         }
 
         if (wasGrounded && !m_Grounded)
         {
             coyoteFloating = true;
             ct = 0;
         }
 
         if (coyoteFloating && ct < coyoteTimeLength)
         {
             ct++;
         }
 
         if (ct == coyoteTimeLength)
             coyoteFloating = false;
 
         if (jumpQueued && jq < jumpQueueLength)
         {
             if (m_Grounded)
             {
                 isJumping = true;
                 i = 0;
                 m_Grounded = false;
                 animationManager.jumping = true;
                 animationManager.launch = true;
                 animationManager.land = false;
                 animationManager.peak = false;
             }    
             jq++;
         }
 
         
         if (isJumping && !frozen)
         {    
             doJump();
         }
 
         //Grounded and not jumping
         if (m_Grounded && Mathf.Approximately(m_Rigidbody2D.velocity.y, 0.0f) && !jumpQueued)
         {
             jumpingAndReleased = false;
             isJumping = false;
             animationManager.jumping = false;
             i = 0;
             animationManager.peak = false;
             n = 0;
         }
 
         if (m_Grounded && Mathf.Approximately(m_Rigidbody2D.velocity.y, 0f) && !wasGrounded && !jumpQueued)
             animationManager.land = true;
 
         if (Mathf.Round(m_Rigidbody2D.velocity.x) > 0f && move < 0f)
             animationManager.isTurning = true;
         
         if (Mathf.Round(m_Rigidbody2D.velocity.x) < 0f && move > 0f)
             animationManager.isTurning = true;
         
         if (m_FacingRightLastFrame && move < 0f)
             animationManager.isTurning = true;
 
         if (!m_FacingRightLastFrame && move > 0f)
             animationManager.isTurning = true;
 
         if (Mathf.Abs(Input.GetAxisRaw("Horizontal")) == 0)
             animationManager.isTurning = false;
         
         if (walledLastFrame && !stick && m_Grounded)
             Flip();
 
         walledLastFrame = stick;
         m_FacingRightLastFrame = m_FacingRight;
         wasGrounded = m_Grounded;
 
     }
 
     //For flipping the player
     private void Flip()
     {
         m_FacingRight = !m_FacingRight;
         Vector3 theScale = transform.localScale;
         theScale.x *= -1;
         transform.localScale = theScale;
     }
 
     //For Jumping    
     private void doJump()
     {
         if (jq == jumpQueueLength)
         {
             jq = 0;
             jumpQueued = false;
         }
 
         //Player has hit head on a ceiling; cancel jump
         if (Physics2D.OverlapCircle(m_CeilingCheck.position, k_CeilingRadius, m_WhatIsCeiling))
             i = jumpDuration;
 
         //Let go before peak of jump; Apply final force
         if (!isPressed && i < jumpDuration)
         {
             jumpingAndReleased = true;
             i = jumpDuration;
             m_Rigidbody2D.velocity = new Vector2(m_Rigidbody2D.velocity.x, jumpReleaseForce);
         }
 
         //Being held and less than full jump height; Apply consistant upwards force
         if (isPressed && i < jumpDuration && !jumpingAndReleased)
         {
             m_Rigidbody2D.velocity = new Vector2(m_Rigidbody2D.velocity.x, jumpForce);
             i++;
         }
 
         //If last frame the player was moving up and this frame the player is moving down, we are at the peak
         if (velocityLastFrame > 0f && m_Rigidbody2D.velocity.y <= 0f)
         {
             animationManager.peak = true;
             animationManager.launch = false;
             jumpQueued = false;
         }
 
         velocityLastFrame = m_Rigidbody2D.velocity.y;
     }
 
     private void doWallJump()
     {
         if (!m_Grounded && wallTouch && wallPush)
             stick = true;
 
         if (!wallTouch)
             stick = false;
 
         //Activating the wallSlide values
         if (wallJump)
         {    
             if (stick)
             {    
                 isWallJumping = false;
                 animationManager.wallJump = false;
                 n = 0;
 
                 //Stay paired to the wall when jumping
                 if (!m_FacingRight)
                     wallPairedLeft = true;
 
                 //Stay paired to the wall when jumping
                 if (m_FacingRight)
                     wallPairedRight = true;
 
                 //Check if the player is going up
                 if (m_Rigidbody2D.velocity.y > 0f)
                 {
                     m_Rigidbody2D.velocity = new Vector2(m_Rigidbody2D.velocity.x, 0f);
                 }
 
                 animationManager.slide = true;
 
                 //Jump
                 if (isPressed)
                 {
                     isWallJumping = true;
                     stick = false;
                 }
 
                 //Enact wall sliding
                 else
                 {
                     float wallSlideSpeed = -baseMass * slideSpeed;
                     m_Rigidbody2D.velocity = new Vector2(0, wallSlideSpeed);
                 }
 
                 //Cancels jump if stuck on wall
                 i = jumpDuration;
             }
             else
                 animationManager.slide = false;
 
             //Walljump Code
             if (isWallJumping)
             {    
                 animationManager.wallJump = true;
 
                 //Player releases before peak of the jump; Apply final force
                 if (!isPressed && n < wallJumpDuration)
                 {
                     if (!m_FacingRight)
                         m_Rigidbody2D.velocity = new Vector2(finalWallJumpForce * wallJumpSideMultiplier, finalWallJumpForce);
                     else
                         m_Rigidbody2D.velocity = new Vector2(finalWallJumpForce * -wallJumpSideMultiplier, finalWallJumpForce);
                     animationManager.wallJump = false;    
                     isWallJumping = false;
                     n = wallJumpDuration;
                 }
 
                 //Player is walljumping; Apply consistant upwards force
                 if (n < wallJumpDuration)
                 {
                     if (!m_FacingRight)
                         m_Rigidbody2D.velocity = new Vector2(wallJumpForce * wallJumpSideMultiplier, wallJumpForce);
                     else
                         m_Rigidbody2D.velocity = new Vector2(wallJumpForce * -wallJumpSideMultiplier, wallJumpForce);
                     n++;
                 }
 
                 if (n == wallJumpDuration)
                     animationManager.wallJump = false;
 
                 //Player has hit their head; Cancel jump
                 if (Physics2D.OverlapCircle(m_CeilingCheck.position, k_CeilingRadius, m_WhatIsCeiling))
                     n = wallJumpDuration;
             }
 
             //Pairing the player to the wall
             if (wallPairedLeft && !stick)
             {
                 if (move >= 0)
                 {
                     wallPairedLeft = false;
                     stick = false;
                     animationManager.wallJump = false;
                 }
             }
 
             //Pairing the player to the wall
             if (wallPairedRight && !stick)
             {
                 if (move <= 0)
                 {
                     wallPairedRight = false;
                     stick = false;
                     animationManager.wallJump = false;                        
                 }
             }
 
             if (m_Grounded && !wasGrounded && walledLastFrame)
             {
                 animationManager.slide = false;
                 stick = false;
             }
         }
     }
 }