diff --git a/.vscode/settings.json b/.vscode/settings.json
index ba8a705..1020abe 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -40,6 +40,15 @@
         "cleanup_mode.h": "c",
         "charge_mode.h": "c",
         "http_rest.h": "c",
-        "motors.h": "c"
+        "motors.h": "c",
+        "eeprom.h": "c",
+        "stdbool.h": "c",
+        "configuration.h": "c",
+        "uart.h": "c",
+        "common.h": "c",
+        "clocks.h": "c",
+        "pwm.h": "c",
+        "servo_gate.h": "c",
+        "semphr.h": "c"
     }
 }
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ae62884..83b0e25 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -99,6 +99,7 @@ target_link_libraries("${TARGET_NAME}"
     hardware_pio
     hardware_spi
     hardware_i2c
+    hardware_pwm
     FreeRTOS-Kernel
     FreeRTOS-Kernel-Heap4
     u8g2
diff --git a/src/app.cpp b/src/app.cpp
index 2966bb8..33bfca8 100644
--- a/src/app.cpp
+++ b/src/app.cpp
@@ -26,7 +26,7 @@
 #include "rotary_button.h"
 #include "menu.h"
 #include "profile.h"
-
+#include "servo_gate.h"
 
 
 uint8_t software_reboot() {
@@ -63,6 +63,9 @@ int main()
     // Initialize profile data
     profile_data_init();
 
+    // Initialize the servo
+    servo_gate_init();
+
 #ifdef RASPBERRYPI_PICO_W
     // Load wireless settings
     wireless_init();
diff --git a/src/charge_mode.cpp b/src/charge_mode.cpp
index d43d53c..de8232a 100644
--- a/src/charge_mode.cpp
+++ b/src/charge_mode.cpp
@@ -20,6 +20,7 @@
 #include "neopixel_led.h"
 #include "profile.h"
 #include "common.h"
+#include "servo_gate.h"
 
 
 uint8_t charge_weight_digits[] = {0, 0, 0, 0, 0};
@@ -28,6 +29,8 @@ charge_mode_config_t charge_mode_config;
 
 // Scale related
 extern scale_config_t scale_config;
+extern servo_gate_t servo_gate;
+
 
 const eeprom_charge_mode_data_t default_charge_mode_data = {
     .charge_mode_data_rev = EEPROM_CHARGE_MODE_DATA_REV,
@@ -40,6 +43,11 @@ const eeprom_charge_mode_data_t default_charge_mode_data = {
 
     .decimal_places = DP_2,
 
+    // Precharges
+    .precharge_enable = false,
+    .precharge_time_ms = 1000,
+    .precharge_speed_rps = 2,
+
     // LED related
     .neopixel_normal_charge_colour = urgb_u32(0, 0xFF, 0),          // green
     .neopixel_under_charge_colour = urgb_u32(0xFF, 0xFF, 0),        // yellow
@@ -167,6 +175,11 @@ void charge_mode_wait_for_complete() {
         true
     );
 
+    // If the servo gate is used then it has to be opened
+    if (servo_gate.gate_state != GATE_DISABLED) {
+        servo_gate_set_state(GATE_OPEN, false);
+    }
+
     // Update current status
     char target_weight_string[WEIGHT_STRING_LEN];
     float_to_string(target_weight_string, charge_mode_config.target_charge_weight, charge_mode_config.eeprom_charge_mode_data.decimal_places);
@@ -260,7 +273,21 @@ void charge_mode_wait_for_complete() {
         last_error = error;
     }
 
-    vTaskDelay(pdMS_TO_TICKS(20));  // Wait for other tasks to complete
+    // Close the gate if the servo gate is present
+    if (servo_gate.gate_state != GATE_DISABLED) {
+        servo_gate_set_state(GATE_CLOSE, true);
+    }
+
+    // Precharge
+    if (charge_mode_config.eeprom_charge_mode_data.precharge_enable && servo_gate.gate_state != GATE_DISABLED) {
+        motor_set_speed(SELECT_COARSE_TRICKLER_MOTOR, charge_mode_config.eeprom_charge_mode_data.precharge_speed_rps);
+        vTaskDelay(pdMS_TO_TICKS(charge_mode_config.eeprom_charge_mode_data.precharge_time_ms));
+
+        motor_set_speed(SELECT_COARSE_TRICKLER_MOTOR, 0);
+    }
+    else {
+        vTaskDelay(pdMS_TO_TICKS(20));  // Wait for other tasks to complete  
+    }
 
     charge_mode_config.charge_mode_state = CHARGE_MODE_WAIT_FOR_CUP_REMOVAL;
 }
@@ -365,6 +392,7 @@ void charge_mode_wait_for_cup_return() {
 
     snprintf(title_string, sizeof(title_string), "Return Cup");
 
+
     FloatRingBuffer data_buffer(5);
 
     while (true) {
@@ -528,6 +556,9 @@ bool http_rest_charge_mode_config(struct fs_file *file, int num_params, char *pa
     // c7 (float): set_point_sd_margin
     // c8 (float): set_point_mean_margin
     // c9 (int): decimal point enum
+    // c10 (bool): precharge_enable
+    // c11 (int): precharge_time_ms
+    // c12 (float): precharge_speed_rps
 
     // ee (bool): save to eeprom
 
@@ -551,6 +582,17 @@ bool http_rest_charge_mode_config(struct fs_file *file, int num_params, char *pa
         else if (strcmp(params[idx], "c9") == 0) {
             charge_mode_config.eeprom_charge_mode_data.decimal_places = (decimal_places_t) atoi(values[idx]);
         }
+        
+        // Pre charge related settings
+        else if (strcmp(params[idx], "c10") == 0) {
+            charge_mode_config.eeprom_charge_mode_data.precharge_enable = string_to_boolean(values[idx]);
+        }
+        else if (strcmp(params[idx], "c11") == 0) {
+            charge_mode_config.eeprom_charge_mode_data.precharge_time_ms = strtol(values[idx], NULL, 10);
+        }
+        else if (strcmp(params[idx], "c12") == 0) {
+            charge_mode_config.eeprom_charge_mode_data.precharge_speed_rps = strtof(values[idx], NULL);
+        }
 
         // LED related settings
         else if (strcmp(params[idx], "c1") == 0) {
@@ -580,17 +622,19 @@ bool http_rest_charge_mode_config(struct fs_file *file, int num_params, char *pa
              sizeof(charge_mode_json_buffer),
              "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n"
              "{\"c1\":\"#%06lx\",\"c2\":\"#%06lx\",\"c3\":\"#%06lx\",\"c4\":\"#%06lx\","
-             "\"c5\":%.3f,\"c6\":%.3f,\"c7\":%.3f,\"c8\":%.3f,\"c9\":%d}",
+             "\"c5\":%.3f,\"c6\":%.3f,\"c7\":%.3f,\"c8\":%.3f,\"c9\":%d,\"c10\":\"%s\",\"c11\":%ld,\"c12\":%0.3f}",
              charge_mode_config.eeprom_charge_mode_data.neopixel_normal_charge_colour,
              charge_mode_config.eeprom_charge_mode_data.neopixel_under_charge_colour,
              charge_mode_config.eeprom_charge_mode_data.neopixel_over_charge_colour,
              charge_mode_config.eeprom_charge_mode_data.neopixel_not_ready_colour,
-             
              charge_mode_config.eeprom_charge_mode_data.coarse_stop_threshold,
              charge_mode_config.eeprom_charge_mode_data.fine_stop_threshold,
              charge_mode_config.eeprom_charge_mode_data.set_point_sd_margin,
              charge_mode_config.eeprom_charge_mode_data.set_point_mean_margin,
-             charge_mode_config.eeprom_charge_mode_data.decimal_places);
+             charge_mode_config.eeprom_charge_mode_data.decimal_places,
+             boolean_to_string(charge_mode_config.eeprom_charge_mode_data.precharge_enable),
+             charge_mode_config.eeprom_charge_mode_data.precharge_time_ms,
+             charge_mode_config.eeprom_charge_mode_data.precharge_speed_rps);
 
     size_t data_length = strlen(charge_mode_json_buffer);
     file->data = charge_mode_json_buffer;
diff --git a/src/charge_mode.h b/src/charge_mode.h
index 05bf2ae..f87e006 100644
--- a/src/charge_mode.h
+++ b/src/charge_mode.h
@@ -6,7 +6,7 @@
 #include "common.h"
 
 
-#define EEPROM_CHARGE_MODE_DATA_REV                     7              // 16 byte 
+#define EEPROM_CHARGE_MODE_DATA_REV                     8              // 16 byte 
 
 #define WEIGHT_STRING_LEN 8
 
@@ -29,6 +29,11 @@ typedef struct {
 
     decimal_places_t decimal_places;
 
+    // Precharge
+    bool precharge_enable;
+    uint32_t precharge_time_ms;
+    float precharge_speed_rps;
+
     // LED related settings
     uint32_t neopixel_normal_charge_colour;
     uint32_t neopixel_under_charge_colour;
diff --git a/src/cleanup_mode.cpp b/src/cleanup_mode.cpp
index 7c6f32a..cf3d080 100644
--- a/src/cleanup_mode.cpp
+++ b/src/cleanup_mode.cpp
@@ -13,12 +13,13 @@
 #include "common.h"
 #include "charge_mode.h"
 #include "cleanup_mode.h"
+#include "servo_gate.h"
 
 
 // Memory from other modules
 extern QueueHandle_t encoder_event_queue;
 extern charge_mode_config_t charge_mode_config;
-
+extern servo_gate_t servo_gate;
 extern AppState_t exit_state;
 extern QueueHandle_t encoder_event_queue;
 
@@ -78,6 +79,11 @@ void cleanup_render_task(void *p) {
         u8g2_SetFont(display_handler, u8g2_font_profont11_tf);
         u8g2_DrawStr(display_handler, 5, 45, buf);
 
+        memset(buf, 0x0, sizeof(buf));
+        sprintf(buf, "Servo Gate: %s", gate_state_to_string(servo_gate.gate_state));
+        u8g2_SetFont(display_handler, u8g2_font_profont11_tf);
+        u8g2_DrawStr(display_handler, 5, 55, buf);
+
         u8g2_SendBuffer(display_handler);
 
         vTaskDelayUntil(&last_render_tick, pdMS_TO_TICKS(20));
diff --git a/src/eeprom.h b/src/eeprom.h
index 8bd5f09..3e819c3 100644
--- a/src/eeprom.h
+++ b/src/eeprom.h
@@ -15,6 +15,7 @@
 #define EEPROM_NEOPIXEL_LED_CONFIG_BASE_ADDR    7 * 1024       // 7k
 #define EEPROM_ROTARY_BUTTON_CONFIG_BASE_ADDR   8 * 1024       // 8k 
 #define EEPROM_PROFILE_DATA_BASE_ADDR           9 * 1024       // 9k
+#define EEPROM_SERVO_GATE_CONFIG_BASE_ADDR     10 * 1024       // 10k
 
 #define EEPROM_METADATA_REV                     2              // 16 byte 
 
diff --git a/src/html/web_portal.html b/src/html/web_portal.html
index e943d43..06f086b 100644
--- a/src/html/web_portal.html
+++ b/src/html/web_portal.html
@@ -13,7 +13,7 @@
     <style>
         /* Exclude the pixels taken by the bottom nav bar */
         .exclude-bottom-nav {
-            padding-bottom: 74px;
+            padding-bottom: 64px;
         }
     </style>
 </head>
@@ -71,11 +71,17 @@
             </section>
 
             <div class="grid grid-cols-1 gap-2 px-4">
-                <div class="divider">Scale</div>
+                <div class="divider">General Control</div>
                 <div class="grid grid-cols-1 gap-2">
                     <button class="btn btn-neutral" onclick="scaleForceZero()">Scale Zero</button>
+
+                    <div class="grid grid-cols-2 gap-2">
+                        <button class="btn btn-neutral" onclick="servoGateSetState(2)">Gate Open</button>
+                        <button class="btn btn-neutral" onclick="servoGateSetState(1)">Gate Close</button>
+                    </div>
                 </div>
             </div>
+
         </div>
     </section>
 
@@ -251,6 +257,26 @@
                                 </select>
                             </div>
 
+                            <div class="divider"></div>
+
+                            <div class="grid grid-cols-1 gap-1">
+                                <span class="label-text">Enable Pre-Charge (requires servo gate)</span>
+                                <select class="select select-bordered" name="c10">
+                                    <option value="true">Yes</option>
+                                    <option value="false">No</option>
+                                </select>
+                            </div>
+
+                            <div class="grid grid-cols-1 gap-1">
+                                <span class="label-text">Pre-Charge Duration (ms)</span>
+                                <input type="number" class="input input-bordered" name="c11" step="1">
+                            </div>
+
+                            <div class="grid grid-cols-1 gap-1">
+                                <span class="label-text">Pre-Charge Speed (rps)</span>
+                                <input type="number" class="input input-bordered" name="c12" step="0.001">
+                            </div>
+
                             <button class="btn btn-neutral settings-apply-btn">Apply</button>
                         </form>
                     </section>
@@ -484,6 +510,50 @@
                         </form>
                     </section>
 
+                    <section class="settings-page" id="settings-servo-gate" name="Servo Gate" style="display: none;">
+                        <form id="servoGateConfigForm" action="/rest/servo_gate_config" class="grid grid-cols-1 gap-3">
+                            <div class="grid grid-cols-1 gap-1">
+                                <span class="label-text">Servo Gate Enable</span>
+                                <select class="select select-bordered" name="c0">
+                                    <option value="true">Yes</option>
+                                    <option value="false">No</option>
+                                </select>
+                            </div>
+
+                            <div class="grid grid-cols-1 gap-1">
+                                <span class="label-text">Shutter 0 Close Duty Cycle</span>
+                                <input type="number" class="input input-bordered" name="c1" step="0.001">
+                            </div>
+                            
+                            <div class="grid grid-cols-1 gap-1">
+                                <span class="label-text">Shutter 0 Open Duty Cycle</span>
+                                <input type="number" class="input input-bordered" name="c2" step="0.001">
+                            </div>
+
+                            <div class="grid grid-cols-1 gap-1">
+                                <span class="label-text">Shutter 1 Close Duty Cycle</span>
+                                <input type="number" class="input input-bordered" name="c3" step="0.001">
+                            </div>
+
+                            <div class="grid grid-cols-1 gap-1">
+                                <span class="label-text">Shutter 1 Open Duty Cycle</span>
+                                <input type="number" class="input input-bordered" name="c4" step="0.001">
+                            </div>
+
+                            <div class="grid grid-cols-1 gap-1">
+                                <span class="label-text">Shutter Close Speed (%/s)</span>
+                                <input type="number" class="input input-bordered" name="c5" step="0.001">
+                            </div>
+
+                            <div class="grid grid-cols-1 gap-1">
+                                <span class="label-text">Shutter Open Speed (%/s)</span>
+                                <input type="number" class="input input-bordered" name="c6" step="0.001">
+                            </div>
+
+                            <button class="btn btn-neutral settings-apply-btn">Apply</button>
+                        </form>
+                    </section>
+
                     <!-- System Control Page -->
                     <section class="settings-page" id="settings-system-control" name="System Control" style="display: none;">
                         <form id="systemControlForm" action="/rest/system_control" class="grid grid-cols-1 gap-3">
@@ -555,6 +625,7 @@
                     <li><a class="text-lg" onclick="onSettingsLinkClicked('settings-fine-motor')">Fine Motor</a></li>
                     <li><a class="text-lg" onclick="onSettingsLinkClicked('settings-neopixel-led')">Neopixel LED</a></li>
                     <li><a class="text-lg" onclick="onSettingsLinkClicked('settings-button')">Buttons</a></li>
+                    <li><a class="text-lg" onclick="onSettingsLinkClicked('settings-servo-gate')">Servo Gate</a></li>
                     <li><a class="text-lg" onclick="onSettingsLinkClicked('settings-system-control')">System Control</a></li>
                 </ul>
             </div>
@@ -730,6 +801,12 @@ <h3 class="font-bold text-lg">Error</h3>
         ENTER: 1,
     });
 
+    const ServoGateState = Object.freeze({
+        GATE_DISABLED: 0,
+        GATE_CLOSE: 1,
+        GATE_OPEN: 2,
+    });
+
     var pollSetTimeoutId;
 
     // Set Charge Mode Set Point with REST interface
@@ -991,6 +1068,22 @@ <h3 class="font-bold text-lg">Error</h3>
         });
     }
 
+    function servoGateSetState(state) {
+        const uri = `/rest/servo_gate_state?g0=${encodeURIComponent(state)}`;
+
+        // Call the scale action URI
+        fetch(uri)
+        .then(response => {
+            return response.json();
+        })
+        .then(data => {
+            // console.log(data);
+        })
+        .catch(error => {
+            console.error("Error applying servo gate state");
+        });
+    }
+
     // Switch pages
     function onNavButtonClicked(button) {
         const sectionTrickler = document.getElementById("sectionTrickler");
diff --git a/src/mui_menu.c b/src/mui_menu.c
index 5c63c99..643e7b1 100644
--- a/src/mui_menu.c
+++ b/src/mui_menu.c
@@ -13,13 +13,14 @@
 #include "version.h"
 #include "common.h"
 #include "profile.h"
+#include "servo_gate.h"
 
 
+// External modules/varaibles
 extern uint8_t charge_weight_digits[];
 extern AppState_t exit_state;
 extern charge_mode_config_t charge_mode_config;
-
-// Imported from and_scale module
+extern servo_gate_t servo_gate;
 extern scale_config_t scale_config;
 extern eeprom_profile_data_t profile_data;
 
@@ -189,6 +190,22 @@ uint8_t render_profile_misc_details(mui_t *ui, uint8_t msg) {
 }
 
 
+uint8_t render_servo_gate_state_with_action(mui_t *ui, uint8_t msg) {
+    uint8_t return_value = mui_u8g2_u8_radio_wm_pi(ui, msg);
+
+    switch(msg) {
+        case MUIF_MSG_CURSOR_SELECT:
+        {
+            uint8_t *value = (uint8_t *)muif_get_data(ui->uif);
+            servo_gate_set_state((gate_state_t) *value, false);
+            break;
+        }
+    }
+
+    return return_value;
+}
+
+
 
 muif_t muif_list[] = {
         /* normal text style */
@@ -229,6 +246,9 @@ muif_t muif_list[] = {
         // Render version
         MUIF_RO("VE", render_version_page),
 
+        // Render servo gate state
+        MUIF_VARIABLE("RB",&servo_gate.gate_state, render_servo_gate_state_with_action),
+
         // input for a number between 0 to 9 //
         MUIF_U8G2_U8_MIN_MAX("N4", &charge_weight_digits[4], 0, 9, mui_u8g2_u8_min_max_wm_mud_pi),
         MUIF_U8G2_U8_MIN_MAX("N3", &charge_weight_digits[3], 0, 9, mui_u8g2_u8_min_max_wm_mud_pi),
@@ -359,6 +379,7 @@ fds_t fds_data[] = {
         MUI_31 "Scale|"
         MUI_32 "Profile Manager|"
         MUI_37 "EEPROM|"
+        MUI_39 "Servo Gate|"
         MUI_35 "Reboot|"
         MUI_36 "Version|"
         MUI_1 "<-Return"  // Back to main menu
@@ -477,6 +498,17 @@ fds_t fds_data[] = {
     MUI_XYA("GC", 5, 49, 2) 
     MUI_XYA("GC", 5, 61, 3)
 
+    // Servo Gate submenu
+    MUI_FORM(39)
+    MUI_STYLE(1)
+    MUI_LABEL(5,10, "Servo Gate Control")
+    MUI_XY("HL", 0,13)
+
+    MUI_XYAT("RB", 5, 25, 0, "Disable")
+    MUI_XYAT("RB", 5, 37, 1, "Open")
+    MUI_XYAT("RB", 5, 49, 2, "Close")
+    MUI_XYAT("BN", 64, 59, 30, " OK ")  // Jump to form 30
+
     // Wirelss submenu
     MUI_FORM(40)
 #ifdef RASPBERRYPI_PICO_W
diff --git a/src/rest_endpoints.c b/src/rest_endpoints.c
index 96d8419..352a297 100644
--- a/src/rest_endpoints.c
+++ b/src/rest_endpoints.c
@@ -12,6 +12,7 @@
 #include "neopixel_led.h"
 #include "profile.h"
 #include "cleanup_mode.h"
+#include "servo_gate.h"
 
 // Generated headers by html2header.py under scripts
 #include "display_mirror.html.h"
@@ -93,6 +94,8 @@ bool rest_endpoints_init(bool default_wizard) {
     rest_register_handler("/rest/neopixel_led_config", http_rest_neopixel_led_config);
     rest_register_handler("/rest/profile_config", http_rest_profile_config);
     rest_register_handler("/rest/profile_summary", http_rest_profile_summary);
+    rest_register_handler("/rest/servo_gate_state", http_rest_servo_gate_state);
+    rest_register_handler("/rest/servo_gate_config", http_rest_servo_gate_config);
     rest_register_handler("/display_buffer", http_get_display_buffer);
     rest_register_handler("/display_mirror", http_display_mirror);
 
diff --git a/src/servo_gate.c b/src/servo_gate.c
new file mode 100644
index 0000000..c3a88bd
--- /dev/null
+++ b/src/servo_gate.c
@@ -0,0 +1,328 @@
+#include <stdbool.h>
+#include <math.h>
+#include "hardware/pwm.h"
+#include "hardware/clocks.h"
+#include "configuration.h"
+#include "eeprom.h"
+#include "common.h"
+#include "servo_gate.h"
+
+// Attributes
+servo_gate_t servo_gate;
+
+// Const settings
+const float _servo_pwm_freq = 50.0;
+const uint16_t _pwm_full_scale_level = 65535;
+
+
+const eeprom_servo_gate_config_t default_eeprom_servo_gate_config = {
+    .servo_gate_config_rev = EEPROM_SERVO_GATE_CONFIG_REV,
+    .servo_gate_enable = false,
+    .shutter0_close_duty_cycle = 0.09f,
+    .shutter0_open_duty_cycle = 0.05f,
+    .shutter1_close_duty_cycle = 0.05f,
+    .shutter1_open_duty_cycle = 0.09f,
+    .shutter_open_speed_pct_s = 5.0f,
+    .shutter_close_speed_pct_s = 3.0f,
+};
+
+
+const char * _gate_state_string[] = {
+    "Disabled",
+    "Close",
+    "Open"
+};
+const char * gate_state_to_string(gate_state_t state) {
+    return _gate_state_string[state];
+}
+
+
+static void inline _set_duty_cycle(uint16_t shutter0_duty_cycle, uint16_t shutter1_duty_cycle) {
+    uint32_t reg_level = ((uint32_t) shutter0_duty_cycle) << 16 | shutter1_duty_cycle;
+
+    // Write both levels to the pwm at the same time
+    hw_write_masked(
+        &pwm_hw->slice[SERVO_PWM_SLICE_NUM].cc,
+        reg_level,
+        0xffffffff
+    );
+}
+
+
+void _servo_gate_set_current_state(float open_ratio) {
+    uint16_t shutter0_duty_cycle;
+    uint16_t shutter1_duty_cycle;
+
+    float shutter0_range = servo_gate.eeprom_servo_gate_config.shutter0_close_duty_cycle - servo_gate.eeprom_servo_gate_config.shutter0_open_duty_cycle;
+    float shutter1_range = servo_gate.eeprom_servo_gate_config.shutter1_close_duty_cycle - servo_gate.eeprom_servo_gate_config.shutter1_open_duty_cycle;
+
+    shutter0_duty_cycle = _pwm_full_scale_level * (servo_gate.eeprom_servo_gate_config.shutter0_open_duty_cycle + shutter0_range * open_ratio);
+    shutter1_duty_cycle = _pwm_full_scale_level * (servo_gate.eeprom_servo_gate_config.shutter1_open_duty_cycle + shutter1_range * open_ratio);
+
+    _set_duty_cycle(shutter0_duty_cycle, shutter1_duty_cycle);
+}
+
+
+void servo_gate_set_state(gate_state_t state, bool block_wait) {
+    // Skip if not initialized
+    if (servo_gate.control_queue) {
+        // Clear the semaphore state
+        xSemaphoreTake(servo_gate.move_ready_semphore, 0);
+
+        xQueueSend(servo_gate.control_queue, &state, portMAX_DELAY);
+
+        if (block_wait) {
+            xSemaphoreTake(servo_gate.move_ready_semphore, portMAX_DELAY);
+        }
+    }
+}
+
+
+void servo_gate_control_task(void * p) {
+    float prev_open_ratio = -1.0f;
+
+    while (true) {
+        gate_state_t new_state;
+        xQueueReceive(servo_gate.control_queue, &new_state, portMAX_DELAY);
+
+        // Calculate the new gate open ratio
+        float new_open_ratio;
+        switch (new_state) {
+            case GATE_OPEN:
+                new_open_ratio = 0.0f;
+                break;
+            case GATE_CLOSE:
+                new_open_ratio = 1.0f;
+                break;
+            default:
+                break;
+        }
+
+        // First time
+        if (prev_open_ratio < 0) {
+            _servo_gate_set_current_state(new_open_ratio);
+        }
+        else {
+            float delta = new_open_ratio - prev_open_ratio;
+            float speed = delta < 0 ? servo_gate.eeprom_servo_gate_config.shutter_open_speed_pct_s : 
+                                      servo_gate.eeprom_servo_gate_config.shutter_close_speed_pct_s;
+            uint32_t ramp_time_us = fabs(delta / speed) * 1e6;
+
+            uint32_t start_time = time_us_32();
+            uint32_t stop_time = start_time + ramp_time_us;
+            while (true) {
+                uint32_t current_time = time_us_32();
+                if (current_time > stop_time) {
+                    break;
+                }
+
+                float percentage = (current_time - start_time) / (float) ramp_time_us;
+                float current_ratio = prev_open_ratio + delta * percentage;
+
+                _servo_gate_set_current_state(current_ratio);
+            }
+
+            _servo_gate_set_current_state(new_open_ratio);
+        }
+
+        // Signal the motion is ready
+        xSemaphoreGive(servo_gate.move_ready_semphore);
+
+        // Update state
+        prev_open_ratio = new_open_ratio;
+        servo_gate.gate_state = new_state;
+    }
+}
+
+
+bool servo_gate_config_save(void) {
+    bool is_ok = eeprom_write(EEPROM_SERVO_GATE_CONFIG_BASE_ADDR, (uint8_t *) &servo_gate.eeprom_servo_gate_config, sizeof(eeprom_servo_gate_config_t));
+    return is_ok;
+}
+
+bool servo_gate_config_init() {
+    bool is_ok = true;
+
+    // Read charge mode config from EEPROM
+    memset(&servo_gate, 0x0, sizeof(servo_gate));
+    is_ok = eeprom_read(EEPROM_SERVO_GATE_CONFIG_BASE_ADDR, (uint8_t *)&servo_gate.eeprom_servo_gate_config, sizeof(eeprom_servo_gate_config_t));
+    if (!is_ok) {
+        printf("Unable to read from EEPROM at address %x\n", EEPROM_SERVO_GATE_CONFIG_BASE_ADDR);
+        return false;
+    }
+
+    if (servo_gate.eeprom_servo_gate_config.servo_gate_config_rev != EEPROM_SERVO_GATE_CONFIG_REV) {
+        memcpy(&servo_gate.eeprom_servo_gate_config, &default_eeprom_servo_gate_config, sizeof(eeprom_servo_gate_config_t));
+
+        // Write back
+        is_ok = servo_gate_config_save();
+        if (!is_ok) {
+            printf("Unable to write to %x\n", EEPROM_SERVO_GATE_CONFIG_BASE_ADDR);
+            return false;
+        }
+    }
+
+    // Register to eeprom save all
+    eeprom_register_handler(servo_gate_config_save);
+
+    // Initialize settings
+    if (servo_gate.eeprom_servo_gate_config.servo_gate_enable) {
+        servo_gate.gate_state = GATE_OPEN;
+    }
+    else {
+        servo_gate.gate_state = GATE_DISABLED;
+    }
+
+    return is_ok;
+}
+
+
+bool servo_gate_init() {
+    bool is_ok = true;
+
+    is_ok = servo_gate_config_init();
+
+    // Stop early if servo config failed to initialise, or disabled
+    if (!is_ok || servo_gate.gate_state == GATE_DISABLED) {
+        return false;
+    }
+
+    // Initialize pins
+    gpio_set_function(SERVO0_PWM_PIN, GPIO_FUNC_PWM);
+    gpio_set_function(SERVO1_PWM_PIN, GPIO_FUNC_PWM);
+
+    pwm_config cfg = pwm_get_default_config();
+
+    // Set to 50hz frequency
+    uint32_t sys_freq = clock_get_hz(clk_sys);
+    float divider = ceil(sys_freq / (4096 * _servo_pwm_freq)) / 16.0f;
+    uint16_t wrap = sys_freq / divider / _servo_pwm_freq - 1;
+
+    pwm_config_set_clkdiv(&cfg, divider);
+    pwm_config_set_wrap(&cfg, wrap);
+
+    pwm_init(pwm_gpio_to_slice_num(SERVO0_PWM_PIN), &cfg, true);
+    pwm_init(pwm_gpio_to_slice_num(SERVO1_PWM_PIN), &cfg, true);
+
+    // Start the RTOS task and queue
+    servo_gate.control_queue = xQueueCreate(1, sizeof(gate_state_t));
+    servo_gate.move_ready_semphore = xSemaphoreCreateBinary();
+
+    xTaskCreate(
+        servo_gate_control_task,
+        "servo_gate_controller",
+        configMINIMAL_STACK_SIZE,
+        NULL,
+        8,
+        &servo_gate.control_task_handler
+    );
+
+    // No, we don't set the servo gate state
+
+    return true;
+}
+
+
+bool http_rest_servo_gate_state(struct fs_file *file, int num_params, char *params[], char *values[]) {
+    // Mappings
+    // g0 (int): gate_state_t
+
+    static char servo_gate_json_buffer[64];
+
+    // Control
+    for (int idx = 0; idx < num_params; idx += 1) {
+        if (strcmp(params[idx], "g0") == 0) {
+            gate_state_t state = (gate_state_t) atoi(values[idx]);
+            servo_gate_set_state(state, false);
+        }
+    }
+    
+    // Response
+    snprintf(servo_gate_json_buffer, 
+             sizeof(servo_gate_json_buffer),
+             "%s"
+             "{\"g0\":%d}",
+             http_json_header,
+             (int) servo_gate.gate_state);
+
+    size_t data_length = strlen(servo_gate_json_buffer);
+    file->data = servo_gate_json_buffer;
+    file->len = data_length;
+    file->index = data_length;
+    file->flags = FS_FILE_FLAGS_HEADER_INCLUDED;
+
+    return true;
+}
+
+
+bool http_rest_servo_gate_config(struct fs_file *file, int num_params, char *params[], char *values[]) {
+    // Mappings
+    // c0 (bool): servo_gate_enable
+    // c1 (float): shutter0_close_duty_cycle
+    // c2 (float): shutter0_open_duty_cycle
+    // c3 (float): shutter1_close_duty_cycle
+    // c4 (float): shutter1_open_duty_cycle
+    // c5 (float): shutter_close_speed_pct_s
+    // c6 (float): shutter_open_speed_pct_s
+    // ee (bool): save_to_eeprom
+
+    static char servo_gate_json_buffer[256];
+    bool save_to_eeprom = false;
+
+
+    // Control
+    for (int idx = 0; idx < num_params; idx += 1) {
+        if (strcmp(params[idx], "c0") == 0) {
+            bool enable = string_to_boolean(values[idx]);
+            servo_gate.eeprom_servo_gate_config.servo_gate_enable = enable;
+        }
+        else if (strcmp(params[idx], "c1") == 0) {
+            servo_gate.eeprom_servo_gate_config.shutter0_close_duty_cycle = strtof(values[idx], NULL);;
+        }
+        else if (strcmp(params[idx], "c2") == 0) {
+            servo_gate.eeprom_servo_gate_config.shutter0_open_duty_cycle = strtof(values[idx], NULL);;
+        }
+        else if (strcmp(params[idx], "c3") == 0) {
+            servo_gate.eeprom_servo_gate_config.shutter1_close_duty_cycle = strtof(values[idx], NULL);;
+        }
+        else if (strcmp(params[idx], "c4") == 0) {
+            servo_gate.eeprom_servo_gate_config.shutter1_open_duty_cycle = strtof(values[idx], NULL);;
+        }
+        else if (strcmp(params[idx], "c5") == 0) {
+            servo_gate.eeprom_servo_gate_config.shutter_close_speed_pct_s = strtof(values[idx], NULL);;
+        }
+        else if (strcmp(params[idx], "c6") == 0) {
+            servo_gate.eeprom_servo_gate_config.shutter_open_speed_pct_s = strtof(values[idx], NULL);;
+        }
+        else if (strcmp(params[idx], "ee") == 0) {
+            save_to_eeprom = string_to_boolean(values[idx]);
+        }
+    }
+
+    // Perform action
+    if (save_to_eeprom) {
+        servo_gate_config_save();  // Note: this will save settings for both
+    }
+    
+    // Response
+    snprintf(servo_gate_json_buffer, 
+             sizeof(servo_gate_json_buffer),
+             "%s"
+             "{\"c0\":%s,\"c1\":%0.3f,\"c2\":%0.3f,\"c3\":%0.3f,\"c4\":%0.3f,\"c5\":%0.3f,\"c6\":%0.3f}",
+             http_json_header,
+             boolean_to_string(servo_gate.eeprom_servo_gate_config.servo_gate_enable),
+             servo_gate.eeprom_servo_gate_config.shutter0_close_duty_cycle,
+             servo_gate.eeprom_servo_gate_config.shutter0_open_duty_cycle,
+             servo_gate.eeprom_servo_gate_config.shutter1_close_duty_cycle,
+             servo_gate.eeprom_servo_gate_config.shutter1_open_duty_cycle,
+             servo_gate.eeprom_servo_gate_config.shutter_close_speed_pct_s,
+             servo_gate.eeprom_servo_gate_config.shutter_open_speed_pct_s);
+
+    size_t data_length = strlen(servo_gate_json_buffer);
+    file->data = servo_gate_json_buffer;
+    file->len = data_length;
+    file->index = data_length;
+    file->flags = FS_FILE_FLAGS_HEADER_INCLUDED;
+
+    return true;
+}
diff --git a/src/servo_gate.h b/src/servo_gate.h
new file mode 100644
index 0000000..ee29512
--- /dev/null
+++ b/src/servo_gate.h
@@ -0,0 +1,59 @@
+#ifndef SERVO_GATE_H_
+#define SERVO_GATE_H_
+
+#include <stdint.h>
+#include <FreeRTOS.h>
+#include <queue.h>
+#include <semphr.h>
+#include "http_rest.h"
+
+#define EEPROM_SERVO_GATE_CONFIG_REV                     1              // 16 byte 
+
+typedef enum {
+    GATE_DISABLED = 0,
+    GATE_CLOSE,
+    GATE_OPEN,
+} gate_state_t;
+
+
+typedef struct {
+    uint16_t servo_gate_config_rev;
+    bool servo_gate_enable;
+    float shutter0_close_duty_cycle;
+    float shutter0_open_duty_cycle;
+    float shutter1_close_duty_cycle;
+    float shutter1_open_duty_cycle;
+    float shutter_close_speed_pct_s;  // Per shutter speed (percentage per second)
+    float shutter_open_speed_pct_s;  // Per shutter speed (percentage per second)
+} eeprom_servo_gate_config_t;
+
+
+typedef struct {
+    eeprom_servo_gate_config_t eeprom_servo_gate_config;
+    gate_state_t gate_state;
+
+    // RTOS control
+    TaskHandle_t control_task_handler;
+    QueueHandle_t control_queue;
+    SemaphoreHandle_t move_ready_semphore;
+} servo_gate_t;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool servo_gate_init(void);
+bool servo_gate_config_save(void);
+bool http_rest_servo_gate_state(struct fs_file *file, int num_params, char *params[], char *values[]);
+bool http_rest_servo_gate_config(struct fs_file *file, int num_params, char *params[], char *values[]);
+const char * gate_state_to_string(gate_state_t);
+
+void servo_gate_set_state(gate_state_t, bool);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif  // SERVO_GATE_H_
\ No newline at end of file
diff --git a/targets/raspberrypi_pico_config.h b/targets/raspberrypi_pico_config.h
index ae1f21a..811b4e1 100644
--- a/targets/raspberrypi_pico_config.h
+++ b/targets/raspberrypi_pico_config.h
@@ -46,5 +46,8 @@
 #define EEPROM_SCL_PIN 11
 #define EEPROM_ADDR 0x0
 
+#define SERVO0_PWM_PIN 26
+#define SERVO1_PWM_PIN 27
+#define SERVO_PWM_SLICE_NUM 5
 
 #endif  // RASPBERRYPI_PICO_CONFIG_H_
\ No newline at end of file
diff --git a/targets/raspberrypi_pico_w_config.h b/targets/raspberrypi_pico_w_config.h
index a47399a..8d7b39c 100644
--- a/targets/raspberrypi_pico_w_config.h
+++ b/targets/raspberrypi_pico_w_config.h
@@ -48,5 +48,8 @@
 #define EEPROM_SCL_PIN 11
 #define EEPROM_ADDR 0x50
 
+#define SERVO0_PWM_PIN 26
+#define SERVO1_PWM_PIN 27
+#define SERVO_PWM_SLICE_NUM 5
 
 #endif  // RASPBERRYPI_PICO_W_CONFIG_H_
\ No newline at end of file
diff --git a/tests/web_test.py b/tests/web_test.py
index 0cd2a81..999ac43 100644
--- a/tests/web_test.py
+++ b/tests/web_test.py
@@ -112,6 +112,11 @@ def rest_neopixel_led_config():
 def rest_button_config():
     return {"b0":True}
 
+@app.route('/rest/servo_gate_config')
+def rest_servo_gate_config():
+    return {"c0":True,"c1":0.050,"c2":0.125}
+
+
 
 @app.route('/rest/system_control')
 def rest_system_control():