rpi_gpio 0.1.2

data/ext/rpi_gpio/event_gpio.h

@@ -0,0 +1,40 @@
+/*
+Original code by Ben Croston modified for Ruby by Nick Lowery
+(github.com/clockvapor)
+Copyright (c) 2014-2015 Nick Lowery
+
+Copyright (c) 2013-2014 Ben Croston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#define NO_EDGE      0
+#define RISING_EDGE  1
+#define FALLING_EDGE 2
+#define BOTH_EDGE    3
+
+int add_edge_detect(unsigned int gpio, unsigned int edge, int bouncetime);
+void remove_edge_detect(unsigned int gpio);
+int add_edge_callback(unsigned int gpio, void (*func)(unsigned int gpio));
+int event_detected(unsigned int gpio);
+int gpio_event_added(unsigned int gpio);
+int event_initialise(void);
+void event_cleanup(unsigned int gpio);
+void event_cleanup_all(void);
+int blocking_wait_for_edge(unsigned int gpio, unsigned int edge, int bouncetime);

data/ext/rpi_gpio/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+extension_name = 'rpi_gpio'
+dir_config(extension_name)
+create_makefile(extension_name)

data/ext/rpi_gpio/rb_gpio.c

@@ -0,0 +1,405 @@
+/*
+Original code by Ben Croston modified for Ruby by Nick Lowery
+(github.com/clockvapor)
+Copyright (c) 2014-2015 Nick Lowery
+
+Copyright (c) 2013-2014 Ben Croston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "rb_gpio.h"
+
+extern VALUE m_GPIO;
+int gpio_warnings = 1;
+
+void define_gpio_module_stuff(void)
+{
+  int i;
+
+  rb_define_singleton_method(m_GPIO, "setup", GPIO_setup, 2);
+  rb_define_singleton_method(m_GPIO, "clean_up", GPIO_clean_up, -1);
+  rb_define_singleton_method(m_GPIO, "set_numbering", GPIO_set_numbering, 1);
+  rb_define_singleton_method(m_GPIO, "set_high", GPIO_set_high, 1);
+  rb_define_singleton_method(m_GPIO, "set_low", GPIO_set_low, 1);
+  rb_define_singleton_method(m_GPIO, "high?", GPIO_test_high, 1);
+  rb_define_singleton_method(m_GPIO, "low?", GPIO_test_low, 1);
+  rb_define_singleton_method(m_GPIO, "set_warnings", GPIO_set_warnings, 1);
+  define_constants(m_GPIO);
+
+  for (i=0; i<54; i++)
+    gpio_direction[i] = -1;
+
+   // detect board revision and set up accordingly
+   revision = get_rpi_revision();
+   if (revision == -1)
+   {
+      rb_raise(rb_eRuntimeError, "this gem can only be run on a Raspberry Pi");
+      setup_error = 1;
+      return;
+   } 
+   else if (revision == 1)
+      pin_to_gpio = &pin_to_gpio_rev1;
+   else if (revision == 2)
+      pin_to_gpio = &pin_to_gpio_rev2;
+   else // assume model B+ or A+
+      pin_to_gpio = &pin_to_gpio_rev3;
+      
+   rb_define_const(m_GPIO, "RPI_REVISION", INT2NUM(revision));
+}
+
+int mmap_gpio_mem(void)
+{
+   int result;
+
+   if (module_setup)
+      return 0;
+
+   result = setup();
+   if (result == SETUP_DEVMEM_FAIL)
+   {
+      rb_raise(rb_eRuntimeError, "no access to /dev/mem; try running as "
+        "root");
+      return 1;
+   } 
+   else if (result == SETUP_MALLOC_FAIL) 
+   {
+      rb_raise(rb_eNoMemError, "out of memory");
+      return 2;
+   }
+   else if (result == SETUP_MMAP_FAIL) 
+   {
+      rb_raise(rb_eRuntimeError, "mmap of GPIO registers failed");
+      return 3;
+   }
+   else // result == SETUP_OK
+   {
+      module_setup = 1;
+      return 0;
+   }
+}
+
+// RPi::GPIO.clean_up(channel=nil)
+// clean up everything by default; otherwise, clean up given channel
+VALUE GPIO_clean_up(int argc, VALUE *argv, VALUE self)
+{
+   int i;
+   int found = 0;
+   int channel = -666; // lol, quite a flag
+   unsigned int gpio;
+   
+   if (argc == 1)
+      channel = NUM2INT(argv[0]);
+   else if (argc > 1)
+   {
+      rb_raise(rb_eArgError, "wrong number of arguments; 0 for all pins, 1 for a specific pin");
+      return Qnil;
+   }
+   
+   if (channel != -666 && get_gpio_number(channel, &gpio))
+      return Qnil;
+
+   if (module_setup && !setup_error)
+   {
+      if (channel == -666)
+      {
+         // clean up any /sys/class exports
+         event_cleanup_all();
+
+         // set everything back to input
+         for (i=0; i<54; i++) {
+            if (gpio_direction[i] != -1)
+            {
+               setup_gpio(i, INPUT, PUD_OFF);
+               gpio_direction[i] = -1;
+               found = 1;
+            }
+         }
+      }
+      else
+      {
+         // clean up any /sys/class exports
+         event_cleanup(gpio);
+
+         // set everything back to input
+         if (gpio_direction[gpio] != -1)
+         {
+            setup_gpio(gpio, INPUT, PUD_OFF);
+            gpio_direction[gpio] = -1;
+            found = 1;
+         }
+      }
+   }
+
+   // check if any channels set up - if not warn about misuse of GPIO.clean_up()
+   if (!found && gpio_warnings)
+      rb_warn("no channels have been set up yet; nothing to clean up");
+   
+   return Qnil;
+}
+
+// RPI::GPIO.setup(channel, hash(:as => {:input, :output}, :pull => {:off, 
+// :down, :up}(default :off)))
+VALUE GPIO_setup(VALUE self, VALUE channel, VALUE hash)
+{
+  unsigned int gpio;
+  int chan = -1;
+  const char *direction_str = NULL;
+  int direction;
+  VALUE pud_val = Qnil;
+  const char *pud_str = NULL;
+  int pud = PUD_OFF + PY_PUD_CONST_OFFSET;
+  int func;
+  
+  // func to set up channel stored in channel variable
+  int setup_one(void)
+  {
+    if (get_gpio_number(chan, &gpio))
+      return 0;
+
+    // warn if the channel is already in use (not from this program).
+    func = gpio_function(gpio);
+    if (gpio_warnings &&
+      ((func != 0 && func != 1) ||
+      (gpio_direction[gpio] == -1 && func == 1)))
+    {
+      rb_warn("this channel is already in use... continuing anyway. "
+        "use RPi::GPIO.set_warnings(false) to disable warnings");
+    }
+
+      setup_gpio(gpio, direction, pud);
+      gpio_direction[gpio] = direction;
+      return 1;
+  }
+
+  // parse arguments
+  
+  // channel
+  chan = NUM2INT(channel);
+  
+  // pin direction
+  direction_str = rb_id2name(rb_to_id(rb_hash_aref(hash, ID2SYM(rb_intern("as"))
+    )));
+  if (strcmp("input", direction_str) == 0)
+    direction = INPUT;
+  else if (strcmp("output", direction_str) == 0)
+    direction = OUTPUT;
+  else
+    rb_raise(rb_eArgError, "invalid pin direction; must be :input or :output");   
+   
+  // pull up, down, or off
+  pud_val = rb_hash_aref(hash, ID2SYM(rb_intern("pull")));
+  if (pud_val != Qnil)
+  {
+    if (direction == OUTPUT)
+    {
+      rb_raise(rb_eArgError, "output pin cannot use pull argument");
+      return Qnil;
+    }
+  
+    pud_str = rb_id2name(rb_to_id(pud_val));
+    if (strcmp("down", pud_str) == 0)
+      pud = PUD_DOWN + PY_PUD_CONST_OFFSET;
+    else if (strcmp("up", pud_str) == 0)
+      pud = PUD_UP + PY_PUD_CONST_OFFSET;
+    else if (strcmp("off", pud_str) == 0)
+      pud = PUD_OFF + PY_PUD_CONST_OFFSET;
+    else
+    {
+      rb_raise(rb_eArgError, "invalid pin pull direction; must be :up, :down, "
+        "or :off");
+      return Qnil;
+    }
+  }
+  else
+    pud = PUD_OFF + PY_PUD_CONST_OFFSET;
+
+  // check module has been imported cleanly
+  if (setup_error)
+  {
+    rb_raise(rb_eRuntimeError, "gem not imported correctly");
+    return Qnil;
+  }
+
+  if (mmap_gpio_mem())
+    return Qnil;
+
+  if (direction != INPUT && direction != OUTPUT)
+  {
+    rb_raise(rb_eArgError, "invalid direction");
+    return Qnil;
+  }
+
+  if (direction == OUTPUT)
+    pud = PUD_OFF + PY_PUD_CONST_OFFSET;
+  pud -= PY_PUD_CONST_OFFSET;
+
+  if (!setup_one())
+    return Qnil;
+
+  return self;
+}
+
+// RPi::GPIO.set_numbering(mode)
+VALUE GPIO_set_numbering(VALUE self, VALUE mode)
+{
+  const char *mode_str = NULL;
+  
+  if (TYPE(mode) == T_SYMBOL)
+    mode_str = rb_id2name(rb_to_id(mode));
+  else
+    mode_str = RSTRING_PTR(mode);
+  
+  if (strcmp(mode_str, "board") == 0)
+    gpio_mode = BOARD;
+  else if (strcmp(mode_str, "bcm") == 0)
+    gpio_mode = BCM;
+  else
+    rb_raise(rb_eArgError, "invalid numbering mode; must be :board or :bcm");
+      
+  if (setup_error)
+  {
+    rb_raise(rb_eRuntimeError, "gem not imported correctly");
+    return Qnil;
+  }
+
+  if (gpio_mode != BOARD && gpio_mode != BCM)
+  {
+    rb_raise(rb_eArgError, "invalid mode");
+    return Qnil;
+  }
+
+  if (revision == 0 && gpio_mode == BOARD)
+  {
+    rb_raise(rb_eRuntimeError, ":board numbering system not applicable on "
+      "computer module");
+    return Qnil;
+  }
+
+  return self;
+}
+
+// RPi::GPIO.set_high(channel)
+VALUE GPIO_set_high(VALUE self, VALUE channel)
+{
+  unsigned int gpio;
+  int chan = -1;
+
+  // func to output value var on channel var
+  int output(void)
+  {
+    if (get_gpio_number(chan, &gpio))
+      return 0;
+
+    if (gpio_direction[gpio] != OUTPUT)
+    {
+      rb_raise(rb_eRuntimeError, "GPIO channel not set as output");
+      return 0;
+    }
+
+    if (check_gpio_priv())
+      return 0;
+
+    output_gpio(gpio, 1);
+    return 1;
+  }
+
+  chan = NUM2INT(channel);
+  if (!output())
+    return Qnil;
+
+  return self;
+}
+
+// RPi::GPIO.set_low(channel)
+VALUE GPIO_set_low(VALUE self, VALUE channel)
+{
+  unsigned int gpio;
+  int chan = -1;
+
+  // func to output value var on channel var
+  int output(void)
+  {
+    if (get_gpio_number(chan, &gpio))
+      return 0;
+
+    if (gpio_direction[gpio] != OUTPUT)
+    {
+      rb_raise(rb_eRuntimeError, "GPIO channel not set as output");
+      return 0;
+    }
+
+    if (check_gpio_priv())
+      return 0;
+
+    output_gpio(gpio, 0);
+    return 1;
+  }
+
+  chan = NUM2INT(channel);
+  if (!output())
+    return Qnil;
+
+  return self;
+}
+
+// RPi::GPIO.high?(channel)
+VALUE GPIO_test_high(VALUE self, VALUE channel)
+{
+  unsigned int gpio;
+  
+  if (get_gpio_number(NUM2INT(channel), &gpio))
+    return Qnil;
+
+  if (gpio_direction[gpio] != INPUT && gpio_direction[gpio] != OUTPUT)
+  {
+    rb_raise(rb_eRuntimeError, "you must setup() the GPIO channel first");
+    return Qnil;
+  }
+
+  if (check_gpio_priv())
+    return Qnil;
+  
+  if (input_gpio(gpio))
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+// RPi::GPIO.low?(channel)
+VALUE GPIO_test_low(VALUE self, VALUE channel)
+{
+  VALUE val = GPIO_test_high(self, channel);
+  if (val == Qtrue) return Qfalse;
+  else if (val == Qfalse) return Qtrue;
+  else return Qnil;
+}
+
+// RPi::GPIO.set_warnings(state)
+VALUE GPIO_set_warnings(VALUE self, VALUE setting)
+{
+  if (setup_error)
+  {
+    rb_raise(rb_eRuntimeError, "gem not imported correctly");
+    return Qnil;
+  }
+
+  gpio_warnings = NUM2INT(setting);
+  return self;
+}

data/ext/rpi_gpio/rb_gpio.h

@@ -0,0 +1,44 @@
+/*
+Original code by Ben Croston modified for Ruby by Nick Lowery
+(github.com/clockvapor)
+Copyright (c) 2014-2015 Nick Lowery
+
+Copyright (c) 2013-2014 Ben Croston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "ruby.h"
+#include "c_gpio.h"
+#include "event_gpio.h"
+#include "cpuinfo.h"
+#include "common.h"
+#include "constants.h"
+#include "rb_pwm.h"
+
+void define_gpio_module_stuff(void);
+int mmap_gpio_mem(void);
+VALUE GPIO_clean_up(int argc, VALUE *argv, VALUE self);
+VALUE GPIO_setup(VALUE self, VALUE channel, VALUE hash);
+VALUE GPIO_set_numbering(VALUE self, VALUE mode);
+VALUE GPIO_set_high(VALUE self, VALUE channel);
+VALUE GPIO_set_low(VALUE self, VALUE channel);
+VALUE GPIO_test_high(VALUE self, VALUE channel);
+VALUE GPIO_test_low(VALUE self, VALUE channel);
+VALUE GPIO_set_warnings(VALUE self, VALUE setting);

data/ext/rpi_gpio/rb_pwm.c

@@ -0,0 +1,131 @@
+/*
+Original code by Ben Croston modified for Ruby by Nick Lowery
+(github.com/clockvapor)
+Copyright (c) 2014-2015 Nick Lowery
+
+Copyright (c) 2013-2014 Ben Croston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "rb_pwm.h"
+
+extern VALUE m_GPIO;
+VALUE c_PWM = Qnil;
+
+void define_pwm_class_stuff(void)
+{
+  c_PWM = rb_define_class_under(m_GPIO, "PWM", rb_cObject);
+  rb_define_method(c_PWM, "initialize", PWM_initialize, 2);
+  rb_define_method(c_PWM, "start", PWM_start, 1);
+  rb_define_method(c_PWM, "pin", PWM_get_pin, 0);
+  rb_define_method(c_PWM, "duty_cycle", PWM_get_duty_cycle, 0);
+  rb_define_method(c_PWM, "duty_cycle=", PWM_set_duty_cycle, 1);
+  rb_define_method(c_PWM, "frequency", PWM_get_frequency, 0);
+  rb_define_method(c_PWM, "frequency=", PWM_set_frequency, 1);
+  rb_define_method(c_PWM, "stop", PWM_stop, 0);
+}
+
+// RPi::GPIO::PWM#initialize
+VALUE PWM_initialize(VALUE self, VALUE channel, VALUE frequency)
+{
+  int chan;
+  unsigned int gpio;
+  
+  chan = NUM2INT(channel);
+  
+  // convert channel to gpio
+  if (get_gpio_number(chan, &gpio))
+    return Qnil;
+  
+  // ensure channel is set as output
+  if (gpio_direction[gpio] != OUTPUT)
+  {
+    rb_raise(rb_eRuntimeError, "you must setup() the GPIO channel as output "
+      "first");
+      return Qnil;
+  }
+  
+  rb_iv_set(self, "@pin", UINT2NUM(gpio));
+  PWM_set_frequency(self, frequency);
+  return self;
+}
+
+// RPi::GPIO::PWM#start
+VALUE PWM_start(VALUE self, VALUE duty_cycle)
+{
+  pwm_start(NUM2UINT(rb_iv_get(self, "@pin")));
+  PWM_set_duty_cycle(self, duty_cycle);
+  return self;
+}
+
+// RPi::GPIO::PWM#pin
+VALUE PWM_get_pin(VALUE self)
+{
+  return rb_iv_get(self, "@pin");
+}
+
+// RPi::GPIO::PWM#duty_cycle
+VALUE PWM_get_duty_cycle(VALUE self)
+{
+  return rb_iv_get(self, "@duty_cycle");
+}
+
+// RPi::GPIO::PWM#duty_cycle=
+VALUE PWM_set_duty_cycle(VALUE self, VALUE duty_cycle)
+{
+  float dc = (float) NUM2DBL(duty_cycle);
+  if (dc < 0.0f || dc > 100.0f)
+  {
+    rb_raise(rb_eArgError, "duty cycle must be between 0.0 and 100.0");
+    return Qnil;
+  }
+  
+  rb_iv_set(self, "@duty_cycle", duty_cycle);
+  pwm_set_duty_cycle(NUM2UINT(rb_iv_get(self, "@pin")), dc);
+  return self;
+}
+
+// RPi::GPIO::PWM#frequency
+VALUE PWM_get_frequency(VALUE self)
+{
+  return rb_iv_get(self, "@frequency");
+}
+
+// RPi::GPIO::PWM#frequency=
+VALUE PWM_set_frequency(VALUE self, VALUE frequency)
+{
+  float freq = (float) NUM2DBL(frequency);
+  if (freq <= 0.0f)
+  {
+    rb_raise(rb_eArgError, "frequency must be greater than 0.0");
+    return Qnil;
+  }
+  
+  rb_iv_set(self, "@frequency", frequency);
+  pwm_set_frequency(NUM2UINT(rb_iv_get(self, "@pin")), freq);
+  return self;
+}
+
+// RPi::GPIO::PWM#stop
+VALUE PWM_stop(VALUE self)
+{
+  pwm_stop(NUM2UINT(rb_iv_get(self, "@pin")));
+  return self;
+}

data/ext/rpi_gpio/rb_pwm.h

@@ -0,0 +1,40 @@
+/*
+Original code by Ben Croston modified for Ruby by Nick Lowery
+(github.com/clockvapor)
+Copyright (c) 2014-2015 Nick Lowery
+
+Copyright (c) 2013-2014 Ben Croston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "ruby.h"
+#include "soft_pwm.h"
+#include "common.h"
+#include "c_gpio.h"
+
+void define_pwm_class_stuff(void);
+VALUE PWM_initialize(VALUE self, VALUE channel, VALUE frequency);
+VALUE PWM_start(VALUE self, VALUE duty_cycle);
+VALUE PWM_get_pin(VALUE self);
+VALUE PWM_get_duty_cycle(VALUE self);
+VALUE PWM_set_duty_cycle(VALUE self, VALUE duty_cycle);
+VALUE PWM_get_frequency(VALUE self);
+VALUE PWM_set_frequency(VALUE self, VALUE frequency);
+VALUE PWM_stop(VALUE self);