diff --git a/doc/eluadoc/arch_platform_adc.lua b/doc/eluadoc/arch_platform_adc.lua
index 410d2f9..29c41a8 100644
--- a/doc/eluadoc/arch_platform_adc.lua
+++ b/doc/eluadoc/arch_platform_adc.lua
@@ -23,104 +23,65 @@ data_en =
       ret = "1 if the ADC interface exists, 0 otherwise"
     },
     
-    { sig = "u32 #platform_adc_op#( unsigned id, int op, u32 data );",
-      desc = "Executes an operation on an ADC channel",
-      args = 
+    { sig = "u32 #platform_adc_get_maxval#( unsigned id );",
+      desc = "Gets the maximum conversion value the channel may supply (based on channel resolution)",
+      args = "$id$ - ADC channel ID",
+      ret = "the maximum possible conversion value"
+    },
+
+    { sig = "u32 #platform_adc_set_smoothing#( unsigned id, u32 length );",
+      desc = "Sets the length of the moving average smoothing filter",
+      args =
       {
         "$id$ - ADC channel ID",
-        [[$op$ - the operation that must be executed. It can take any value from @#adc_operations@this enum@, as follows:
-  <ul>
-    <li>$PLATFORM_ADC_GET_MAXVAL$: get the maximum conversion value the channel may supply (based on channel resolution)</li>
-    <li>$PLATFORM_ADC_SET_SMOOTHING$: sets the length of the moving average smoothing filter to $data$ </li>  
-    <li>$PLATFORM_ADC_SET_BLOCKING$: sets whether or not sample requests should block, waiting for additional samples</li>
-    <li>$PLATFORM_ADC_IS_DONE$: checks whether sampling has completed</li>
-    <li>$PLATFORM_ADC_OP_SET_TIMER$: selects a timer to control sampling frequency</li>
-    <li>$PLATFORM_ADC_OP_SET_CLOCK$: set the frequency of sample acquisition</li>
-  </ul>]],
-        "$data$ - when used with $op$ == $PLATFORM_ADC_SET_SMOOTHING$, specifies the length of the moving average filter (must be a power of 2). If it is 1, filter is disabled.",
-        "$data$ - when used with $op$ == $PLATFORM_ADC_SET_BLOCKING$, specifies whether or not sample requests block.  If 1, requests will block until enough samples are available or sampling has ended. If 0, requests will return immediately with up to the number of samples requested.",
-        "$data$ - when used with $op$ == $PLATFORM_ADC_OP_SET_TIMER$, specifies the timer to use to control sampling frequency.",
-        "$data$ - when used with $op$ == $PLATFORM_ADC_OP_SET_CLOCK$, specifies the frequency of sample collection in Hz (number of samples per second). If 0, timer is not used and samples are acquired as quickly as possible."
-      },
-      ret = 
-      {
-        "the maximum possible conversion value when $op$ == $PLATFORM_ADC_GET_MAXVAL$",
-        "whether or not sampling has completed (1: yes, 0: no) when $op$ == $PLATFORM_ADC_IS_DONE$. This will return 1 (yes), if no samples have been requested.",
-        "the actual frequency of acquisition that will be used when $op$ == $PLATFORM_ADC_OP_SET_CLOCK$",
-        "irellevant for other operations"
-      }  
+        "$length$ - the length of the moving average filter (must be a power of 2). If it is 1, the filter is disabled.",
+      }
+      ret = "$PLATFORM_OK$ if the operation succeeded, $PLATFORM_ERR$ otherwise."
     },
-    
-    { sig = "int #platform_adc_check_timer_id#( unsigned id, unsigned timer_id );",
-      desc = "Checks whether a timer may be used with a particular ADC channel",
-      args = 
+
+    { sig = "void #platform_adc_set_blocking#( unsigned id, u32 mode );",
+      desc = "Sets whether or not sample requests should block, waiting for additional samples",
+      args =
       {
         "$id$ - ADC channel ID",
-        "$timer_id$ - Timer ID",
-      },
-      ret = "1 if the timer may be used to trigger the ADC channel, 0 if not",
-    }
-  }
-}
-
-data_pt = 
-{
-  -- Menu name
-  menu_name = "ADC",
-
-  -- Title
-  title = "eLua API - ADC",
-
-  -- Overview
-  overview = "Interfaceamento com as funcões do ADC da MCU.",
+        "$mode$ - specifies whether or not sample requests block.  If 1, requests will block until enough samples are available or sampling has ended. If 0, requests will return immediately with up to the number of samples requested.",
+      }
+    },
 
