c_gpio 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ccafeaa0502815b135c4bc830c182bbf0824c79
-  data.tar.gz: 0c8dd4659fe70110185f72f5252a5a9d3ac8976d
+  metadata.gz: 165db671c63bd4156e152c4af8b3511c42ea0bd7
+  data.tar.gz: 6ff5273c68bf31c0d95e5d751dd124abe73d366f
 SHA512:
-  metadata.gz: effcf66a43487ad13acce3b6036e32dd127ab46a743a3c8b62cba7c36d3aeea37e08a7e227a226d0d39f9176cc303a48ef864b6223734f66565e3ff36b6975bf
-  data.tar.gz: 8b4a5010ea9211373be756ff74cee6962301e764651ab623c7d234dc9492e5c5bb39a2cf8f004b5e508192b89231db1b115999ac7d84d7e363a48cae9528833f
+  metadata.gz: 4914d74baaa5d0c4abb1687455d2be575fbc1259ba11319699b22f7778bb83f6c617401a19649677b241dff79705ed4a8ff2aef72c9e4becabe6c4074f7d48d3
+  data.tar.gz: d571408860ef7a0e5982a386d17959a29012c5686e59403d686bd053518e668ce20e6fedf1534021a772ed7e4120cf716dfa2560f9188c0f958b7911f154613f

data/ext/c_gpio/base.c

@@ -0,0 +1,147 @@
+#ifndef __RUBY_H
+  #define __RUBY_H
+  #include <ruby.h>
+#endif
+
+#include "base.h"
+#include "internal.h"
+#include "mount.h"
+#include "file_stuff.h"
+
+const char *GPIO_IN   = "in";
+const char *GPIO_OUT  = "out";
+const char *GPIO_HIGH = "1";
+const char *GPIO_LOW  = "0";
+
+VALUE GPIO_BASE_init(VALUE self, VALUE port) {
+  struct GPIO *ptr;
+  int gpio_port = NUM2INT(port);
+
+  GPIO_INTERNAL_validate_pin(gpio_port);
+
+  pi_io_mountPin(gpio_port);
+
+  Data_Get_Struct(self, struct GPIO, ptr);
+
+  ptr->port = gpio_port;
+
+  return self;
+}
+
+VALUE GPIO_BASE_get_value(VALUE self) {
+  struct GPIO *ptr;
+  // We have assign a default value here, because if the file is empty,
+  // It will NOT get overwritten, and you will see a memdump
+  char content[2] = "";
+
+  Data_Get_Struct(self, struct GPIO, ptr);
+
+  GPIO_INTERNAL_get_value(ptr->port, (char *) &content);
+
+  if(strcmp(GPIO_HIGH, content) == 0) {
+    return ID2SYM(rb_intern("high"));
+  } else if(strcmp(GPIO_LOW, content) == 0) {
+    return ID2SYM(rb_intern("low"));
+  }
+
+  rb_raise(rb_eRuntimeError, "Value was neither HIGH nor LOW");
+}
+
+VALUE GPIO_BASE_set_value(VALUE self, VALUE value) {
+  struct GPIO *ptr;
+
+  Data_Get_Struct(self, struct GPIO, ptr);
+
+  if(SYM2ID(value) == rb_intern("low")) {
+    GPIO_INTERNAL_set_value(ptr->port, (char *) GPIO_LOW);
+  } else if(SYM2ID(value) == rb_intern("high")) {
+    GPIO_INTERNAL_set_value(ptr->port, (char *) GPIO_HIGH);
+  } else {
+    rb_raise(rb_eArgError, "Only :low and :high are valid input");
+  }
+
+  return self;
+}
+
+VALUE GPIO_BASE_get_direction(VALUE self) {
+  struct GPIO *ptr;
+  // We have assign a default value here, because if the file is empty,
+  // It will NOT get overwritten, and you will see a memdump
+  char content[4] = "";
+
+  Data_Get_Struct(self, struct GPIO, ptr);
+
+  GPIO_INTERNAL_get_direction(ptr->port, (char *) &content);
+
+  if(strcmp(GPIO_IN, content) == 0) {
+    return ID2SYM(rb_intern("in"));
+  } else if(strcmp(GPIO_OUT, content) == 0) {
+    return ID2SYM(rb_intern("out"));
+  }
+
+  rb_raise(rb_eRuntimeError, "Direction was neither IN nor OUT");
+}
+
+VALUE GPIO_BASE_set_direction(VALUE self, VALUE direction) {
+  struct GPIO *ptr;
+
+  Data_Get_Struct(self, struct GPIO, ptr);
+
+  if(SYM2ID(direction) == rb_intern("in")) {
+    GPIO_INTERNAL_set_direction(ptr->port, (char *) GPIO_IN);
+  } else if(SYM2ID(direction) == rb_intern("out")) {
+    GPIO_INTERNAL_set_direction(ptr->port, (char *) GPIO_OUT);
+  } else {
+    rb_raise(rb_eArgError, "Only :in and :out are valid input");
+  }
+
+  return self;
+}
+
+VALUE GPIO_BASE_wait_for_low(VALUE self, VALUE block) {
+  struct GPIO *gpio;
+  char oldVal[20] = "1";
+  char newVal[20] = "1";
+
+  Data_Get_Struct(self, struct GPIO, gpio);
+
+  while(1) {
+    rb_thread_schedule();
+
+    GPIO_INTERNAL_get_value(gpio->port, (char *) &newVal);
+
+    if (strcmp(oldVal, newVal) != 0 && strcmp(newVal, (char *) GPIO_LOW) == 0) {
+      rb_funcall(block, rb_intern("call"), 0);
+    }
+
+    strcpy(oldVal, newVal);
+
+    usleep(10 * 1000);
+  }
+
+  return self;
+}
+
+VALUE GPIO_BASE_wait_for_high(VALUE self, VALUE block) {
+  struct GPIO *gpio;
+  char oldVal[20] = "1";
+  char newVal[20] = "1";
+
+  Data_Get_Struct(self, struct GPIO, gpio);
+
+  while(1) {
+    rb_thread_schedule();
+
+    GPIO_INTERNAL_get_value(gpio->port, (char *) &newVal);
+
+    if (strcmp(oldVal, newVal) != 0 && strcmp(newVal, (char *) GPIO_HIGH) == 0) {
+      rb_funcall(block, rb_intern("call"), 0);
+    }
+
+    strcpy(oldVal, newVal);
+
+    usleep(10 * 1000);
+  }
+
+  return self;
+}

