Quick release buckle

Abstract

Quick Release Buckle (QRB) is an automated seatbelt system. QRB utilizes a power source and control unit software incorporated into pre-existing components within the vehicle's transmission or by micro-switch. QRB automatically disengages the seatbelt upon placing the vehicle in “park”, regardless of the ignition setting for law enforcement/military vehicles. While in “park”, an electrical signal energizes a solenoid releasing the buckle. The control unit contains proprietary software that records every engage/disengage of the seatbelt. Electronic records can be downloaded at any time, using an integrated micro-scan disk (SD) module/card. During a collision, the system ceases to record activity, showing electronic proof the seatbelt was engaged/disengaged. Civilian application includes accident investigations, insurance inquiries, and private company regulation compliance. Civilian QRB differs slightly as the transmission must be placed in “park” and the ignition must be in “off” for system operation.

Claims

1. A quick release buckle system comprising: At least one seat belt buckle for use in a vehicle, the seat belt buckle including a latching mechanism and a latching tongue; A micro control unit connected to the seat belt buckle and configured to be connected to a transmission, electrical system of the vehicle or switch, the micro control unit configured to perform the following steps: a. Determine whether the vehicle is a law enforcement vehicle or a civilian vehicle; b. Upon determining that the vehicle is the law enforcement vehicle, configuring the seat belt buckle to release the latching mechanism when the vehicle is placed in a park position, and an ignition of the law enforcement vehicle is in one of the on or off position as set by an operator of the vehicle; and c. Upon deterring that the vehicle is the civilian vehicle, configuring the seat belt buckle to release the latching mechanism when the vehicle is placed in the park position and an ignition of the civilian vehicle is in the off position; the seat belt buckle is configured to additionally contain manual releasing capability.

2. The seat belt buckle system of claim 1, wherein the at least one seat belt buckle is configured to be attached to one of a front seat or a rear seat of the vehicle.

3. The seat belt buckle system of claim 1, wherein the at least one seat belt buckle is a plurality of seat belt buckles, the plurality of seat belt buckles each being configured to be attached to one of a front seat or a rear seat of the vehicle.

4. The seat belt buckle system of claim 3, wherein the plurality of seat belt buckles are configured individually to have the steps to be turned on and off by an operator of the vehicle.

5. The seat belt buckle system of claim 1, wherein the seat belt buckle is configured to have the steps to be turned on and off by an operator of the vehicle.

6. A law enforcement vehicle containing the seat belt buckle system of claim 1, upon recognizing the law enforcement vehicle, the seat belt buckle is configured to release the latching mechanism when the vehicle is placed in a park position, and an ignition of the law enforcement vehicle is in one of the on or off position as set by the operator of the vehicle.

7. A civilian vehicle containing the seat belt buckle system of claim 1, upon recognizing the civilian vehicle, the seat belt buckle is configured to release the latching mechanism when the vehicle is placed in the park position and an ignition of the civilian vehicle is in the off position.

8. The seat belt buckle system of claim 1, wherein the seat belt buckle is configured to record each operation of the seat belt buckle, these operations being configured to be downloaded when necessary, using a removable Micro Scan Disk, Universal Serial Bus, Bluetooth, On-board Diagnostics, or Direct Data Port.

9. The law enforcement vehicle of claim 6, wherein the seat belt buckle is configured to record each operation of the seat belt buckle, these operations being configured to be downloaded when necessary, using a removable Micro Scan Disk, Universal Serial Bus, Bluetooth, On-board Diagnostics, or Direct Data Port.

10. The civilian vehicle of claim 7, wherein the seat belt buckle is configured to record each operation of the seat belt buckle, these operations being configured to be downloaded when necessary, using a removable Micro Scan Disk, Universal Serial Bus, Bluetooth, On-board Diagnostics, or Direct Data Port.

11. The law enforcement vehicle of claim 6, further comprising an override button located near a driver door instrument cluster to allow first responders to disengage the seat belt buckle system in an event of an accident or other emergency situation.

