object_oriented_beaglebone_black 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d50d4a5e405aaf4a8a2eb0cc753003898af3727
-  data.tar.gz: 77570e9e927f7e0dba758f41fa49b92c31ea60a9
+  metadata.gz: 23dd492f02ed9599e354f09bc32122056d4b570d
+  data.tar.gz: 52af68d2197f4b880dc83a2b541531546b38d24b
 SHA512:
-  metadata.gz: e89d8f813c455dfae761bf9d7a0631a732289b2187bb3256fd614e4c393ddeb69c7077918bbb2f7f8d78f5ada765847bd0623889fd8b2665091e08d977a859a0
-  data.tar.gz: ee89313d3c4dfadbd391336e54ee09f8087bf040bf1efdcccdeb5f4f5a2623383a4c1955dceed970e646d5ad7b1c6d02542f412d48589d54c5ed2ee86bc974a8
+  metadata.gz: 5e19440fd68f62438dbcaca492524cedc1f5ca10dc3f018ceb22d66b9310e3668b47b4e8b4e01288afa0c87a902b48dd8e5c181eb07dca6c8bace62a578955d6
+  data.tar.gz: cc30fabdeb896be78abe143067145e90901258b0f766ed5d3053e799681251df8e575790b4512539916e11a52cb7388454be34e8b8270aa0e95643e5582dedd4

data/README.md

@@ -86,6 +86,7 @@ Or install it yourself as:
 
     pin_key = "P9_40"
 
+    # This can take a few seconds:
     analog_input = ObjectOrientedBeagleboneBlack::AnalogInput.new(pin_key)
 
     analog_input.raw_value  # Read the raw voltage value in the range of 0 and 1.8[V].
@@ -102,6 +103,7 @@ Or install it yourself as:
 
     pwm_pin_key = "P9_14"
 
+    # This can take several seconds:
     pwm = ObjectOrientedBeagleboneBlack::Pwm.new(pwm_pin_key)
 
     pwm.period = 1000 # Unit is [ns] (nano second)

data/examples/arduino/arduino_sketches/DcDcConverterManagement/DcDcConverterManagement.ino

@@ -0,0 +1,100 @@
+/* 
+   Sends the raw voltage and current to the serial port and receives raw PWM value from the serial port. 
+   
+   Created by Tadatoshi Takahashi
+*/
+
+const int inputVoltageAnalogInputPin = 0;
+const int inputCurrentAnalogInputPin = 1; 
+const int outputVoltageAnalogInputPin = 2;
+const int outputCurrentAnalogInputPin = 3;
+const int pwmDigitalPin = 8; // Just in case, selected a pin number different from the ones used for input pins. 
+
+void setup() {
+  pinMode(pwmDigitalPin, OUTPUT);
+  Serial.begin(9600, SERIAL_8N1); // send and receive at 9600 baud 
+}
+
+void loop() {
+  
+//  Serial.println("In loop");
+
+  
+
+//  delay(1000);
+  
+}  
+
+void serialEvent() {  
+  
+//  Serial.println("Testing serialEvent method.");
+  
+  while (Serial.available()) {
+    
+//    Serial.println("In Serial.available()");
+
+    char command = Serial.read();
+    
+//    Serial.print("command: ");
+//    Serial.println(command);    
+
+    // 'm' for measure:
+    if (command == 'm') {
+      
+//      Serial.println("if for m");
+      
+      measureRawVoltageAndCurrent();
+    
+    // 'p' for pwm (e.g. "p127": 127 out of between 0 and 255 gives 50% duty cycle):
+    } else if (command == 'p') {
+      
+//      Serial.println("else if for p");
+    
+      int dutyCycle = Serial.parseInt();
+//      Serial.print("duty cycle: ");
+//      Serial.println(dutyCycle);
+      
+      setDutyCycle(pwmDigitalPin, dutyCycle);
+//      Serial.println("duty_cycle_set");
+    
+    // 'o' for b'o'ost (set duty cycle for the second switch with the first one clsed = 255):
+    }
+  
+  }
+  
+//  delay(1000);
+  
+}
+
+void measureRawVoltageAndCurrent() {
+  
+//  Serial.println("in measureRawVoltageAndCurrent");
+
+  // In order to have analog steps between 0 and 4095:
+  analogReadResolution(12);
+  
+  int rawReadingForInputVoltage = analogRead(inputVoltageAnalogInputPin);
+  int rawReadingForInputCurrent = analogRead(inputCurrentAnalogInputPin);
+  int rawReadingForOutputVoltage = analogRead(outputVoltageAnalogInputPin);
+//  int rawReadingForOutputCurrent = analogRead(outputCurrentAnalogInputPin); 
+    
+  Serial.print("{\"raw_reading_for_input_voltage\": ");
+  Serial.print(rawReadingForInputVoltage);
+  Serial.print(", \"raw_reading_for_input_current\": ");
+  Serial.print(rawReadingForInputCurrent);
+  Serial.print(", \"raw_reading_for_output_voltage\": ");
+  Serial.print(rawReadingForOutputVoltage);  
+//  Serial.print(", \"raw_reading_for_output_current\": ");
+//  Serial.print(rawReadingForOutputCurrent);    
+  Serial.println("}");
+ 
+//  delay(1000); 
+  
+}
+
+void setDutyCycle(int pwmPin, int dutyCycle) {
+  analogWrite(pwmDigitalPin, dutyCycle);
+  
+//  delay(1000);
+}  
+