data/ext/c_gpio/base.h

@@ -0,0 +1,23 @@
+#ifndef S_GPIO
+#define S_GPIO
+
+struct GPIO {
+  int port;
+  int pwmPosition;
+  void *ptr;
+};
+
+extern const char *GPIO_IN;
+extern const char *GPIO_OUT;
+extern const char *GPIO_HIGH;
+extern const char *GPIO_LOW;
+
+#endif
+
+VALUE GPIO_BASE_init(VALUE self, VALUE port);
+VALUE GPIO_BASE_get_value(VALUE self);
+VALUE GPIO_BASE_set_value(VALUE self, VALUE value);
+VALUE GPIO_BASE_get_direction(VALUE self);
+VALUE GPIO_BASE_set_direction(VALUE self, VALUE direction);
+VALUE GPIO_BASE_wait_for_high(VALUE self, VALUE block);
+VALUE GPIO_BASE_wait_for_low(VALUE self, VALUE block);

data/ext/c_gpio/button.c

@@ -0,0 +1,41 @@
+#ifndef __RUBY_H
+  #define __RUBY_H
+  #include <ruby.h>
+#endif
+
+#include "mount.h"
+#include "base.h"
+#include "internal.h"
+#include "file_stuff.h"
+
+VALUE GPIO_BUTTON_init(VALUE self, VALUE port) {
+  struct GPIO *ptr;
+  int gpio_port = NUM2INT(port);
+
+  GPIO_INTERNAL_validate_pin(gpio_port);
+
+  pi_io_mountPin(gpio_port);
+
+  Data_Get_Struct(self, struct GPIO, ptr);
+
+  ptr->port = gpio_port;
+
+  GPIO_INTERNAL_set_direction(ptr->port, (char *) GPIO_IN);
+
+  return self;
+}
+
+VALUE GPIO_BUTTON_is_pressed(VALUE self) {
+  struct GPIO *ptr;
+  char content[20];
+
+  Data_Get_Struct(self, struct GPIO, ptr);
+
+  GPIO_INTERNAL_get_value(ptr->port, (char *) &content);
+
+  if( strcmp(GPIO_LOW, content) ) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}