12. The civilian vehicle of claim 7, further comprising an override button located near a driver door instrument cluster to allow first responders to disengage the seat belt buckle system in an event of an accident or other emergency situation.

13. The seat belt buckle system of claim 1, further comprising the latching mechanism including a buckle slider, pull cable and a solenoid for attaching the latching mechanism to the latching tongue.

Description

BRIEF DESCRIPTION OF THE DRAWINGS

(1) FIG. 1—Circuit Design of the QRB system.

(2) FIG. 2—Physical Circuit depicts the actuator controlling the buckle that is controlled by a five-volt relay receiving control signals and the input voltage (Vin) pin of the Arduino MCU. The negative output of the 12-volt power supply was connected to negative wire of the actuator and the ground (GND) pin of the Arduino MCU. The positive wire of the actuator was connected to the normally open output pin of the relay. The five-volt relay's input pins were the input voltage pin (VCC), signal input (IN), and ground (GND). The VCC pin was connected to the five-volt output pin of the Arduino MCU. The IN pin was connected to a digital pin of the Arduino MCU to receive signals. The GND pin of the relay was connected to the ground of the Arduino MCU. Three switches were connected to digital pins of the Arduino MCU. The three switches were tied together at one end to ground and used the Arduino MCU's onboard pullup resistances. This method was used to eliminate the need for connected to a 32-kilobyte memory chip. The memory chip was connected to the five-volt and GND pins of the Arduino MCU physical resistors.

(3) FIG. 3—Logic Code flowchart of how the QRB operates. The first decision is whether or not the car is a law enforcement or civilian vehicle. If the car is a law enforcement vehicle, the MCU checks if the car is in “park”. If the car is in park, then the buckle is released. If the car is a civilian vehicle, the MCU checks if the car is in “park” or not. If the car is in park, the MCU checks if the ignition is on or not. If the ignition is off, then the buckle is released. QRB contains a data logging system that records a value of 255 to the next memory address whenever a pulse is recorded. This simulates recording the belt unbuckling using the vehicle's real-time clock. The current design also records a value of 127 to the next memory address once the buckle resets to simulate recording the time that the buckled was re-engaged. When the memory is full, the values are overwritten starting at the initial location. The code also allows for a fourth switch to be added that simulates an accident. If an accident occurs, the event is logged, and the memory is software-locked to prevent tampering.

(4) FIG. 4—Buckle Release Design is the method which the process of releasing the QRB with the Arduino MCU. Once the decision is made by the Arduino MCU to release the belt buckle, a 12-volt solenoid actuator is pulse activated wherein a cable attached between the actuator and buckle slider is configured to be pulled as the actuator compresses electromagnetically. The cable will then move the buckle slider from the locked to the unlocked position releasing the buckle tongue. Once the action is initiated, the actuator will decompress as the 12-volt pulse is over returning the buckle slider back to the original position.

(5) FIG. 5 represents a Computer Aided Design (CAD) drawing of the buckle along with a solenoid depicting the pulling action of the system during disengagement.

(6) FIG. 6 represents a standard seatbelt buckle and mounting arm CAD drawing, modified with a pull cable mount (top view) the pull to the solenoid for actuation.

(7) FIG. 7 represents a Computer Aided Design (CAD) drawing of the buckle.

(8) FIG. 8 represents a standard seatbelt buckle CAD drawing modified with the pull cable mounted securely to the buckle arm, (bottom view) the opposite end of the pull cable is then attached to the solenoid for actuation.

(9) FIG. 9 represents a CAD drawing of an internal view of the buckle, modified with a pull cable both to the release button and securely mounted to the arm and (bottom view) the opposite end of the pull cable is then attached to the solenoid for actuation.

DETAILED DESCRIPTION

(10) For a clear and better understanding of the QRB; reference and description with accompanying:

