How do I change my speed based on certain events?

(CODE BELOW) I've gotten myself into a kind of rut. I got help with some code a while back which allowed me to run and walk and crouch. I then tried to change the speed based a courotine. This.. used to work, I changed some things and now it does not change my speed. I got help with this part too. So, I think the problem is with my speed variable. Everything is being changed through my speed variable I think. While what I added was based on other speed values (walkSpeed, runSpeed, & crouchSpeed). I tried to make speed equal these variables... but it doesn't seem to have worked. Thank you for anybody that can help! (:

Also, if anybody knows how to put these into spoilers, that would be great too!

 using UnityEngine;
 using System.Collections;
 
 [RequireComponent (typeof (CharacterController))]
 public class FPSwalkerEnhanced: MonoBehaviour {
 
     public float walkSpeed = 6.0f;
     public float walk;
     public float runSpeed = 11.0f;
     public float run;
     public float crouchSpeed = 2.0f;
     public float crouch;
     
     public float slowWalkSpeed = 1.0f;
     public float slowRunSpeed = 1.5f;
     public float slowCrouchSpeed = 0.5f;
 
     public bool walking = true;
     public bool running = false;
     public bool crouching = false;
 
     
     public float runTimer = 15; // how long you can run without getting tired
     public float endTime = 0;
 
     // If true, diagonal speed (when strafing + moving forward or back) can't exceed normal move speed; otherwise it's about 1.4 times faster
     public bool limitDiagonalSpeed = true;
 
     // If checked, the run key toggles between running and walking. Otherwise player runs if the key is held down and walks otherwise
     // There must be a button set up in the Input Manager called "Run"
     public bool toggleRun = false;
 
     public float jumpSpeed = 8.0f;
     public float gravity = 20.0f;
 
     // Units that player can fall before a falling damage function is run. To disable, type "infinity" in the inspector
     public float fallingDamageThreshold = 10.0f;
 
     // If the player ends up on a slope which is at least the Slope Limit as set on the character controller, then he will slide down
     public bool slideWhenOverSlopeLimit = false;
 
     // If checked and the player is on an object tagged "Slide", he will slide down it regardless of the slope limit
     public bool slideOnTaggedObjects = false;
 
     public float slideSpeed = 12.0f;
 
     // If checked, then the player can change direction while in the air
     public bool airControl = false;
 
     // Small amounts of this results in bumping when walking down slopes, but large amounts results in falling too fast
     public float antiBumpFactor = .75f;
 
     // Player must be grounded for at least this many physics frames before being able to jump again; set to 0 to allow bunny hopping
     public int antiBunnyHopFactor = 1;
 
     private Vector3 moveDirection = Vector3.zero;
     private bool grounded = false;
     private CharacterController controller;
     private Transform myTransform;
     private float speed;
     private RaycastHit hit;
     private float fallStartLevel;
     private bool falling;
     private float slideLimit;
     private float rayDistance;
     private Vector3 contactPoint;
     private bool playerControl = false;
     private int jumpTimer;
     private float cameraYOffset;
 
     private bool crouchKeyWasDown;
     private float crouchHeight;
     private float standardHeight;
     private GameObject mainCamera;
     private float height;
 
     void Start() {
         controller = GetComponent<CharacterController>();
         myTransform = transform;
         speed = walkSpeed;
         rayDistance = controller.height * .5f + controller.radius;
         slideLimit = controller.slopeLimit - .1f;
         jumpTimer = antiBunnyHopFactor;
         height = controller.height;
         mainCamera = GameObject.FindWithTag("MainCamera");
         cameraYOffset = mainCamera.transform.localPosition.y;
         crouchHeight = controller.height/2;
 
         walking = true;
         running = false;
         crouching = false;
 
         StartCoroutine (Speed());
         
     }
 
 
     void FixedUpdate() {
         float inputX = Input.GetAxis("Horizontal");
         float inputY = Input.GetAxis("Vertical");
         // If both horizontal and vertical are used simultaneously, limit speed (if allowed), so the total doesn't exceed normal move speed
         float inputModifyFactor = (inputX != 0.0f && inputY != 0.0f && limitDiagonalSpeed)? .7071f : 1.0f;
 
         if (grounded) {
                         bool sliding = false;
                         // See if surface immediately below should be slid down. We use this normally rather than a ControllerColliderHit point,
                         // because that interferes with step climbing amongst other annoyances
                         if (Physics.Raycast (myTransform.position, -Vector3.up, out hit, rayDistance)) {
                                 if (Vector3.Angle (hit.normal, Vector3.up) > slideLimit)
                                         sliding = true;
                         }
             // However, just raycasting straight down from the center can fail when on steep slopes
             // So if the above raycast didn't catch anything, raycast down from the stored ControllerColliderHit point instead
             else {
                                 Physics.Raycast (contactPoint + Vector3.up, -Vector3.up, out hit);
                                 if (Vector3.Angle (hit.normal, Vector3.up) > slideLimit)
                                         sliding = true;
                         }
 
                         // If we were falling, and we fell a vertical distance greater than the threshold, run a falling damage routine
                         if (falling) {
                                 falling = false;
                                 if (myTransform.position.y < fallStartLevel - fallingDamageThreshold)
                                         FallingDamageAlert (fallStartLevel - myTransform.position.y);
                         }
 
                         // If running isn't on a toggle, then use the appropriate speed depending on whether the run button is down
                         if (!toggleRun)
                                 speed = Input.GetButton ("Run") ? runSpeed : walkSpeed;
 
                         // If sliding (and it's allowed), or if we're on an object tagged "Slide", get a vector pointing down the slope we're on
                         if ((sliding && slideWhenOverSlopeLimit) || (slideOnTaggedObjects && hit.collider.tag == "Slide")) {
                                 Vector3 hitNormal = hit.normal;
                                 moveDirection = new Vector3 (hitNormal.x, -hitNormal.y, hitNormal.z);
                                 Vector3.OrthoNormalize (ref hitNormal, ref moveDirection);
                                 moveDirection *= slideSpeed;
                                 playerControl = false;
                         }
             // Otherwise recalculate moveDirection directly from axes, adding a bit of -y to avoid bumping down inclines
             else {
                                 moveDirection = new Vector3 (inputX * inputModifyFactor, -antiBumpFactor, inputY * inputModifyFactor);
                                 moveDirection = myTransform.TransformDirection (moveDirection) * speed;
                                 playerControl = true;
                         }
 
                         // Jump! But only if the jump button has been released and player has been grounded for a given number of frames
                         if (!Input.GetButton ("Jump"))
                                 jumpTimer++;
                         else if (jumpTimer >= antiBunnyHopFactor) {
                                 moveDirection.y = jumpSpeed;
                                 jumpTimer = 0;
                         }
 
         }
         
         {
             // If we stepped over a cliff or something, set the height at which we started falling
             if (!falling) {
                 falling = true;
                 fallStartLevel = myTransform.position.y;
             }
 
             // If air control is allowed, check movement but don't touch the y component
             if (airControl && playerControl) {
                 moveDirection.x = inputX * speed * inputModifyFactor;
                 moveDirection.z = inputY * speed * inputModifyFactor;
                 moveDirection = myTransform.TransformDirection(moveDirection);
             }
         }
 
         // Apply gravity
         moveDirection.y -= gravity * Time.deltaTime;
 
         // Move the controller, and set grounded true or false depending on whether we're standing on something
         grounded = (controller.Move(moveDirection * Time.deltaTime) & CollisionFlags.Below) != 0;
 
     
         // If running isn't on a toggle, then use the appropriate speed depending on whether the run button is down
         if(Input.GetKey(KeyCode.LeftControl)){
 
             //crouchKeyWasDown = true;
             //crouching = !crouching;
             //controller.height = crouchHeight;
             //controller.center = new Vector3 (0, -1, 0);
 
             //Debug.Log(mainCamera);
             //mainCamera.transform.localPosition.y = cameraYOffset + standardHeight;
             crouching = true;
             Debug.Log ("Is Crouching.");
 
         } else{
 
             //controller.height = standardHeight ;
             //controller.center = new Vector3 (0, 0, 0);
             //mainCamera.transform.localPosition.y = cameraYOffset + crouchHeight;
             crouching = false;
             Debug.Log ("Is NOT Crouching.");
 
         } 
 
         if (crouching && Input.GetKeyUp(KeyCode.LeftControl)) {
             //crouchKeyWasDown = false;
         }
 
         if ((Input.GetKey (KeyCode.LeftShift))) {
                         running = true;
                         walking = false;
             Debug.Log ("Is running.");
                 } else {
             running = false;
             walking = true;
             Debug.Log ("Is NOT running.");
                 }
     
     }
 
     void Update () {
 
 
         // If the run button is set to toggle, then switch between walk/run speed. (We use Update for this...
         // FixedUpdate is a poor place to use GetButtonDown, since it doesn't necessarily run every frame and can miss the event)
         if (toggleRun && grounded && Input.GetButtonDown("Run"))
             speed = (speed == walkSpeed? runSpeed : walkSpeed);
 
         if ((Input.GetKey (KeyCode.LeftShift))) {
             running = true;
             walking = false;
             Debug.Log ("Is running.");
         } else {
             running = false;
             walking = true;
             Debug.Log ("Is NOT running.");
         }
         
         if(grounded){
         if (walking == true){
             speed = walkSpeed;
         } 
         if (running == true){
             speed = runSpeed;
         }
         if (crouching == true){
             speed = crouchSpeed;
         }
         
         }
     }
     
 
     // Store point that we're in contact with for use in FixedUpdate if needed
     void OnControllerColliderHit (ControllerColliderHit hit) {
         contactPoint = hit.point;
     }
 
     // If falling damage occured, this is the place to do something about it. You can make the player
     // have hitpoints and remove some of them based on the distance fallen, add sound effects, etc.
     void FallingDamageAlert (float fallDistance) {
         print ("Ouch! Fell " + fallDistance + " units!");   
     }
 
     void OnGUI()
     {
         GUILayout.Label("\n" + "\n" + "Time Remaining - " + endTime.ToString() + "\n" + "Press 'L_Shift' Key to activate the timer.");
     }
 
 
      IEnumerator Speed(){
         while (true){
             endTime = 15;
             SetSpeedNormal();
             while (endTime >= 0){
                 if((Input.GetKey ("left shift") || Input.GetKey ("right shift"))) {
                     endTime -= Time.deltaTime;
                 } else {                
                     if (endTime < 15){
                         endTime += Time.deltaTime;
                     }
                 }
                 yield return null;
             }
 
             SetSpeedSlow();
             yield return new WaitForSeconds(6);
         }
     }
     
       void SetSpeedNormal (){
         walk = walkSpeed;
         run = runSpeed;
         crouch = crouchSpeed;
     }
     
       void SetSpeedSlow (){
         walk = slowWalkSpeed;
         run = slowRunSpeed;
         crouch = slowCrouchSpeed;
     }
 }

~WM