data/ext/c_gpio/button.h

@@ -0,0 +1,2 @@
+VALUE GPIO_BUTTON_init(VALUE self, VALUE port);
+VALUE GPIO_BUTTON_is_pressed(VALUE self);

data/ext/c_gpio/file_stuff.c

@@ -0,0 +1,30 @@
+#ifndef __RUBY_H
+  #define __RUBY_H
+  #include <ruby.h>
+#endif
+
+#include <fcntl.h>
+
+void GPIO_INTERNAL_getFileContent(char *filePath, char *dst) {
+  FILE *file = fopen(filePath,"r");
+  if(file == NULL) {
+    rb_raise(rb_eArgError, "Could not open GPIO connection");
+  }
+
+  fscanf(file, "%s", dst);
+
+  fclose(file);
+}
+
+void GPIO_INTERNAL_writeFileContent(char *filePath, char* content, size_t size) {
+  int fd;
+
+  fd = open(filePath, O_WRONLY);
+  if (-1 == fd) {
+    rb_raise(rb_eArgError, "Could not open File for writing");
+  }
+
+  write(fd, content, size);
+
+  close(fd);
+}

data/ext/c_gpio/file_stuff.h

@@ -0,0 +1,2 @@
+void GPIO_INTERNAL_getFileContent(char *filePath, char *dst);
+void GPIO_INTERNAL_writeFileContent(char *filePath, char* content, size_t size);

data/ext/c_gpio/gpio.c

@@ -0,0 +1,61 @@
+#include <ruby.h>
+
+#include "mount.h"
+#include "led.h"
+#include "button.h"
+#include "base.h"
+#include "pwm.h"
+#include "file_stuff.h"
+
+
+void GPIO_deallocate(void *pi_io) {
+  // We can not unmount it here, because maybe another object is looking for the same pin?
+  //pi_io_unmountPin(ptr->port);
+
+  free(pi_io);
+}
+
+VALUE GPIO_allocate(VALUE self) {
+  struct GPIO *pi_io = malloc(sizeof(struct GPIO));
+
+  return Data_Wrap_Struct(self, NULL, GPIO_deallocate, pi_io);
+}
+
+
+//Ruby-Einstiegsmethode. Sie muss immer mit Init_ beginnen und auf den Namen der Extension enden. 
+void Init_gpio(void) {
+  VALUE GPIO_MODULE, GPIO_PWM, GPIO_LED, GPIO_BASE, GPIO_BUTTON;
+
+  GPIO_MODULE = rb_const_get(rb_cObject, rb_intern("GPIO"));
+
+  GPIO_LED = rb_define_class_under(GPIO_MODULE, "Led", rb_cObject);
+  rb_define_alloc_func(GPIO_LED, GPIO_allocate);
+  rb_define_method(GPIO_LED, "initialize", GPIO_LED_init,     1);
+  rb_define_method(GPIO_LED, "turn_on!",   GPIO_LED_turn_on,  0);
+  rb_define_method(GPIO_LED, "turn_off!",  GPIO_LED_turn_off, 0);
+
+
+  GPIO_BASE = rb_define_class_under(GPIO_MODULE, "Base", rb_cObject);
+  rb_define_alloc_func(GPIO_BASE, GPIO_allocate);
+  rb_define_method(GPIO_BASE, "initialize",    GPIO_BASE_init,          1);
+  rb_define_method(GPIO_BASE, "value",         GPIO_BASE_get_value,     0);
+  rb_define_method(GPIO_BASE, "value=",        GPIO_BASE_set_value,     1);
+  rb_define_method(GPIO_BASE, "direction",     GPIO_BASE_get_direction, 0);
+  rb_define_method(GPIO_BASE, "direction=",    GPIO_BASE_set_direction, 1);
+  rb_define_method(GPIO_BASE, "wait_for_high", GPIO_BASE_wait_for_high, 1);
+  rb_define_method(GPIO_BASE, "wait_for_low",  GPIO_BASE_wait_for_low,  1);
+
+
+  GPIO_BUTTON = rb_define_class_under(GPIO_MODULE, "Button", rb_cObject);
+  rb_define_alloc_func(GPIO_BUTTON, GPIO_allocate);
+  rb_define_method(GPIO_BUTTON, "initialize",           GPIO_BUTTON_init,                  1);
+  rb_define_method(GPIO_BUTTON, "pressed?",             GPIO_BUTTON_is_pressed,            0);
+  // Yes e want to delegate to the GPIO_BASE here
+  rb_define_method(GPIO_BUTTON, "wait_for_high",        GPIO_BASE_wait_for_high,           1);
+  rb_define_method(GPIO_BUTTON, "wait_for_low",         GPIO_BASE_wait_for_low,            1);
+
+  GPIO_PWM = rb_define_class_under(GPIO_MODULE, "Pwm", rb_cObject);
+  rb_define_alloc_func(GPIO_PWM, GPIO_allocate);
+  rb_define_method(GPIO_PWM, "initialize", GPIO_PWM_init,     1);
+  rb_define_method(GPIO_PWM, "move_to",    GPIO_PWM_position, 1);
+}