(11) Circuit Design—FIG. 1 contains the circuit design of the QRB system. The Physical Circuit—FIG. 2 depicts the solenoid controlling the buckle that is controlled by a five-volt relay receiving control signals from an Arduino (microcontroller unit) MCU. The relay was selected to switch power on or off to the buckle depending on the conditions of the vehicle. The positive output of the 12-volt power supply was connected to the common output pin of the relay and the input voltage (Vin) pin of the Arduino MCU. The negative output of the 12-volt power supply was connected to negative wire of the actuator and the ground (GND) pin of the Arduino MCU. The positive wire of the actuator was connected to the normally open output pin of the relay.

(12) The five-volt relay's input pins were the input voltage pin (VCC), signal input (IN), and ground (GND). The VCC pin was connected to the five-volt output pin of the Arduino MCU. The IN pin was connected to a digital pin of the Arduino MCU to receive signals. The GND pin of the relay was connected to the ground of the Arduino MCU. Three switches were connected to digital pins of the Arduino MCU. The three switches were tied together at one end to ground and used the Arduino MCU's onboard pullup resistances. This method was used to eliminate the need for connected to a 32-kilobyte memory chip. The memory chip was connected to the five-volt and GND pins of the Arduino MCU physical resistors and reduce number of wires.

(13) Logic Code—FIG. 3 represents the logic flowchart of how the QRB operates. The first decision is whether or not the car is a law enforcement or civilian vehicle. If the car is a law enforcement vehicle, the MCU checks if the car is in “park”. If the car is in park, then the buckle is released. If the car is a civilian vehicle, the MCU checks if the car is in “park” or not. If the car is in park, the MCU checks if the ignition is on or not. If the ignition is off, then the buckle is released. QRB contains a data logging system that records a value of 255 to the next memory address whenever a pulse is recorded. This simulates recording the belt unbuckling using the vehicle's real-time clock. The current design also records a value of 127 to the next memory address once the buckle resets to simulate recording the time that the buckled was re-engaged. When the memory is full, the values are overwritten starting at the initial location. The code also allows for a fourth switch to be added that simulates an accident. If an accident occurs, the event is logged, and the memory is software-locked to prevent tampering.

(14) Buckle Release Design—FIG. 4 is the method which the process of releasing the QRB with the Arduino MCU. Once the decision is made by the Arduino MCU to release the belt buckle, a 12-volt solenoid is pulse activated wherein a cable attached between the solenoid and buckle slider is configured to be pulled as the solenoid compresses electromagnetically. The cable will then move the buckle slider from the locked to the unlocked position releasing the buckle tongue. Once the action is initiated, the solenoid will decompress as the 12-volt pulse is over returning the buckle slider back to the original position.

(15) Most automakers outsource the design and construction of personal safety restraint systems to third party vendors; therefore, the design was created using a seat belt assembly from a Ford Taurus which was easily sourced. The intent of the QRB is to be easily implemented in any vehicle that is used by LEOs, the choice of which seat belt assembly was chosen was not a crucial element.

(16) An important element in the design is selecting a mechanism to be able to pull the seat belt release slide with enough force to release the seat belt buckle. The average release button for a seat belt needs to be depressed one-half inch and requires 3 lbf (pounds of force) to release the buckle. An important aspect that was considered when looking at options was for the mechanism to use enough force to operate the seat belt assembly but not so forceful as to cause damage to the buckle release mechanism or the QRB. Since it was important to find easily sources parts, a 12-volt solenoid was chosen. The solenoid has a one-inch stroke and pulls with at least five (5) pounds of force which is strong enough to effectively accomplish releasing the buckle.

(17) To connect to buckle release slide to the actuator there was a couple of factors to consider. One factor is the cable has the flexibility to be capable of being incorporated into the design of the buckle release and existing wiring. The second factor is the cable needing to be strong to handle the force releasing the buckle and rigid enough to allow the solenoid actuator to pull the cable allowing the buckle slide release. A brake cable was chosen for both strength and dexterity since its design is meant to be robust enough to repeatedly pull the release slide without breaking yet be flexible enough to follow the sensor wiring and car frame cable restraints. FIG. 5 represents a Computer Aided Design (CAD) drawing of the buckle.