data/examples/arduino/arduino_sketches/VoltageMeasurement/VoltageMeasurement.ino

@@ -0,0 +1,78 @@
+/* 
+   Sends the raw voltage and current to the serial port. 
+   
+   Created by Tadatoshi Takahashi
+*/
+
+const int inputVoltagePin = 0;
+const int inputCurrentPin = 1; 
+const int outputVoltagePin = 2;
+const int outputCurrentPin = 3;
+
+void setup() {
+  Serial.begin(9600, SERIAL_8N1); // send and receive at 9600 baud 
+}
+
+void loop() {
+  
+//  Serial.println("In loop");
+
+  
+
+//  delay(1000);
+  
+}  
+
+void serialEvent() {  
+  
+//  Serial.println("Testing serialEvent method.");
+  
+  while (Serial.available()) {
+    
+//    Serial.println("In Serial.available()");
+
+    char command = Serial.read();
+    
+//    Serial.print("command: ");
+//    Serial.println(command);    
+
+    // 'm' for measure:
+    if (command == 'm') {
+      
+//      Serial.println("if for m");
+      
+      measureRawVoltageAndCurrent();
+    
+    }
+  
+  }
+  
+//  delay(1000);
+  
+}
+
+void measureRawVoltageAndCurrent() {
+  
+//  Serial.println("in measureRawVoltageAndCurrent");
+
+  // In order to have analog steps between 0 and 4095:
+  analogReadResolution(12);
+  
+  int rawReadingForInputVoltage = analogRead(inputVoltagePin);
+  int rawReadingForInputCurrent = analogRead(inputCurrentPin);
+  int rawReadingForOutputVoltage = analogRead(outputVoltagePin);
+//  int rawReadingForOutputCurrent = analogRead(outputCurrentPin); 
+    
+  Serial.print("{\"raw_reading_for_input_voltage\": ");
+  Serial.print(rawReadingForInputVoltage);
+  Serial.print(", \"raw_reading_for_input_current\": ");
+  Serial.print(rawReadingForInputCurrent);
+  Serial.print(", \"raw_reading_for_output_voltage\": ");
+  Serial.print(rawReadingForOutputVoltage);  
+//  Serial.print(", \"raw_reading_for_output_current\": ");
+//  Serial.print(rawReadingForOutputCurrent);    
+  Serial.println("}");
+ 
+//  delay(1000); 
+  
+}

data/examples/object_oriented_beaglebone_black_examples/current_measurement/current_input.rb