data/ext/c_gpio/internal.c

@@ -0,0 +1,46 @@
+#ifndef __RUBY_H
+  #define __RUBY_H
+  #include <ruby.h>
+#endif
+
+#include "file_stuff.h"
+#define FILE_NAME_BUFFER_SIZE 50
+
+void GPIO_INTERNAL_validate_pin(int pinNumber) {
+  // Currently the rPI does only have GPIO Pins  from 2 to 27
+  if(pinNumber < 2 || pinNumber > 27) {
+    rb_raise(rb_eArgError, "The GPIO Port has to be between 2 and 27");
+  }
+}
+
+void GPIO_INTERNAL_get_value(int pinNumber, char *dst) {
+  char filename[FILE_NAME_BUFFER_SIZE];
+
+  sprintf(filename, "/sys/class/gpio/gpio%d/value", pinNumber);
+
+  GPIO_INTERNAL_getFileContent(filename, dst);
+}
+
+void GPIO_INTERNAL_set_value(int pinNumber, char* content) {
+  char filename[FILE_NAME_BUFFER_SIZE];
+
+  sprintf(filename, "/sys/class/gpio/gpio%d/value", pinNumber);
+
+  GPIO_INTERNAL_writeFileContent(filename, content, strlen(content));
+}
+
+void GPIO_INTERNAL_get_direction(int pinNumber, char *dst) {
+  char filename[FILE_NAME_BUFFER_SIZE];
+
+  sprintf(filename, "/sys/class/gpio/gpio%d/direction", pinNumber);
+
+  GPIO_INTERNAL_getFileContent(filename, dst);
+}
+
+void GPIO_INTERNAL_set_direction(int pinNumber, char *content) {
+  char filename[FILE_NAME_BUFFER_SIZE];
+
+  sprintf(filename, "/sys/class/gpio/gpio%d/direction", pinNumber);
+
+  GPIO_INTERNAL_writeFileContent(filename, content, strlen(content));
+}

data/ext/c_gpio/internal.h

@@ -0,0 +1,5 @@
+void GPIO_INTERNAL_validate_pin(int pinNumber);
+void GPIO_INTERNAL_get_value(int pinNumber, char *dst);
+void GPIO_INTERNAL_set_value(int pinNumber, char *content);
+void GPIO_INTERNAL_get_direction(int pinNumber, char *dst);
+void GPIO_INTERNAL_set_direction(int pinNumber, char *content);