Quick Release Buckle Logic Proprietary Code

(18) // Include libraries needed for FRAM chip

(19) #include <Wir.h>

(20) #include “Adafmit_FRAM_I2C.h”

(21) // Initialize the FRAM chip object for read and write manipulation

(22) Adafmit_FRAM_I2C fram=Adafmit_FRAM_I2C( );

(23) uint6 t framAddr=0;

(24) // Define the pins on the Arduino MCU

(25) #define ACCIDENT_SWITCH 2 // Button that simulates an accident, locking the memory chip until reset

(26) #define VEHICLE SWITCH 3 // Controls whether operating in law enforcement or civilian vehicle

(27) #define IGNITION SWITCH 4 // Controls whether the car is on or not (only applies to civilian vehicle)

(28) #define PARK SWITCH 5 // Controls whether the car is in park or not

(29) #define RAM LOCK 6 // Locks the memory as soon as an accident is detected

(30) #define RELEASE PIN 7 // The pin that sends the release signal to the buckle

(31) #define BOARD LED 13 // On board LED to indicate accident

(32) #define ACCIDENT ID 0xFF // Constant to indicate recording an accident

(33) // How long the pulse lasts in milliseconds

(34) #define PULSE TIME 200

(35) // The different state variables based on the switches

(36) int vehicleState; // Is the car in law enforcement mode or civilian mode

(37) in ignitionState; // Is the car on or not (only applies to civilian vehicle)

(38) in parkState; // Is the car in park or not

(39) int accidentState; // Is there an accident detected

(40) int previousAccidentState; // Save the initial state of the ACCIDENT_SWITCH to know when it was detected

(41) int previousParkState; // Was the car previously in park or not (to ensure the buckle can be latched again)

(42) int previousignitionState; // Was the car's ignition previously on or not (for civilian vehicle)

(43) int buckleReleased; // Check if the buckle was released or not for data logging purposes

(44) // Tracker to know what address to write to on each pulse

(45) uint8_t addrCoun;

(46) // This code initializes pins