-  -- Functions
-  funcs = 
-  {
-    { sig = "int #platform_adc_exists#( unsigned id );",
-      desc = [[Checa se a plataforma possui hardware para o Conversor AD especificado no argumento. Implementado em %src/common.c%, utiliza a  macro $NUM_ADC$ que deve estar definida no arquivo $platform_conf.h$ da plataforma em questão. (veja @arch_overview.html#platforms@here@ para detalhes). Por exemplo:</p>
-  ~#define NUM_ADC   1      $// A Plataforma possui uma interface para ADC$~<p> ]],
-      args = "$id$ - ADC ID",
-      ret = "1 se a interface do ADC existir, 0 em caso contrário"
+    { sig = "void #platform_adc_is_done#( unsigned id );",
+      desc = "Checks whether sampling has completed",
+      args = "$id$ - ADC channel ID",
+      ret = "1 if sampling has completed, 0 if not",
     },
-    
-    { sig = "u32 #platform_adc_op#( unsigned id, int op, u32 data );",
-      desc = "Executes an operation on an ADC channel",
-      args = 
+
+    { sig = "void #platform_adc_set_timer#( unsigned id, u32 timer );",
+      desc = "Selects a timer to control the sampling frequency",
+      args =
       {
-        "$id$ - ID do canal ADC",
-        [[$op$ - A operação que deve ser executada. Valores possíveis em  @#adc_operations@this enum@, conforme:
-  <ul>
-    <li>$PLATFORM_ADC_GET_MAXVAL$: Pega o maior valor de conversão que o canal pode fornecer, dependendo de sua resolução.</li>
-    <li>$PLATFORM_ADC_SET_SMOOTHING$: Seta o tamanho do filtro atenuador de média móvel em $data$ </li>  
-    <li>$PLATFORM_ADC_SET_BLOCKING$: Seta se a amostragem deve aguardar novos valores (blocking)</li>
-    <li>$PLATFORM_ADC_IS_DONE$: Checa se a amostragem foi completada</li>
-    <li>$PLATFORM_ADC_OP_SET_TIMER$: Seleciona um Timer para o controle da amostragem</li>
-    <li>$PLATFORM_ADC_OP_SET_CLOCK$: Seta a frequência de amostragem</li>
-  </ul>]],
-        "$data$ - quando usada com $op$ == $PLATFORM_ADC_SET_SMOOTHING$, especifica o tamanho do filtro de média móvel (deve ser potência de 2). O valor 1 desabilita o filtro.",
-        "$data$ - quando usada com $op$ == $PLATFORM_ADC_SET_BLOCKING$, especifica se a amostragem é blocking ou não.  Se 1, os pedidos só retornam quando as amostras tiverem sido obtidas ou a amostragem encerrada. Se 0, os pedidos retornam imediatamente, com o número de amostras já obtidas.",
-        "$data$ - quando usada com $op$ == $PLATFORM_ADC_OP_SET_TIMER$, especifica o Timer a ser usado para o controle da frequência de amostragem.",
-        "$data$ - quando usada com $op$ == $PLATFORM_ADC_OP_SET_CLOCK$, especifica a frequência de amostragem em Hz (número de amostras por segundo). Se 0, nenhum Timer é usado e a amostragem é feita o mais rapidamente possível."
-      },
-      ret = 
+        "$id$ - ADC channel ID",
+	"$timer$ - the ID of the timer to use to control the sampling frequency.",
+      }
+    },
+
+    { sig = "void #platform_adc_set_clock#( unsigned id, u32 freq );",
+      desc = "Set the frequency of sample acquisition",
+      args =
       {
-        "O maior valor possível de ser obtido do conversor, quando $op$ == $PLATFORM_ADC_GET_MAXVAL$",
-        "Flag informando se a conversão foi completada (1: sim, 0: não), quando $op$ == $PLATFORM_ADC_IS_DONE$. Também retorna 1 se nenhuma conversão foi solicitada.",
-        "A frequência real de conversão que sera usada, quando $op$ == $PLATFORM_ADC_OP_SET_CLOCK$",
-        "Indefinido para outras operações."
-      }  
+        "$id$ - ADC channel ID",
+	"$freq$ - the frequency of sample collection in Hz (number of samples per second). If 0, the timer is not used and samples are acquired as quickly as possible.",
+      }
     },
-    
+
     { sig = "int #platform_adc_check_timer_id#( unsigned id, unsigned timer_id );",
-      desc = "Checa see um Timer pode ser usado com um ADC específico",
+      desc = "Checks whether a timer may be used with a particular ADC channel",
       args = 
       {
-        "$id$ - ADC ID",
+        "$id$ - ADC channel ID",
         "$timer_id$ - Timer ID",
       },
-      ret = "1 se o Timer pode ser usado para trigar um ADC. 0 em caso contrário",
+      ret = "1 if the timer may be used to trigger the ADC channel, 0 if not",
     }
   }
 }
 
+data_pt = data_en
diff --git a/inc/platform.h b/inc/platform.h
index 86727db..2554315 100644
--- a/inc/platform.h
+++ b/inc/platform.h
@@ -235,17 +235,6 @@ u32 platform_cpu_get_frequency();
 // *****************************************************************************
 // The platform ADC functions
 
-enum
-{
-  PLATFORM_ADC_GET_MAXVAL,
-  PLATFORM_ADC_SET_SMOOTHING,
-  PLATFORM_ADC_SET_BLOCKING,
-  PLATFORM_ADC_SET_FREERUNNING,
-  PLATFORM_ADC_IS_DONE,
-  PLATFORM_ADC_OP_SET_TIMER,
-  PLATFORM_ADC_OP_SET_CLOCK,
-};
-
 // Functions requiring platform-specific implementation
 int platform_adc_update_sequence();
 int platform_adc_start_sequence();
@@ -253,9 +242,15 @@ void platform_adc_stop( unsigned id );
 u32 platform_adc_setclock( unsigned id, u32 frequency);
 
 // ADC Common Functions
-int platform_adc_exists( unsigned id );
-int platform_adc_check_timer_id( unsigned id, unsigned timer_id );
-u32 platform_adc_op( unsigned id, int op, u32 data );
+int  platform_adc_exists( unsigned id );
+int  platform_adc_check_timer_id( unsigned id, unsigned timer_id );
+u32  platform_adc_maxval( unsigned id );
+u32  platform_adc_set_smoothing( unsigned id, u32 length );
+void platform_adc_set_blocking( unsigned id, u32 mode );
+void platform_adc_set_freerunning( unsigned id, u32 mode );
+u32  platform_adc_is_done( unsigned id );
+void platform_adc_set_timer( unsigned id, u32 timer );
+u32  platform_adc_set_clock( unsigned id, u32 freq );
 
 // *****************************************************************************
 // I2C platform interface
diff --git a/src/common.c b/src/common.c
index 4902a05..ee8e874 100644
--- a/src/common.c
+++ b/src/common.c
@@ -294,47 +294,46 @@ int platform_adc_exists( unsigned id )
 
 #ifdef BUILD_ADC
 
-u32 platform_adc_op( unsigned id, int op, u32 data )
-{  
-  elua_adc_ch_state *s = adc_get_ch_state( id );
+u32 platform_adc_maxval( unsigned id )
+{
+  return pow( 2, ADC_BIT_RESOLUTION ) - 1;
+}
+
+u32 platform_adc_set_smoothing( unsigned id, u32 length )
+{
+  return adc_update_smoothing( id, ( u8 )intlog2( ( unsigned ) length ) );
+}
+
+void platform_adc_set_blocking( unsigned id, u32 mode )
+{
+  adc_get_ch_state( id )->blocking = mode;
+}
+
+void platform_adc_set_freerunning( unsigned id, u32 mode )
+{
+  adc_get_ch_state( id )->freerunning = mode;
+}
+
+u32 platform_adc_is_done( unsigned id )
+{
+  return adc_get_ch_state( id )->op_pending == 0;
+}
+
+void platform_adc_set_timer( unsigned id, u32 timer )
+{
   elua_adc_dev_state *d = adc_get_dev_state( 0 );
-  u32 res = 0;
 
-  switch( op )
-  {
-    case PLATFORM_ADC_GET_MAXVAL:
-      res = pow( 2, ADC_BIT_RESOLUTION ) - 1;
-      break;
-
-    case PLATFORM_ADC_SET_SMOOTHING:
-      res = adc_update_smoothing( id, ( u8 )intlog2( ( unsigned ) data ) );
-      break;
-      
-    case PLATFORM_ADC_SET_BLOCKING:
-      s->blocking = data;
-      break;
-      
-    case PLATFORM_ADC_IS_DONE:
-      res = ( s->op_pending == 0 );
-      break;
-    
-    case PLATFORM_ADC_OP_SET_TIMER:
-      if ( d->timer_id != data )
-        d->running = 0;
-      platform_adc_stop( id );
-      d->timer_id = data;
-      break;
-    
-    case PLATFORM_ADC_OP_SET_CLOCK:
-      res = platform_adc_setclock( id, data );
-      break;
-      
-    case PLATFORM_ADC_SET_FREERUNNING:
-      s->freerunning = data;
-      break;
-  }
-  return res;
+  if ( d->timer_id != timer )
+    d->running = 0;
+  platform_adc_stop( id );
+  d->timer_id = timer;
 }
+
+u32 platform_adc_set_clock( unsigned id, u32 freq )
+{
+  return platform_adc_setclock( id, freq );
+}
+
 #endif // #ifdef BUILD_ADC
 
 // ****************************************************************************
diff --git a/src/modules/adc.c b/src/modules/adc.c
index 867cb85..472b5d6 100644
--- a/src/modules/adc.c
+++ b/src/modules/adc.c
@@ -20,7 +20,7 @@ static int adc_maxval( lua_State* L )
   
   id = luaL_checkinteger( L, 1 );
   MOD_CHECK_ID( adc, id );
-  res = platform_adc_op( id, PLATFORM_ADC_GET_MAXVAL, 0 );
+  res = platform_adc_maxval( id );
   lua_pushinteger( L, res );
   return 1;
 }
@@ -41,8 +41,8 @@ static int adc_setclock( lua_State* L )
     MOD_CHECK_RES_ID( adc, id, timer, timer_id );
   }
 
-  platform_adc_op( id, PLATFORM_ADC_OP_SET_TIMER, timer_id );
-  clock = platform_adc_op( id, PLATFORM_ADC_OP_SET_CLOCK, clock );
+  platform_adc_set_timer( id, timer_id );
+  clock = platform_adc_setclock( id, clock );
   lua_pushinteger( L, clock );
   return 1;
 }
@@ -54,7 +54,7 @@ static int adc_isdone( lua_State* L )
     
   id = luaL_checkinteger( L, 1 );
   MOD_CHECK_ID( adc, id );
-  lua_pushinteger( L, platform_adc_op( id, PLATFORM_ADC_IS_DONE, 0 ) );
+  lua_pushinteger( L, platform_adc_is_done( id ) );
   return 1;
 }
 
@@ -66,7 +66,7 @@ static int adc_setblocking( lua_State* L )
   id = luaL_checkinteger( L, 1 );
   MOD_CHECK_ID( adc, id );
   mode = luaL_checkinteger( L, 2 );
-  platform_adc_op( id, PLATFORM_ADC_SET_BLOCKING, mode );
+  platform_adc_set_blocking( id, mode );
   return 0;
 }
 
@@ -81,7 +81,7 @@ static int adc_setsmoothing( lua_State* L )
   length = luaL_checkinteger( L, 2 );
   if ( !( length & ( length - 1 ) ) )
   {
-    res = platform_adc_op( id, PLATFORM_ADC_SET_SMOOTHING, length );
+    res = platform_adc_set_smoothing( id, length );
     if ( res == PLATFORM_ERR )
       return luaL_error( L, "Buffer allocation failed." );
     else