data/ext/c_gpio/led.c

@@ -0,0 +1,46 @@
+#ifndef __RUBY_H
+  #define __RUBY_H
+  #include <ruby.h>
+#endif
+
+#include "mount.h"
+#include "base.h"
+#include "led.h"
+#include "internal.h"
+#include "file_stuff.h"
+
+
+VALUE GPIO_LED_init(VALUE self, VALUE port) {
+  struct GPIO *ptr;
+  int gpio_port = NUM2INT(port);
+
+  GPIO_INTERNAL_validate_pin(gpio_port);
+
+  pi_io_mountPin(gpio_port);
+
+  Data_Get_Struct(self, struct GPIO, ptr);
+
+  ptr->port = gpio_port;
+
+  GPIO_INTERNAL_set_direction(ptr->port, (char *) GPIO_OUT);
+
+  return self;
+}
+
+VALUE GPIO_LED_turn_on(VALUE self) {
+  struct GPIO *ptr;
+  Data_Get_Struct(self, struct GPIO, ptr);
+
+  GPIO_INTERNAL_set_value(ptr->port, (char *) GPIO_LOW);
+
+  return self;
+}
+
+VALUE GPIO_LED_turn_off(VALUE self) {
+  struct GPIO *ptr;
+  Data_Get_Struct(self, struct GPIO, ptr);
+
+  GPIO_INTERNAL_set_value(ptr->port, (char *) GPIO_HIGH);
+
+  return self;
+}

data/ext/c_gpio/led.h

@@ -0,0 +1,3 @@
+VALUE GPIO_LED_init(VALUE self, VALUE port);
+VALUE GPIO_LED_turn_on(VALUE self);
+VALUE GPIO_LED_turn_off(VALUE self);

data/ext/c_gpio/mount.c

@@ -0,0 +1,50 @@
+#ifndef __RUBY_H
+  #define __RUBY_H
+  #include <ruby.h>
+#endif
+
+#include <fcntl.h>
+#define BUFFER_SIZE 5
+
+void pi_io_writeToMountFile(char *fileName, int content) {
+  int fd;
+  char buffer[BUFFER_SIZE];
+  ssize_t bytes_written;
+
+  fd = open(fileName, O_WRONLY);
+  if (-1 == fd) {
+    rb_raise(rb_eArgError, "Could not open GPIO connection - mounting GPIO pin not possible");
+  }
+
+  bytes_written = snprintf(buffer, BUFFER_SIZE, "%d", content);
+  write(fd, buffer, bytes_written);
+
+  close(fd);
+}
+
+void pi_io_mountPin(int pinNumber) {
+  pi_io_writeToMountFile((char*)"/sys/class/gpio/export", pinNumber);
+
+  char mountedPinDirection[40];
+
+  sprintf(mountedPinDirection, "/sys/class/gpio/gpio%d/direction", pinNumber);
+
+  int i;
+  for (i = 0; i < 10; i++) {
+    if( access( mountedPinDirection, W_OK ) != -1 ) {
+      // The pin is mounted, so we can return
+      return;
+    } else {
+      // The pin seems to be not mounted yet.
+      // so we wait 20ms and check again
+      usleep(20 * 1000);
+    }
+  }
+
+  // If we reach this part, mounting in time was not possible
+  rb_raise(rb_eSystemCallError, "Was not able to mount GPIO pin");
+}
+
+void pi_io_unmountPin(int pinNumber) {
+  pi_io_writeToMountFile((char*)"/sys/class/gpio/unexport", pinNumber);
+}

data/ext/c_gpio/mount.h

@@ -0,0 +1,3 @@
+void pi_io_mountPin(int pinNumber);
+void pi_io_unmountPin(int pinNumber);
+void pi_io_writeToMountFile(char *fileName, int content);

data/ext/c_gpio/pwm.c

