rpi_gpio 0.4.0

data/ext/rpi_gpio/rb_gpio.h

@@ -0,0 +1,47 @@
+/*
+Original code by Ben Croston modified for Ruby by Nick Lowery
+(github.com/clockvapor)
+Copyright (c) 2014-2020 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 "rb_pwm.h"
+
+void define_gpio_module_stuff(void);
+int mmap_gpio_mem(void);
+int is_gpio_initialized(unsigned int gpio);
+int is_gpio_output(unsigned int gpio);
+int is_rpi(void);
+VALUE GPIO_clean_up(int argc, VALUE *argv, VALUE self);
+VALUE GPIO_reset(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,148 @@
+/*
+Original code by Ben Croston modified for Ruby by Nick Lowery
+(github.com/clockvapor)
+Copyright (c) 2014-2020 Nick Lowery
+
+Copyright (c) 2013-2018 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, "gpio", PWM_get_gpio, 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);
+  rb_define_method(c_PWM, "running?", PWM_get_running, 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;
+ 
+  // does soft pwm already exist on this channel?
+  if (pwm_exists(gpio))
+  {
+    rb_raise(rb_eRuntimeError, "a PWM object already exists for this GPIO channel");
+    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 with RPi::GPIO.setup CHANNEL, :as => :output");
+    return Qnil;
+  }
+  
+  rb_iv_set(self, "@gpio", UINT2NUM(gpio));
+  rb_iv_set(self, "@running", Qfalse);
+  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, "@gpio")));
+  PWM_set_duty_cycle(self, duty_cycle);
+  rb_iv_set(self, "@running", Qtrue);
+  return self;
+}
+
+// RPi::GPIO::PWM#gpio
+VALUE PWM_get_gpio(VALUE self)
+{
+  return rb_iv_get(self, "@gpio");
+}
+
+// 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, "@gpio")), 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, "@gpio")), freq);
+  return self;
+}
+
+// RPi::GPIO::PWM#stop
+VALUE PWM_stop(VALUE self)
+{
+  pwm_stop(NUM2UINT(rb_iv_get(self, "@gpio")));
+  rb_iv_set(self, "@running", Qfalse);
+  return self;
+}
+
+// RPi::GPIO::PWM#running?
+VALUE PWM_get_running(VALUE self)
+{
+  return rb_iv_get(self, "@running");
+}

data/ext/rpi_gpio/rb_pwm.h

@@ -0,0 +1,41 @@
+/*
+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_gpio(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);
+VALUE PWM_get_running(VALUE self);

data/ext/rpi_gpio/rpi_gpio.c

@@ -0,0 +1,45 @@
+/*
+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 "rpi_gpio.h"
+#include "rb_pwm.h"
+#include "rb_gpio.h"
+
+VALUE m_RPi = Qnil;
+VALUE m_GPIO = Qnil;
+
+void Init_rpi_gpio()
+{
+  define_modules();
+  define_gpio_module_stuff();
+  define_pwm_class_stuff();
+}
+
+void define_modules(void)
+{
+  m_RPi = rb_define_module("RPi");
+  m_GPIO = rb_define_module_under(m_RPi, "GPIO");
+}

data/ext/rpi_gpio/rpi_gpio.h

@@ -0,0 +1,28 @@
+/*
+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.
+*/
+
+void Init_rpi_gpio();
+void define_modules(void);

data/ext/rpi_gpio/soft_pwm.c

