I want to turn the LED blue when the switch is in the middle position The LED strip does not turn blue when the switch is in the middle position because the middle position of the switch is not included in the switch cases that define the different palettes. The switch cases are currently set to change the palette based on whether the RC receiver value is less than or greater than the RC_MID value. In the provided code, the middle position of the switch is not accounted for, hence the LEDs will not turn blue in this position. To include the middle position of the switch, a new switch case should be added to set the LEDs to blue when the RC receiver value is equal to the RC_MID value. Can you make the changes for me and give me the full script?   
#include <FastLED.h>

#define LED_PIN 6
#define COLOR_ORDER GRB
#define CHIPSET WS2812
#define NUM_LEDS 30

#define BRIGHTNESS 100
#define FRAMES_PER_SECOND 60

CRGB leds[NUM_LEDS];

CRGBPalette16 gPal;

// Futaba RC Receiver variables
#define RC_PIN A0
#define RC_MIN 1000
#define RC_MAX 2000
#define RC_MID 1500
#define RC_DEADZONE 100

int currentPalette = 0;
int prevRCValue = RC_MID;

void setup() {
  delay(3000); // sanity delay
  FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
  FastLED.setBrightness( BRIGHTNESS );

  // This first palette is the basic ‘black body radiation’ colors,
  // which run from black to red to bright yellow to white.
  // gPal = HeatColors_p;

  // These are other ways to set up the color palette for the ‘fire’.
  // First, a gradient from black to red to yellow to white – similar to HeatColors_p
  // (GPAL A)
  // gPal = CRGBPalette16( CRGB::Black, CRGB::Red, CRGB::Yellow, CRGB::White);

  // Second, this palette is like the heat colors, but blue/aqua instead of red/yellow
  // (GPAL B)
  gPal = CRGBPalette16(
    CRGB::Black,
    CRGB::Blue,
    CRGB::Aqua,
    CRGB::White
  );

  // Third, here’s a simpler, three-step gradient, from black to red to white
  // (GPAL C)
  // gPal = CRGBPalette16( CRGB::Black, CRGB::Green, CRGB::Yellow);
}

void loop() {
  // Read RC receiver value
  int rcValue = pulseIn(RC_PIN, HIGH, 25000);
  rcValue = constrain(rcValue, RC_MIN, RC_MAX);

  // Check if RC receiver value is within the deadzone
  if (abs(rcValue - RC_MID) < RC_DEADZONE) {
    rcValue = RC_MID;
  }

  // Toggle color mode based on RC receiver value
  if (rcValue < RC_MID && prevRCValue >= RC_MID) {
    currentPalette--;
    if (currentPalette < 0) {
      currentPalette = 2;
    }
  } else if (rcValue >= RC_MID && prevRCValue < RC_MID) {
    currentPalette++;
    if (currentPalette > 2) {
      currentPalette = 0;
    }
  }

  prevRCValue = rcValue;

  // Add entropy to random number generator; we use a lot of it.
  random16_add_entropy( random());

  // Update palette based on currentPalette variable
  switch (currentPalette) {
    case 0:
      gPal = CRGBPalette16( CRGB::Red, CRGB::Red, CRGB::Yellow, CRGB::White);
      break;
    case 1:
      // This is the new palette with a blue color
      gPal = CRGBPalette16(
        CRGB::Black,
        CRGB::Blue,
        CRGB::Aqua,
        CRGB::White
      );
      break;
    case 2:
      gPal = CRGBPalette16( CRGB::Green, CRGB::Green, CRGB::Yellow);
      break;
  }

  Fire2012WithPalette(); // run simulation frame, using palette colors

  FastLED.show(); // display this frame
  FastLED.delay(1000 / FRAMES_PER_SECOND);
}

#define COOLING 55
#define SPARKING 120
#define FALLING 50

//****************************************************************


//********************************************************************************************//
// PLAY WITH FALLING, COOLING AND SPARKLING

void Fire2012WithPalette() {
  // Array of temperature readings at each simulation cell
  static uint8_t heat[NUM_LEDS];

  // Step 1. Cool down every cell a little
  for( int i = 0; i < NUM_LEDS; i++) {
    heat[i] = qsub8( heat[i], random8(0, ((COOLING * 10) / NUM_LEDS) + 2));
  }

  // Step 2. Heat from each cell drifts ‘up’ and diffuses a little
  for(int k = NUM_LEDS - 1; k >= 2; k--) {
    heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2] ) / 3;
  }

  // Step 3. Randomly ignite new ‘sparks’ of heat near the bottom
  if( random8() < FALLING ) {
    int y = random8(7);
    heat[y] = qadd8( heat[y], random8(160,255) );
  }

  // Step 4. Map from heat cells to LED colors
  for( int j = 0; j < NUM_LEDS; j++) {
    // Scale the heat value from 0-255 down to 0-240
    // for best results with color palettes.
    uint8_t colorindex = scale8( heat[j], 240);
    CRGB color = ColorFromPalette( gPal, colorindex);
    leds[j] = color;
  }
}