(47) void setup( ) {

(48) // Setup serial communications (for debugging only)

(49) Serial.begin(115200);

(50) // Initialize the FRAM object

(51) if (fram.begin( )) { Serial.println(“Found I2C FRAM”);

(52) }

(53) else ( Serial.pritln(“I2C FRAM not identified . . . check connections\r\n”); Serial.pritln(“Will continue in case this processor doesn't support repeated start\r\n”);

(54) }

(55) // Get the address tracker value

(56) addrCount=fram.read8(0x0);

(57) // Setup pins using internal pullup resistors on the MCU

(58) pinMode(ACCIDENT_SWITCH, INPUT_PULLUP); // Accident simulator

(59) pinMode(VEHICLE_SWITCH, INPUT_PULLUP); // Read vehicle state: LOW-Civilian, HIGH-Law enforcement

(60) pinMode(IGNITION_SWITCH, INPUT_PULLUP); // Read ignition state: Civilian vehicle only, LOW is off

(61) pinMode(PARK_SWITCH, INPUT_PULLUP); // Read park state: HIGH represents in park

(62) pinMode(RELEASE_PIN, OUTPUT); // Set release pin high to release buckle

(63) pinMode(RAM_LOCK, OUTPUT); // Pin to lock RAM when accident is detected

(64) pinMode(BOARD_LED, OUTPUT); // On-board LED indicating RAM is locked

(65) digitalWrite(RAM_LOCK, LOW); // Allow RAM to be written to

(66) digitalWrite(RELEASE_PIN, HIGH); // Initialize relay to off

(67) previousParkState=HIGH; // Set the state of park to HIGH or OFF (based on circuitry) initially

(68) previousignitionState=LOW; // Set the state of park to LOW or ON (based on circuitry) initially

(69) buckleReleased=LOW; // Set the state of buckle released to be LOW or FALSE initially

(70) previousAccidentState=digitalRead(ACCIDENT_SWITCH);

(71) }

(72) // This code continuously runs and contains the control logic

(73) void loop( ) {

(74) // Read the states of the four switches

(75) accidentState=digitalRead(ACCIDENT_SWITCH);

(76) vehicleState=digitadRead(VEHICLE_SWITCH);

(77) ignitionState=digitalRead(IGNITION_SWITCH);

(78) parkState=digitalRead(PARK_SWITCH);

(79) // If accident switch is flipped, write to memory that an accident was detected, lock the software

(80) If (accidentState !=previousAccidentState) { memWrite(ACCIDENT_ID); // Write accident to memory digitalWrite(BOARD_LED, HIGH); digitalWrite(RAM_LOCK, HIGH); // Lock the RAM Serial.println(“Accident Detected”); //Debugging while (1) { }

(81) }

(82) // If the car is in law enforcement mode, placed in park, and the car was not previously in park, release the buckle

(83) if (!vehicleState && !parkState && previousParkState) { releaseBuckle( );

(84) }

(85) // If the car is in civilian mode, placed in park, ignition is off, and the car was not previously in park, release the buckle

(86) else If (vehicleState && ignitionState && !parkState && !previousIgnitionState) { releaseBuckle( );

(87) }

(88) // The new previous state will be the current state

(89) previousParkState=parkState;

(90) previousIgnitionState=ignitionState;

(91) // Prints out the states of the switches. For debugging purposes only

(92) Serial.print(“Vehicle Switch is:”); Serial.println(vehicleState);

(93) Serial.print(“Ignition Switch is:”); Serial.println(ignitionState);

(94) Serial.print(“Park Switch is:”); Serial.println(parkState);

(95) Serial.print(“Previous park state was:”); Serial.println(previousParkState);

(96) Serial.println( );

(97) Serial.println( );

(98) Serial.println( );

(99) // delay(2500); //Debugging

(100) }

(101) // Function for writing the pulse signal to the next address of memory

(102) void memWrite(int pulse) {

(103) // Go to the next address

(104) addrCount++;

(105) // If the RAM is full, go back to the first address and write to it

(106) If (addrCount==32768) { addrCount=0;

(107) }

(108) // Write the next address to be written to in the first address

(109) fram.write8(0x0, addrCount);

(110) // Write to memory that an accident occurred If detected

(111) If (accidentState !=previousAccidentState) { Serial.prinln(“Recorded accident . . . ”); fram.writeS(addrCount, 0x46); // Write hex ‘F’ to current memory location addrCount++; // Move to next memory location fram.write8(addrCount, 0x75); // Write hex ‘u’ to current memory location addrCount++; // Move to next memory location fram.write8(addrCount, 0x63); // Write hex c to current memory location addrCount++; // Move to next memory location fram.writeS(addrCount, 0x6b); // Write hex ‘k’ to current memory location fram.write8(0x0, addrCount); // Write current memory location to the first byte to keep track return;

(112) }

(113) if (pulse) {

(114) // Write #FF in hexadecimal to indicate buckle disengagement to the current address

(115) fram.writeS(addrCount, 255);

(116) }

(117) else {

(118) // Write #7F in hexadecimal to indicate buckle re-engagement to the current address

(119) fram.write8(addrCount, 127);

(120) }

(121) }

(122) // This function releases the buckle when the proper conditions are met

(123) void releaseBuckle( ) {

(124) digitalWrite(RELEASE_PIN, LOW); // Send pulse to release the buckle

(125) buckleReleased=HIGH; // Buckle was released

(126) memWrite(buckleReleased); // Write to memory that the buckle was released

(127) Serial.println(“Release buckle”); // Debugging

(128) delay(PULSE_TIME); // Do nothing to ensure proper unbuckling

(129) digitalWrite(RELEASE_PIN, HIGH); // Re-engage the buckle

(130) buckleReleased=LOW; // Buckle was re-engaged

(131) memWrite(buckleReleased); // Write to memory that the buckle was re-engaged