@@ -0,0 +1,235 @@
+/*
+Original code by Ben Croston modified for Ruby by Nick Lowery
+(github.com/clockvapor)
+Copyright (c) 2014-2020 Nick Lowery
+
+Copyright (c) 2013-2018 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 <stdlib.h>
+#include <pthread.h>
+#include <time.h>
+#include "c_gpio.h"
+#include "soft_pwm.h"
+pthread_t threads;
+
+struct pwm
+{
+    unsigned int gpio;
+    float freq;
+    float dutycycle;
+    float basetime;
+    float slicetime;
+    struct timespec req_on, req_off;
+    int running;
+    struct pwm *next;
+};
+struct pwm *pwm_list = NULL;
+
+void remove_pwm(unsigned int gpio)
+{
+    struct pwm *p = pwm_list;
+    struct pwm *prev = NULL;
+    struct pwm *temp;
+
+    while (p != NULL)
+    {
+        if (p->gpio == gpio)
+        {
+            if (prev == NULL) {
+                pwm_list = p->next;
+            } else {
+                prev->next = p->next;
+            }
+            temp = p;
+            p = p->next;
+            temp->running = 0; // signal the thread to stop. The thread will free() the pwm struct when it's done with it.
+        } else {
+            prev = p;
+            p = p->next;
+        }
+    }
+}
+
+void calculate_times(struct pwm *p)
+{
+    long long usec;
+
+    usec = (long long)(p->dutycycle * p->slicetime * 1000.0);
+    p->req_on.tv_sec = (int)(usec / 1000000LL);
+    usec -= (long long)p->req_on.tv_sec * 1000000LL;
+    p->req_on.tv_nsec = (long)usec * 1000L;
+
+    usec = (long long)((100.0-p->dutycycle) * p->slicetime * 1000.0);
+    p->req_off.tv_sec = (int)(usec / 1000000LL);
+    usec -= (long long)p->req_off.tv_sec * 1000000LL;
+    p->req_off.tv_nsec = (long)usec * 1000L;
+}
+
+void full_sleep(struct timespec *req)
+{
+    struct timespec rem = {0};
+
+    if (nanosleep(req,&rem) == -1)
+        full_sleep(&rem);
+}
+
+void *pwm_thread(void *threadarg)
+{
+    struct pwm *p = (struct pwm *)threadarg;
+
+    while (p->running)
+    {
+
+        if (p->dutycycle > 0.0)
+        {
+            output_gpio(p->gpio, 1);
+            full_sleep(&p->req_on);
+        }
+
+        if (p->dutycycle < 100.0)
+        {
+            output_gpio(p->gpio, 0);
+            full_sleep(&p->req_off);
+        }
+    }
+
+    // clean up
+    output_gpio(p->gpio, 0);
+    free(p);
+    pthread_exit(NULL);
+}
+
+struct pwm *add_new_pwm(unsigned int gpio)
+{
+    struct pwm *new_pwm;
+
+    new_pwm = malloc(sizeof(struct pwm));
+    new_pwm->gpio = gpio;
+    new_pwm->running = 0;
+    new_pwm->next = NULL;
+    // default to 1 kHz frequency, dutycycle 0.0
+    new_pwm->freq = 1000.0;
+    new_pwm->dutycycle = 0.0;
+    new_pwm->basetime = 1.0;    // 1 ms
+    new_pwm->slicetime = 0.01;  // 0.01 ms
+    calculate_times(new_pwm);
+    return new_pwm;
+}
+
+struct pwm *find_pwm(unsigned int gpio)
+/* Return the pwm record for gpio, creating it if it does not exist */
+{
+    struct pwm *p = pwm_list;
+
+    if (pwm_list == NULL)
+    {
+        pwm_list = add_new_pwm(gpio);
+        return pwm_list;
+    }
+
+    while (p != NULL)
+    {
+        if (p->gpio == gpio)
+            return p;
+        if (p->next == NULL)
+        {
+            p->next = add_new_pwm(gpio);
+            return p->next;
+        }
+        p = p->next;
+    }
+    return NULL;
+}
+
+void pwm_set_duty_cycle(unsigned int gpio, float dutycycle)
+{
+    struct pwm *p;
+
+    if (dutycycle < 0.0 || dutycycle > 100.0)
+    {
+        // btc fixme - error
+        return;
+    }
+
+    if ((p = find_pwm(gpio)) != NULL)
+    {
+        p->dutycycle = dutycycle;
+        calculate_times(p);
+    }
+}
+
+void pwm_set_frequency(unsigned int gpio, float freq)
+{
+    struct pwm *p;
+
+    if (freq <= 0.0) // to avoid divide by zero
+    {
+        // btc fixme - error
+        return;
+    }
+
+    if ((p = find_pwm(gpio)) != NULL)
+    {
+        p->basetime = 1000.0 / freq;    // calculated in ms
+        p->slicetime = p->basetime / 100.0;
+        calculate_times(p);
+    }
+}
+
+void pwm_start(unsigned int gpio)
+{
+    struct pwm *p;
+
+    if (((p = find_pwm(gpio)) == NULL) || p->running)
+        return;
+
+    p->running = 1;
+    if (pthread_create(&threads, NULL, pwm_thread, (void *)p) != 0)
+    {
+        // btc fixme - error
+        p->running = 0;
+        return;
+    }
+    pthread_detach(threads);
+}
+
+void pwm_stop(unsigned int gpio)
+{
+    remove_pwm(gpio);
+}
+
+// returns 1 if there is a PWM for this gpio, 0 otherwise
+int pwm_exists(unsigned int gpio)
+{
+    struct pwm *p = pwm_list;
+
+    while (p != NULL)
+    {
+        if (p->gpio == gpio)
+        {
+            return 1;
+        } else {
+            p = p->next;
+        }
+    }
+    return 0;
+}