@@ -0,0 +1,30 @@
+require 'bigdecimal'
+
+module ObjectOrientedBeagleboneBlackExamples
+  module CurrentMeasurement
+    class CurrentInput
+
+      def initialize(pin_key, resistance_for_current_measurement: nil, voltage_gain_for_current_measurement: BigDecimal("1.0"), voltage_current_ratio_for_current_measurement: nil)
+        @analog_input = ObjectOrientedBeagleboneBlack::AnalogInput.new(pin_key)
+
+        @voltage_current_calculation = VoltageCurrentCalculation.new
+
+        @resistance_for_current_measurement = resistance_for_current_measurement
+        @voltage_gain_for_current_measurement = voltage_gain_for_current_measurement
+        @voltage_current_ratio_for_current_measurement = voltage_current_ratio_for_current_measurement        
+      end
+
+      def value
+        raw_analog_reading = BigDecimal(@analog_input.raw_value.to_s)
+
+        current_in_bigdecimal = @voltage_current_calculation.current(raw_analog_reading, 
+                                                                     resistance_for_current_measurement: @resistance_for_current_measurement, 
+                                                                     voltage_gain_for_current_measurement: @voltage_gain_for_current_measurement, 
+                                                                     voltage_current_ratio_for_current_measurement: @voltage_current_ratio_for_current_measurement)
+
+        current_in_bigdecimal.to_f
+      end
+
+    end
+  end
+end

data/examples/object_oriented_beaglebone_black_examples/current_measurement.rb

@@ -0,0 +1,7 @@
+require 'object_oriented_beaglebone_black_examples/current_measurement/current_input'
+
+module ObjectOrientedBeagleboneBlackExamples
+  module CurrentMeasurement
+    # Your code goes here...
+  end
+end

data/examples/object_oriented_beaglebone_black_examples/dc_dc_converter_control_example_1.rb

@@ -0,0 +1,54 @@
+require 'object_oriented_beaglebone_black_examples'
+require 'bigdecimal'
+
+uart_id = "UART4"
+
+uart_connection = ObjectOrientedBeagleboneBlack::UartConnection.new(uart_id)
+
+# The parameters for Arduino Due:
+analog_steps = BigDecimal("4095")
+reference_voltage = BigDecimal("3.3")
+
+voltage_current_input = ObjectOrientedBeagleboneBlackExamples::UartConnectionToArduino::VoltageCurrentInput.new(uart_connection, analog_steps, reference_voltage)
+
+voltage_current_input.measure
+
+# higher_side_resistor_resistance: 100[kΩ], lower_side_resistor_resistance: 8.2[kΩ]
+input_voltage = voltage_current_input.input_voltage(higher_side_resistor_resistance: BigDecimal("100000"), lower_side_resistor_resistance: BigDecimal("8200"))
+# shunt resistance: 0.04[Ω]
+input_current = voltage_current_input.input_current(resistance_for_current_measurement: BigDecimal("0.04"))
+# higher_side_resistor_resistance: 100[kΩ], lower_side_resistor_resistance: 8.2[kΩ]
+output_voltage = voltage_current_input.output_voltage(higher_side_resistor_resistance: BigDecimal("100000"), lower_side_resistor_resistance: BigDecimal("8200"))    
+
+puts "----- Before setting PWM -----"
+
+puts "input_voltage: #{input_voltage}"
+puts "input_current: #{input_current}"
+puts "output_voltage: #{output_voltage}"
+
+puts "output_voltage / input_voltage = #{(BigDecimal(output_voltage.to_s) / BigDecimal(input_voltage.to_s)).to_f}"
+
+# The parameters for Arduino Due:
+pwm_steps = BigDecimal("255")
+
+pwm_output = ObjectOrientedBeagleboneBlackExamples::UartConnectionToArduino::PwmOutput.new(uart_connection, pwm_steps)
+
+pwm_output.send(0.5)
+
+voltage_current_input.measure
+
+# higher_side_resistor_resistance: 100[kΩ], lower_side_resistor_resistance: 8.2[kΩ]
+input_voltage = voltage_current_input.input_voltage(higher_side_resistor_resistance: BigDecimal("100000"), lower_side_resistor_resistance: BigDecimal("8200"))
+# shunt resistance: 0.04[Ω]
+input_current = voltage_current_input.input_current(resistance_for_current_measurement: BigDecimal("0.04"))
+# higher_side_resistor_resistance: 100[kΩ], lower_side_resistor_resistance: 8.2[kΩ]
+output_voltage = voltage_current_input.output_voltage(higher_side_resistor_resistance: BigDecimal("100000"), lower_side_resistor_resistance: BigDecimal("8200"))    
+
+puts "----- After setting PWM -----"
+
+puts "input_voltage: #{input_voltage}"
+puts "input_current: #{input_current}"
+puts "output_voltage: #{output_voltage}"
+
+puts "output_voltage / input_voltage = #{(BigDecimal(output_voltage.to_s) / BigDecimal(input_voltage.to_s)).to_f}"
+