@@ -0,0 +1,80 @@
+#ifndef __RUBY_H
+  #define __RUBY_H
+  #include <ruby.h>
+#endif
+
+#include "mount.h"
+#include "base.h"
+#include "internal.h"
+#include "file_stuff.h"
+#include "pwm.h"
+
+#include <pthread.h>
+
+VALUE GPIO_PWM_init(VALUE self, VALUE port) {
+  struct GPIO *ptr;
+  int gpio_port = NUM2INT(port);
+
+  GPIO_INTERNAL_validate_pin(gpio_port);
+
+  pi_io_mountPin(gpio_port);
+
+  Data_Get_Struct(self, struct GPIO, ptr);
+
+  ptr->port = gpio_port;
+
+  GPIO_INTERNAL_set_direction(ptr->port, (char *) GPIO_OUT);
+
+  return self;
+}
+
+VALUE GPIO_PWM_position(VALUE self, VALUE vPosition) {
+  struct GPIO *ptr;
+  Data_Get_Struct(self, struct GPIO, ptr);
+
+  int position = NUM2INT(vPosition);
+
+  if(position < 0 || position > 200) {
+    rb_raise(rb_eArgError, "Argument must be between 0 and 200");
+  }
+
+  // Position 0 is not 0 but 30, and max is not 200 but 230
+  // Just for interface reasons, we accept values from 0 to 200
+  // But internally we have to add 30
+  ptr->pwmPosition = position + 30;
+
+  pthread_t myThread;
+
+  pthread_create(&myThread, NULL, &positioner, ptr);
+
+  return self;
+}
+
+
+void *positioner(void *ptr) {
+
+  struct GPIO *gpio = (struct GPIO *) ptr;
+
+  float duration = 40.0;
+  float uptime = gpio->pwmPosition / 100.0;
+
+  // We can not use while(1) atm, because this whole thing is that unprecise, that the stepper engine will start jittering
+  // while(1) {
+  //   GPIO_INTERNAL_set_value(gpio->port, (char *) GPIO_HIGH);
+  //   usleep(uptime * 1000);
+  //   GPIO_INTERNAL_set_value(gpio->port, (char *) GPIO_LOW);
+  //   usleep((duration - uptime) * 1000);
+  // }
+
+  int i;
+  for (i = 0; i < 35; i++) {
+    GPIO_INTERNAL_set_value(gpio->port, (char *) GPIO_HIGH);
+
+    usleep(uptime * 1000);
+
+    GPIO_INTERNAL_set_value(gpio->port, (char *) GPIO_LOW);
+    usleep((duration - uptime) * 1000);
+  }
+
+  return NULL;
+}

data/ext/c_gpio/pwm.h

@@ -0,0 +1,3 @@
+VALUE GPIO_PWM_init(VALUE self, VALUE port);
+VALUE GPIO_PWM_position(VALUE self, VALUE vPosition);
+void *positioner(void *ptr);

data/lib/c_gpio.rb

@@ -1,5 +1,5 @@
 module GPIO
-  VERSION = '0.0.5'
+  VERSION = '0.0.7'
 end
 
 require 'c_gpio/gpio'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: c_gpio
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - hujiko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-25 00:00:00.000000000 Z
+date: 2018-06-26 00:00:00.000000000 Z
 dependencies: []
 description: Ruby gem to control GPIO ports of a raspberry PI
 email: 
@@ -18,7 +18,22 @@ extensions:
 extra_rdoc_files: []
 files:
 - README.md
+- ext/c_gpio/base.c
+- ext/c_gpio/base.h
+- ext/c_gpio/button.c
+- ext/c_gpio/button.h
 - ext/c_gpio/extconf.rb
+- ext/c_gpio/file_stuff.c
+- ext/c_gpio/file_stuff.h
+- ext/c_gpio/gpio.c
+- ext/c_gpio/internal.c
+- ext/c_gpio/internal.h
+- ext/c_gpio/led.c
+- ext/c_gpio/led.h
+- ext/c_gpio/mount.c
+- ext/c_gpio/mount.h
+- ext/c_gpio/pwm.c
+- ext/c_gpio/pwm.h
 - lib/c_gpio.rb
 homepage: https://github.com/hujiko/c_GPIO
 licenses: