Thiết kế tay cảm biến Robot hỗ trợ người khiếm thị Ver 0.1

Đăng lúc: Thứ năm - 17/03/2016 10:09 - Người đăng bài viết: SuperG
Arduino Sonar

Arduino Sonar

Chỉ với những linh kiện đơn giản bạn hoàn toàn có thể chế tạo ra thiết bị này với mục đích hỗ trợ người khiếm thị: tránh vật cản, nhìn đường.. hay nâng cấp hơn là tìm kiếm đồ vật.

Ver 0.1 sử dụng sóng siêu âm: Phát hiện và tránh vật cản.

Video: https://vimeo.com/27675622

 

Phần cứng:
- Arduino mini
- RC servo
- Cảm biến siêu âm SRF05
Các công cụ khác để hàn và liên kết thiết bị...
Nó bao gồm một thiết bị đeo trên tay như một chiếc găng tay, gòm nhiều cảm biến siêu âm phía trên mu bàn tay phát ra sóng siêu âm. 
Arduino là vi điều khiển chính tính toán và đo khoảng cách và gây ra tác động lên mui bàn tay người sử dụng, áp lực trên mặt sau của bàn tay. Khi đối tượng ở xa, người dùng cảm thấy ít hoặc không có áp lực tỷ lệ khoảng cách lên trên bàn tay người dùng; càng gần áp lực càng lớn.
Tacit The Haptic Sonar Glove: Hardware
Tacit, The Sonar Glove (Internal Electronics)
Tacit Haptic Sonar Glove: Shield Detail Tacit The Haptic Sonar Glove: Pressure applying servo detail
Tacit Schematic
Tacit Haptic Glove Layout

Kết nối Arduino:

RAW: Positive (+) side of the 9v battery and power pins on the servos.

GND: Battery ground (-) and grounds for servos, ultrasonic sensors.

VCC: Ultrasonic sensors +5V

2: Right ultrasonic sensor SIG

3: Left ultrasonics sensor SIG

7: Right Servo signal.

8: Left Servo signal.

Mã nguồn tham khảo :
 
#include 
const int MaxSensors = 2;                     // The number of sensor/servo pairs.
const int ServoPins[MaxSensors] = {7, 8};     // The pins they're on
const int RangingPins[MaxSensors] = {3, 2};   // The pins they're on
const int ReadingsPerSensor = 5;              // The number of historic readings to consider when determining position.
const int TimePerDegree = 9;                  // ms per degree rotation on the servo to prevent servo motor electrical noise from interfering with the ultrasonic sensor readings
const int MinimumTurnDistance = 3;            // Minimum number of degrees that the servo will turn. Keeps the servos from being too twitchy.
 
// Variables
Servo ServoList[MaxSensors];                         // Array of servo objects for manipulating easily.
int sensorReadings[MaxSensors][ReadingsPerSensor];   // Hold past readings for each sensor.
int calculatedSenorReadings[MaxSensors];             // The calculated distance for each sensor.
int latestReading = 0;                               // Current position in the array for the most recent reading.
int servoLocations[MaxSensors];                      // The current position of each sensor.
int SenorClose = 500;                                // Closest value we detect with the PING sensor. (Soundwave travel time in milliseconds.)
int SensorFar = 14000;                               // Furthest distance we register on the PING sensor. (Soundwave travel time in milliseconds.)
int ServoClose[MaxSensors] = {0, 160};               // Angle the servo turns to when something is closest.
int ServoFar[MaxSensors] = {70,110};                 // Angle the servo turns to when something is at its furthest.
 
void setup() {
 
  //Serial.begin(115200);   // Uncomment the Serial.foo lines for testing.
  //Serial.println("Begin...");
 
  // Initialize the servo location and move them through a full range of motion so we know they work.
  for (int i = 0; i < MaxSensors; i++){
     ServoList[i].attach(ServoPins[i]);
     delay(10);
     ServoList[i].write(ServoClose[i]);
     delay(500);
     ServoList[i].write(ServoFar[i]);
     delay(500);
     ServoList[i].detach();
   }
   delay(100);
 
}
 
void loop(){
  int i, j, oldLocation;
  unsigned long delayTime;
 
  // Loop through each range sensor
  for (i = 0; i < MaxSensors; i++){     // Get the current sensor's range.     sensorReadings[i][latestReading] = getDistance(i);     // Figure out an averaged/smoothed readings based on this and past data.     calculatedSenorReadings[i] = calculateNewDistace(i);     // Set the servo to the correct angle.     oldLocation = servoLocations[i];     servoLocations[i] = map(calculatedSenorReadings[i], 0, 100, ServoClose[i], ServoFar[i]);     if (latestReading >= ReadingsPerSensor-1){                          // Don't do anything until we have enough data to trend.
      if (abs(servoLocations[i]-oldLocation) >= MinimumTurnDistance){   // Only try to turn it if we have somewhere to go.
 ServoList[i].attach(ServoPins[i]);
 delay(10);
 ServoList[i].write(servoLocations[i]);
 delayTime = (TimePerDegree * (abs(servoLocations[i]-oldLocation))+20);      // Set a delay for the next reading so motor noise doesn't interfere with senor readings.
 if (abs(delayTime)>500){ // If it can't do it in this amount of time       // It's based on how far it has to turn to keep the delay to a minimum, response time at a maximum.
delayTime=500;         // we'll get it next time. Keep it responsive.
 }
 delay(delayTime);
 ServoList[i].detach();
 } else {                                          // Otherwise if the reading hasn't changed enough write the old value to
     ServoList[i].attach(ServoPins[i]);            // the servo so that it will hold in place if it's applying pressure.
 delay(10);
 ServoList[i].write(oldLocation);
 delay(50);         
 ServoList[i].detach();   
     servoLocations[i]=oldLocation;
 }
    }
    delay(20); // Added to fix left sensor misbehavior reported by Rob.
  }
 
  latestReading++; // Increment the reading counter so we know where we're at.
  if (latestReading >= ReadingsPerSensor){  // Make sure we don't record more readings than we have space to hold.
    latestReading = ReadingsPerSensor-1;
    // Pop the oldest reading off the list.
    for (i = 0; i < MaxSensors; i++){
      for (j=0; j < ReadingsPerSensor-1; j++){         sensorReadings[i][j] = sensorReadings[i][j+1];       }     }   } } // function: calculateNewDistace(sensorNumber: Which sensor's data to process): Calculated distance in 0-100 range. // Apply some averaging and smoothing to the recorded distance readings // to take care of noisy data. int calculateNewDistace(int sensorNumber){   int output = SensorFar;                      // Default value is the furthest distance.   float weightingFactor = 0.5;                 // How fast the reading's importance tapers off in time. (1= no taper, 0 = divide by zero error.)   float flickerFactor = 30;                    // When the change is greater than this, ignore it unless its two in a row. (It's probably noise.)   if (latestReading >= ReadingsPerSensor-1) {  // Only do this if we have a full set of readings to sample.
    int total = 0;                             // Average them with a weighting.
    float currentWeight = 1;                   // New readings count more than older readings.
    float percentagePossible = 0;
    boolean flickered = false;
    for (int i=ReadingsPerSensor-1; i >=0 ;i--){   // Check for flicker (This reduces jitter with something right on the threshold.)
      flickered = false;
      if (i==ReadingsPerSensor-1){
        if ((abs(sensorReadings[sensorNumber][i])-abs(sensorReadings[sensorNumber][i-1]) > flickerFactor) &&
           (abs(sensorReadings[sensorNumber][i-1])-abs(sensorReadings[sensorNumber][i-2]) > flickerFactor)){
          flickered = true;
        }
      }
      if (flickered==false){
        total += (sensorReadings[sensorNumber][i] * currentWeight);
        percentagePossible += currentWeight;
        currentWeight *= weightingFactor;
      }
    }
    output = total / percentagePossible;
  }
  return output;
}
// function: getDistance
// Take a sensor number (not pin number) and returns an int in the 0-100 range
// 0 = closest, 100= furthest.  (It's a percentage of the distance that the software
//
// Note: Function is designed to be generic so that it can be swapped out for
//       different kinds of ranging sensors.
//       This version of the function is made for Parallax PING))) sensors
//       For more info see http://arduino.cc/en/Tutorial/Ping
//                     and http://www.parallax.com/tabid/768/ProductID/92/Default.aspx
int getDistance(int sensorNumber){
  long duration;   // How long it takes a sonic pulse to reflect back.
  int out;         // The value we send back from the function
 
  // Initialize the sensor and tell it to send out a ping.
  pinMode(RangingPins[sensorNumber], OUTPUT);
  digitalWrite(RangingPins[sensorNumber], LOW);
  delayMicroseconds(2);
  digitalWrite(RangingPins[sensorNumber], HIGH);
  delayMicroseconds(5);
  digitalWrite(RangingPins[sensorNumber], LOW);
 
  // Read the time in milliseconds until the value comes back.
  pinMode(RangingPins[sensorNumber], INPUT);
  duration = pulseIn(RangingPins[sensorNumber], HIGH);
 
  // Trim the data into minimums and maximums and map it to the 0-100 output range.
  duration = constrain(duration, SenorClose, SensorFar);
  out = map(duration,  SenorClose, SensorFar, 0, 100);
  return out;
}
// end
// other glove
 
Bản nâng cấp: Kết hợp công nghệ camera cho phép nhận dạng và tìm kiếm đồ vật, hỗ trợ dạy và cập nhật dữ liệu cho thiết bị.

Phần cứng dự kiến bổ sung:

- Siêu âm tầm xa

- Tai nghe không dây

- Camera 


Nguồn tin: medgadget.com
Từ khóa:

n/a

Đánh giá bài viết
Tổng số điểm của bài viết là: 0 trong 0 đánh giá
Click để đánh giá bài viết
 

Quy trình xử lý

Hướng dẫn quý khách hàng tìm hiểu làm quen với cách sử dụng sản phẩm và dịch vụ trong lĩnh vực Robot gia dụng chúng tôi cung cấp. Đặt vấn đề: Khách hàng liên hệ qua Email hoặc Điện thoại, ghi chú nội dung liên hệ và thông tin yêu cầu sản phẩm dịch vụ sơ bộ. Xử lý thông tin: Chúng tôi sẽ trực...

Thăm dò ý kiến

Bạn có muốn sở hữu một Robot trong nhà không?

Cần một Robot để dọn dẹp

Cần một Robot trông nhà

Cần một Robot để giải trí

Bạn cần một Robot theo cách khác

Bạn đã có rồi

Bạn không cần

Liên kết