data/examples/object_oriented_beaglebone_black_examples/uart_connection_to_arduino/pwm_output.rb

@@ -0,0 +1,30 @@
+require 'bigdecimal'
+
+module ObjectOrientedBeagleboneBlackExamples
+  module UartConnectionToArduino
+    class PwmOutput
+
+      def initialize(uart_connection, pwm_steps)
+        @uart_connection = uart_connection
+
+        @pwm_steps = BigDecimal(pwm_steps.to_s)
+      end
+
+      def send(duty_cycle)
+
+        duty_cycle_in_bigdecimal = BigDecimal(duty_cycle.to_s)
+        raw_value = convert_duty_cycle(duty_cycle_in_bigdecimal)
+        communication_command = "p#{raw_value}"
+
+        @uart_connection.write(serial_baud_rate: 9600, serial_data_bits: 8, serial_stop_bits: 1, communication_command: communication_command)
+
+      end  
+
+      private
+        def convert_duty_cycle(duty_cycle_in_bigdecimal)
+          (duty_cycle_in_bigdecimal * @pwm_steps).to_i
+        end  
+    
+    end
+  end
+end

data/examples/object_oriented_beaglebone_black_examples/uart_connection_to_arduino/voltage_current_input.rb

@@ -0,0 +1,73 @@
+require 'bigdecimal'
+require 'json'
+
+module ObjectOrientedBeagleboneBlackExamples
+  module UartConnectionToArduino
+    class VoltageCurrentInput
+
+      def initialize(uart_connection, analog_steps, reference_voltage)
+        @uart_connection = uart_connection
+        @voltage_current_calculation = VoltageCurrentCalculation.new(analog_steps, reference_voltage)
+      end
+
+      def measure
+
+        raw_data = @uart_connection.read(serial_baud_rate: 9600, serial_data_bits: 8, serial_stop_bits: 1, communication_command: 'm')
+
+        @raw_data_hash = JSON.parse(raw_data)
+
+      end
+
+      def input_voltage(higher_side_resistor_resistance: nil, lower_side_resistor_resistance: nil)
+
+        if @raw_data_hash.has_key?("raw_reading_for_input_voltage")
+          raw_reading_in_bigdecimal = BigDecimal(@raw_data_hash["raw_reading_for_input_voltage"].to_s)
+          voltage_in_bigdecimal = @voltage_current_calculation.voltage(raw_reading_in_bigdecimal, 
+                                                                       higher_side_resistor_resistance: higher_side_resistor_resistance, 
+                                                                       lower_side_resistor_resistance: lower_side_resistor_resistance)
+          voltage_in_bigdecimal.to_f
+        end
+
+      end
+
+      def input_current(resistance_for_current_measurement: nil, voltage_gain_for_current_measurement: BigDecimal("1.0"), voltage_current_ratio_for_current_measurement: nil)
+
+        if @raw_data_hash.has_key?("raw_reading_for_input_current")
+          raw_reading_in_bigdecimal = BigDecimal(@raw_data_hash["raw_reading_for_input_current"].to_s)
+          current_in_bigdecimal = @voltage_current_calculation.current(raw_reading_in_bigdecimal, 
+                                                                       resistance_for_current_measurement: resistance_for_current_measurement, 
+                                                                       voltage_gain_for_current_measurement: voltage_gain_for_current_measurement, 
+                                                                       voltage_current_ratio_for_current_measurement: voltage_current_ratio_for_current_measurement)
+          current_in_bigdecimal.to_f
+        end
+
+      end
+
+      def output_voltage(higher_side_resistor_resistance: nil, lower_side_resistor_resistance: nil)
+
+        if @raw_data_hash.has_key?("raw_reading_for_output_voltage")
+          raw_reading_in_bigdecimal = BigDecimal(@raw_data_hash["raw_reading_for_output_voltage"].to_s)
+          voltage_in_bigdecimal = @voltage_current_calculation.voltage(raw_reading_in_bigdecimal, 
+                                                                       higher_side_resistor_resistance: higher_side_resistor_resistance, 
+                                                                       lower_side_resistor_resistance: lower_side_resistor_resistance)
+          voltage_in_bigdecimal.to_f
+        end
+
+      end
+
+      def output_current(resistance_for_current_measurement: nil, voltage_gain_for_current_measurement: BigDecimal("1.0"), voltage_current_ratio_for_current_measurement: nil)
+
+        if @raw_data_hash.has_key?("raw_reading_for_output_current")
+          raw_reading_in_bigdecimal = BigDecimal(@raw_data_hash["raw_reading_for_output_current"].to_s)
+          current_in_bigdecimal = @voltage_current_calculation.current(raw_reading_in_bigdecimal, 
+                                                                       resistance_for_current_measurement: resistance_for_current_measurement, 
+                                                                       voltage_gain_for_current_measurement: voltage_gain_for_current_measurement, 
+                                                                       voltage_current_ratio_for_current_measurement: voltage_current_ratio_for_current_measurement)
+          current_in_bigdecimal.to_f
+        end
+
+      end      
+    
+    end
+  end
+end

data/examples/object_oriented_beaglebone_black_examples/uart_connection_to_arduino.rb

@@ -0,0 +1,8 @@
+require 'object_oriented_beaglebone_black_examples/uart_connection_to_arduino/voltage_current_input'
+require 'object_oriented_beaglebone_black_examples/uart_connection_to_arduino/pwm_output'
+
+module ObjectOrientedBeagleboneBlackExamples
+  module UartConnectionToArduino
+    # Your code goes here...
+  end
+end

data/examples/object_oriented_beaglebone_black_examples/voltage_current_calculation.rb

@@ -0,0 +1,49 @@
+require "bigdecimal"
+
+module ObjectOrientedBeagleboneBlackExamples
+  class VoltageCurrentCalculation
+
+    # The default value is for Analog Input pin of BeagleBone Black. 
+    # Since Analog Input pin reading doesn't work when it's used with PWM, 
+    # this class is created to accommodate the case where external analog digital converter is used. 
+    # e.g. Analog input pin of Arduino. 
+    def initialize(analog_steps = BigDecimal("1.8"), reference_voltage = BigDecimal("1.8"))
+      @analog_steps = analog_steps
+      @reference_voltage = reference_voltage
+    end
+
+    def voltage(raw_analog_reading, higher_side_resistor_resistance: nil, lower_side_resistor_resistance: nil)
+     
+      (raw_analog_reading / resistor_factor(higher_side_resistor_resistance, lower_side_resistor_resistance)) * @reference_voltage
+
+    end
+
+    def current(raw_analog_reading, resistance_for_current_measurement: nil, voltage_gain_for_current_measurement: BigDecimal("1.0"), voltage_current_ratio_for_current_measurement: nil)
+
+      current = nil
+
+      voltage = voltage(raw_analog_reading)
+
+      if !resistance_for_current_measurement.nil? && voltage_current_ratio_for_current_measurement.nil? # The case where voltage accross shunt resistance is directly measured
+        voltage = voltage / voltage_gain_for_current_measurement
+        current = voltage / resistance_for_current_measurement
+      elsif resistance_for_current_measurement.nil? && !voltage_current_ratio_for_current_measurement.nil? # The case where current sensor circuit is used
+        current = voltage / voltage_current_ratio_for_current_measurement
+      end
+
+      current
+
+    end
+
+    def resistor_factor(higher_side_resistor_resistance, lower_side_resistor_resistance)
+
+      if higher_side_resistor_resistance.nil? && lower_side_resistor_resistance.nil?
+        @analog_steps
+      else
+        @analog_steps * (lower_side_resistor_resistance / (higher_side_resistor_resistance + lower_side_resistor_resistance))
+      end
+
+    end
+
+  end
+end