মোশন সেন্সর

অ্যান্ড্রয়েড প্ল্যাটফর্মটি বেশ কয়েকটি সেন্সর সরবরাহ করে যা আপনাকে একটি ডিভাইসের গতিবিধি পর্যবেক্ষণ করতে দেয়।

সেন্সরের সম্ভাব্য স্থাপত্য সেন্সরের ধরণ অনুসারে পরিবর্তিত হয়:

• মাধ্যাকর্ষণ, রৈখিক ত্বরণ, ঘূর্ণন ভেক্টর, উল্লেখযোগ্য গতি, ধাপ কাউন্টার এবং ধাপ সনাক্তকারী সেন্সরগুলি হয় হার্ডওয়্যার-ভিত্তিক অথবা সফ্টওয়্যার-ভিত্তিক।
• অ্যাক্সিলোমিটার এবং জাইরোস্কোপ সেন্সরগুলি সর্বদা হার্ডওয়্যার-ভিত্তিক।

বেশিরভাগ অ্যান্ড্রয়েড-চালিত ডিভাইসে অ্যাক্সিলোমিটার থাকে এবং অনেক ডিভাইসে এখন জাইরোস্কোপ থাকে। সফ্টওয়্যার-ভিত্তিক সেন্সরগুলির প্রাপ্যতা আরও পরিবর্তনশীল কারণ তারা প্রায়শই তাদের ডেটা সংগ্রহের জন্য এক বা একাধিক হার্ডওয়্যার সেন্সরের উপর নির্ভর করে। ডিভাইসের উপর নির্ভর করে, এই সফ্টওয়্যার-ভিত্তিক সেন্সরগুলি অ্যাক্সিলোমিটার এবং ম্যাগনেটোমিটার বা জাইরোস্কোপ থেকে তাদের ডেটা সংগ্রহ করতে পারে।

মোশন সেন্সরগুলি ডিভাইসের নড়াচড়া পর্যবেক্ষণের জন্য কার্যকর, যেমন টিল্ট, শেক, রোটেশন, বা সুইং। নড়াচড়া সাধারণত ব্যবহারকারীর সরাসরি ইনপুটের প্রতিফলন (উদাহরণস্বরূপ, কোনও ব্যবহারকারী কোনও গেমে গাড়ি চালাচ্ছেন বা কোনও ব্যবহারকারী কোনও গেমে বল নিয়ন্ত্রণ করছেন), তবে এটি ডিভাইসটি যে ভৌত পরিবেশে বসে আছে তার প্রতিফলনও হতে পারে (উদাহরণস্বরূপ, আপনি যখন আপনার গাড়ি চালাচ্ছেন তখন আপনার সাথে চলছেন)। প্রথম ক্ষেত্রে, আপনি ডিভাইসের ফ্রেম অফ রেফারেন্স বা আপনার অ্যাপ্লিকেশনের ফ্রেম অফ রেফারেন্সের সাথে সম্পর্কিত গতি পর্যবেক্ষণ করছেন; দ্বিতীয় ক্ষেত্রে আপনি বিশ্বের ফ্রেম অফ রেফারেন্সের সাথে সম্পর্কিত গতি পর্যবেক্ষণ করছেন। মোশন সেন্সরগুলি সাধারণত ডিভাইসের অবস্থান পর্যবেক্ষণ করতে ব্যবহৃত হয় না, তবে এগুলি অন্যান্য সেন্সরের সাথে ব্যবহার করা যেতে পারে, যেমন ভূ-চৌম্বকীয় ক্ষেত্র সেন্সর, বিশ্বের ফ্রেম অফ রেফারেন্সের সাথে সম্পর্কিত একটি ডিভাইসের অবস্থান নির্ধারণ করতে (আরও তথ্যের জন্য অবস্থান সেন্সর দেখুন)।

প্রতিটি SensorEvent এর জন্য সকল মোশন সেন্সর বহুমাত্রিক অ্যারে সেন্সর মান প্রদান করে। উদাহরণস্বরূপ, একটি একক সেন্সর ইভেন্টের সময় অ্যাক্সিলোমিটার তিনটি স্থানাঙ্ক অক্ষের জন্য ত্বরণ বল ডেটা প্রদান করে এবং জাইরোস্কোপ তিনটি স্থানাঙ্ক অক্ষের জন্য ঘূর্ণন হার ডেটা প্রদান করে। এই ডেটা মানগুলি অন্যান্য SensorEvent প্যারামিটারের সাথে একটি float অ্যারে ( values ) তে ফেরত পাঠানো হয়। টেবিল 1 অ্যান্ড্রয়েড প্ল্যাটফর্মে উপলব্ধ মোশন সেন্সরগুলির সারসংক্ষেপ তুলে ধরে।

সারণী ১। অ্যান্ড্রয়েড প্ল্যাটফর্মে সমর্থিত মোশন সেন্সর।

^১ স্কেলার উপাদানটি একটি ঐচ্ছিক মান।

ঘূর্ণন ভেক্টর সেন্সর এবং মাধ্যাকর্ষণ সেন্সর হল গতি সনাক্তকরণ এবং পর্যবেক্ষণের জন্য সর্বাধিক ব্যবহৃত সেন্সর। ঘূর্ণন ভেক্টর সেন্সরটি বিশেষভাবে বহুমুখী এবং এটি গতি-সম্পর্কিত বিভিন্ন কাজের জন্য ব্যবহার করা যেতে পারে, যেমন অঙ্গভঙ্গি সনাক্তকরণ, কৌণিক পরিবর্তন পর্যবেক্ষণ এবং আপেক্ষিক অভিযোজন পরিবর্তন পর্যবেক্ষণ। উদাহরণস্বরূপ, যদি আপনি একটি গেম, একটি অগমেন্টেড রিয়েলিটি অ্যাপ্লিকেশন, একটি 2-মাত্রিক বা 3-মাত্রিক কম্পাস, অথবা একটি ক্যামেরা স্থিতিশীলকরণ অ্যাপ তৈরি করেন তবে ঘূর্ণন ভেক্টর সেন্সরটি আদর্শ। বেশিরভাগ ক্ষেত্রে, অ্যাক্সিলোমিটার এবং জিওম্যাগনেটিক ফিল্ড সেন্সর বা ওরিয়েন্টেশন সেন্সর ব্যবহারের চেয়ে এই সেন্সরগুলি ব্যবহার করা একটি ভাল পছন্দ।

অ্যান্ড্রয়েড ওপেন সোর্স প্রজেক্ট সেন্সর

অ্যান্ড্রয়েড ওপেন সোর্স প্রজেক্ট (AOSP) তিনটি সফ্টওয়্যার-ভিত্তিক মোশন সেন্সর সরবরাহ করে: একটি গ্র্যাভিটি সেন্সর, একটি লিনিয়ার অ্যাক্সিলারেশন সেন্সর এবং একটি রোটেশন ভেক্টর সেন্সর। এই সেন্সরগুলি অ্যান্ড্রয়েড 4.0 এ আপডেট করা হয়েছিল এবং এখন স্থিতিশীলতা এবং কর্মক্ষমতা উন্নত করার জন্য একটি ডিভাইসের জাইরোস্কোপ (অন্যান্য সেন্সর ছাড়াও) ব্যবহার করে। আপনি যদি এই সেন্সরগুলি চেষ্টা করতে চান, তাহলে আপনি getVendor() পদ্ধতি এবং getVersion() পদ্ধতি ব্যবহার করে এগুলি সনাক্ত করতে পারেন (বিক্রেতা হল Google LLC; সংস্করণ নম্বর 3)। বিক্রেতা এবং সংস্করণ নম্বর দ্বারা এই সেন্সরগুলি সনাক্ত করা প্রয়োজনীয় কারণ অ্যান্ড্রয়েড সিস্টেম এই তিনটি সেন্সরকে সেকেন্ডারি সেন্সর হিসাবে বিবেচনা করে। উদাহরণস্বরূপ, যদি কোনও ডিভাইস প্রস্তুতকারক তাদের নিজস্ব গ্র্যাভিটি সেন্সর সরবরাহ করে, তাহলে AOSP গ্র্যাভিটি সেন্সরটি সেকেন্ডারি গ্র্যাভিটি সেন্সর হিসাবে প্রদর্শিত হবে। এই তিনটি সেন্সরই একটি জাইরোস্কোপের উপর নির্ভর করে: যদি কোনও ডিভাইসে জাইরোস্কোপ না থাকে, তাহলে এই সেন্সরগুলি প্রদর্শিত হবে না এবং ব্যবহারের জন্য উপলব্ধ থাকবে না।

মাধ্যাকর্ষণ সেন্সর ব্যবহার করুন

মাধ্যাকর্ষণ সেন্সরটি একটি ত্রিমাত্রিক ভেক্টর প্রদান করে যা মাধ্যাকর্ষণটির দিক এবং মাত্রা নির্দেশ করে। সাধারণত, এই সেন্সরটি মহাকাশে ডিভাইসের আপেক্ষিক অভিযোজন নির্ধারণ করতে ব্যবহৃত হয়। নিম্নলিখিত কোডটি আপনাকে ডিফল্ট মাধ্যাকর্ষণ সেন্সরের একটি উদাহরণ কীভাবে পেতে হয় তা দেখায়:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY);

ইউনিটগুলি ত্বরণ সেন্সর দ্বারা ব্যবহৃত ইউনিটগুলির মতোই (m/s ² ), এবং স্থানাঙ্ক সিস্টেমটি ত্বরণ সেন্সর দ্বারা ব্যবহৃত ইউনিটের মতোই।

দ্রষ্টব্য: যখন একটি ডিভাইস স্থির অবস্থায় থাকে, তখন মাধ্যাকর্ষণ সেন্সরের আউটপুট অ্যাক্সিলোমিটারের আউটপুটের মতো হওয়া উচিত।

লিনিয়ার অ্যাক্সিলোমিটার ব্যবহার করুন

রৈখিক ত্বরণ সেন্সর আপনাকে একটি ত্রিমাত্রিক ভেক্টর প্রদান করে যা প্রতিটি ডিভাইস অক্ষ বরাবর ত্বরণ প্রতিনিধিত্ব করে, মাধ্যাকর্ষণ বাদ দিয়ে। আপনি এই মানটি অঙ্গভঙ্গি সনাক্তকরণ সম্পাদন করতে ব্যবহার করতে পারেন। মানটি একটি ইনর্শিয়াল নেভিগেশন সিস্টেমের ইনপুট হিসাবেও কাজ করতে পারে, যা ডেড রেকনিং ব্যবহার করে। নিম্নলিখিত কোডটি আপনাকে দেখায় কিভাবে ডিফল্ট রৈখিক ত্বরণ সেন্সরের একটি উদাহরণ পেতে হয়:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION);

ধারণাগতভাবে, এই সেন্সরটি আপনাকে নিম্নলিখিত সম্পর্ক অনুসারে ত্বরণ ডেটা সরবরাহ করে:

linear acceleration = acceleration - acceleration due to gravity

সাধারণত যখন আপনি মাধ্যাকর্ষণের প্রভাব ছাড়াই ত্বরণ ডেটা পেতে চান তখন আপনি এই সেন্সরটি ব্যবহার করেন। উদাহরণস্বরূপ, আপনার গাড়ি কত দ্রুত চলছে তা দেখার জন্য আপনি এই সেন্সরটি ব্যবহার করতে পারেন। রৈখিক ত্বরণ সেন্সরে সর্বদা একটি অফসেট থাকে, যা আপনাকে অপসারণ করতে হবে। এটি করার সবচেয়ে সহজ উপায় হল আপনার অ্যাপ্লিকেশনে একটি ক্রমাঙ্কন ধাপ তৈরি করা। ক্রমাঙ্কনের সময় আপনি ব্যবহারকারীকে ডিভাইসটি একটি টেবিলে সেট করতে বলতে পারেন এবং তারপরে তিনটি অক্ষের জন্য অফসেটগুলি পড়তে পারেন। তারপরে আপনি প্রকৃত রৈখিক ত্বরণ পেতে ত্বরণ সেন্সরের সরাসরি রিডিং থেকে সেই অফসেটটি বিয়োগ করতে পারেন।

সেন্সর স্থানাঙ্ক সিস্টেমটি ত্বরণ সেন্সর দ্বারা ব্যবহৃত সিস্টেমের মতোই, এবং পরিমাপের এককগুলিও (m/s ² )।

ঘূর্ণন ভেক্টর সেন্সর ব্যবহার করুন

ঘূর্ণন ভেক্টরটি একটি কোণ এবং একটি অক্ষের সংমিশ্রণ হিসাবে ডিভাইসের ওরিয়েন্টেশনকে প্রতিনিধিত্ব করে, যেখানে ডিভাইসটি একটি অক্ষের (x, y, অথবা z) চারপাশে একটি কোণ θ এর মধ্য দিয়ে ঘোরানো হয়েছে। নিম্নলিখিত কোডটি আপনাকে ডিফল্ট ঘূর্ণন ভেক্টর সেন্সরের একটি উদাহরণ কীভাবে পেতে হয় তা দেখায়:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);

ঘূর্ণন ভেক্টরের তিনটি উপাদান নিম্নরূপ প্রকাশ করা হয়েছে:

যেখানে ঘূর্ণন ভেক্টরের মান sin(θ/2) এর সমান, এবং ঘূর্ণন ভেক্টরের দিক ঘূর্ণন অক্ষের দিকের সমান।

চিত্র ১. ঘূর্ণন ভেক্টর সেন্সর দ্বারা ব্যবহৃত স্থানাঙ্ক ব্যবস্থা।

ঘূর্ণন ভেক্টরের তিনটি উপাদান একটি একক চতুর্ভুজের শেষ তিনটি উপাদানের সমান (cos(θ/2), x*sin(θ/2), y*sin(θ/2), z*sin(θ/2))। ঘূর্ণন ভেক্টরের উপাদানগুলি এককবিহীন। x, y, এবং z অক্ষগুলিকে ত্বরণ সেন্সরের মতো একইভাবে সংজ্ঞায়িত করা হয়েছে। রেফারেন্স স্থানাঙ্ক ব্যবস্থাকে একটি সরাসরি অর্থনরমাল ভিত্তি হিসাবে সংজ্ঞায়িত করা হয়েছে (চিত্র 1 দেখুন)। এই স্থানাঙ্ক ব্যবস্থার নিম্নলিখিত বৈশিষ্ট্য রয়েছে:

• X কে ভেক্টর গুণফল Y x Z হিসেবে সংজ্ঞায়িত করা হয়েছে। এটি ডিভাইসের বর্তমান অবস্থানে ভূমির স্পর্শক এবং প্রায় পূর্ব দিকে নির্দেশ করে।
• ডিভাইসের বর্তমান অবস্থানে Y ভূমির স্পর্শক এবং ভূ-চৌম্বকীয় উত্তর মেরুর দিকে নির্দেশ করে।
• Z আকাশের দিকে নির্দেশ করে এবং ভূমির সমতলের সাথে লম্ব।

ঘূর্ণন ভেক্টর সেন্সর কীভাবে ব্যবহার করতে হয় তা দেখানোর জন্য একটি নমুনা অ্যাপ্লিকেশনের জন্য, RotationVectorDemo.java দেখুন।

উল্লেখযোগ্য গতি সেন্সর ব্যবহার করুন

প্রতিবার উল্লেখযোগ্য গতি সনাক্ত হওয়ার সময় উল্লেখযোগ্য গতি সেন্সর একটি ইভেন্ট ট্রিগার করে এবং তারপর এটি নিজেকে অক্ষম করে। একটি উল্লেখযোগ্য গতি হল এমন একটি গতি যা ব্যবহারকারীর অবস্থান পরিবর্তন করতে পারে; উদাহরণস্বরূপ হাঁটা, সাইকেল চালানো, অথবা চলন্ত গাড়িতে বসে থাকা। নিম্নলিখিত কোডটি আপনাকে দেখায় কিভাবে ডিফল্ট উল্লেখযোগ্য গতি সেন্সরের একটি উদাহরণ পেতে হয় এবং কীভাবে একটি ইভেন্ট শ্রোতা নিবন্ধন করতে হয়:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val mSensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_SIGNIFICANT_MOTION)
val triggerEventListener = object : TriggerEventListener() {
    override fun onTrigger(event: TriggerEvent?) {
        // Do work
    }
}
mSensor?.also { sensor ->
    sensorManager.requestTriggerSensor(triggerEventListener, sensor)
}

private SensorManager sensorManager;
private Sensor sensor;
private TriggerEventListener triggerEventListener;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_SIGNIFICANT_MOTION);

triggerEventListener = new TriggerEventListener() {
    @Override
    public void onTrigger(TriggerEvent event) {
        // Do work
    }
};

sensorManager.requestTriggerSensor(triggerEventListener, mSensor);

আরও তথ্যের জন্য, TriggerEventListener দেখুন।

স্টেপ কাউন্টার সেন্সর ব্যবহার করুন

স্টেপ কাউন্টার সেন্সরটি সেন্সরটি সক্রিয় করার সময় শেষ রিবুট করার পর থেকে ব্যবহারকারীর নেওয়া পদক্ষেপের সংখ্যা প্রদান করে। স্টেপ কাউন্টারটিতে লেটেন্সি বেশি (১০ সেকেন্ড পর্যন্ত) কিন্তু স্টেপ ডিটেক্টর সেন্সরের তুলনায় বেশি নির্ভুলতা রয়েছে।

দ্রষ্টব্য: আপনার অ্যাপটি Android 10 (API লেভেল 29) বা তার বেশি চলমান ডিভাইসগুলিতে এই সেন্সরটি ব্যবহার করতে চাইলে আপনাকে ACTIVITY_RECOGNITION অনুমতি ঘোষণা করতে হবে।

নিম্নলিখিত কোডটি আপনাকে দেখায় কিভাবে ডিফল্ট স্টেপ কাউন্টার সেন্সরের একটি উদাহরণ পেতে হয়:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);

আপনার অ্যাপটি চালানো ডিভাইসগুলিতে ব্যাটারি সংরক্ষণ করার জন্য, আপনার JobScheduler ক্লাস ব্যবহার করে একটি নির্দিষ্ট ব্যবধানে স্টেপ কাউন্টার সেন্সর থেকে বর্তমান মান পুনরুদ্ধার করা উচিত। যদিও বিভিন্ন ধরণের অ্যাপের জন্য বিভিন্ন সেন্সর-পড়ার ব্যবধানের প্রয়োজন হয়, আপনার এই ব্যবধানটি যতটা সম্ভব দীর্ঘ করা উচিত যদি না আপনার অ্যাপটির সেন্সর থেকে রিয়েল-টাইম ডেটার প্রয়োজন হয়।

স্টেপ ডিটেক্টর সেন্সর ব্যবহার করুন

ব্যবহারকারী যখনই কোনও পদক্ষেপ নেয়, তখন স্টেপ ডিটেক্টর সেন্সরটি একটি ইভেন্ট ট্রিগার করে। ল্যাটেন্সি ২ সেকেন্ডের কম হবে বলে আশা করা হচ্ছে।

দ্রষ্টব্য: আপনার অ্যাপটি Android 10 (API লেভেল 29) বা তার বেশি চলমান ডিভাইসগুলিতে এই সেন্সরটি ব্যবহার করতে চাইলে আপনাকে ACTIVITY_RECOGNITION অনুমতি ঘোষণা করতে হবে।

নিম্নলিখিত কোডটি আপনাকে ডিফল্ট স্টেপ ডিটেক্টর সেন্সরের একটি উদাহরণ কীভাবে পেতে হয় তা দেখায়:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR);

কাঁচা তথ্য নিয়ে কাজ করুন

নিম্নলিখিত সেন্সরগুলি আপনার অ্যাপকে ডিভাইসে প্রয়োগ করা রৈখিক এবং ঘূর্ণন বল সম্পর্কে কাঁচা তথ্য সরবরাহ করে। এই সেন্সরগুলির মানগুলি কার্যকরভাবে ব্যবহার করার জন্য, আপনাকে পরিবেশ থেকে উপাদানগুলি ফিল্টার করতে হবে, যেমন মাধ্যাকর্ষণ। শব্দ কমাতে আপনাকে মানগুলির প্রবণতায় একটি স্মুথিং অ্যালগরিদম প্রয়োগ করতে হতে পারে।

অ্যাক্সিলোমিটার ব্যবহার করুন

একটি ত্বরণ সেন্সর ডিভাইসে প্রয়োগ করা ত্বরণ পরিমাপ করে, যার মধ্যে মাধ্যাকর্ষণ বলও অন্তর্ভুক্ত। নিম্নলিখিত কোডটি আপনাকে ডিফল্ট ত্বরণ সেন্সরের একটি উদাহরণ কীভাবে পেতে হয় তা দেখায়:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)

private SensorManager sensorManager;
private Sensor sensor;
  ...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

দ্রষ্টব্য: যদি আপনার অ্যাপটি Android 12 (API লেভেল 31) বা তার উচ্চতর ভার্সনকে টার্গেট করে, তাহলে এই সেন্সরটি রেট-লিমিটেড ।

ধারণাগতভাবে, একটি ত্বরণ সেন্সর নিম্নলিখিত সম্পর্ক ব্যবহার করে সেন্সরে প্রয়োগ করা বল (F _s ) পরিমাপ করে একটি ডিভাইসে (A _d ) প্রয়োগ করা ত্বরণ নির্ধারণ করে:

তবে, মাধ্যাকর্ষণ বল সর্বদা নিম্নলিখিত সম্পর্ক অনুসারে পরিমাপিত ত্বরণকে প্রভাবিত করে:

এই কারণে, যখন ডিভাইসটি টেবিলের উপর বসে থাকে (এবং ত্বরণ না করে), তখন অ্যাক্সিলোমিটারটি g = 9.81 m/s ² এর মাত্রা রিড করে। একইভাবে, যখন ডিভাইসটি মুক্ত পতনের মধ্যে থাকে এবং তাই 9.81 m/s ² এ দ্রুত ভূমির দিকে ত্বরণ করে, তখন এর অ্যাক্সিলোমিটার g = 0 m/s ² এর মাত্রা রিড করে। অতএব, ডিভাইসের প্রকৃত ত্বরণ পরিমাপ করার জন্য, অ্যাক্সিলোমিটার ডেটা থেকে মাধ্যাকর্ষণ বলের অবদান বাদ দিতে হবে। এটি একটি উচ্চ-পাস ফিল্টার প্রয়োগ করে অর্জন করা যেতে পারে। বিপরীতভাবে, মাধ্যাকর্ষণ বল বিচ্ছিন্ন করার জন্য একটি নিম্ন-পাস ফিল্টার ব্যবহার করা যেতে পারে। নিম্নলিখিত উদাহরণটি দেখায় যে আপনি এটি কীভাবে করতে পারেন:

override fun onSensorChanged(event: SensorEvent) {
    // In this example, alpha is calculated as t / (t + dT),
    // where t is the low-pass filter's time-constant and
    // dT is the event delivery rate.

    val alpha: Float = 0.8f

    // Isolate the force of gravity with the low-pass filter.
    gravity[0] = alpha * gravity[0] + (1 - alpha) * event.values[0]
    gravity[1] = alpha * gravity[1] + (1 - alpha) * event.values[1]
    gravity[2] = alpha * gravity[2] + (1 - alpha) * event.values[2]

    // Remove the gravity contribution with the high-pass filter.
    linear_acceleration[0] = event.values[0] - gravity[0]
    linear_acceleration[1] = event.values[1] - gravity[1]
    linear_acceleration[2] = event.values[2] - gravity[2]
}

public void onSensorChanged(SensorEvent event){
    // In this example, alpha is calculated as t / (t + dT),
    // where t is the low-pass filter's time-constant and
    // dT is the event delivery rate.

    final float alpha = 0.8;

    // Isolate the force of gravity with the low-pass filter.
    gravity[0] = alpha * gravity[0] + (1 - alpha) * event.values[0];
    gravity[1] = alpha * gravity[1] + (1 - alpha) * event.values[1];
    gravity[2] = alpha * gravity[2] + (1 - alpha) * event.values[2];

    // Remove the gravity contribution with the high-pass filter.
    linear_acceleration[0] = event.values[0] - gravity[0];
    linear_acceleration[1] = event.values[1] - gravity[1];
    linear_acceleration[2] = event.values[2] - gravity[2];
}

দ্রষ্টব্য: সেন্সর ডেটা ফিল্টার করার জন্য আপনি অনেকগুলি ভিন্ন কৌশল ব্যবহার করতে পারেন। উপরের কোড নমুনাটি একটি সাধারণ ফিল্টার ধ্রুবক (আলফা) ব্যবহার করে একটি লো-পাস ফিল্টার তৈরি করে। এই ফিল্টার ধ্রুবকটি একটি সময় ধ্রুবক (t) থেকে উদ্ভূত, যা ফিল্টারটি সেন্সর ইভেন্টগুলিতে যে বিলম্ব যোগ করে এবং সেন্সরের ইভেন্ট ডেলিভারি রেট (dt) এর একটি মোটামুটি উপস্থাপনা। প্রদর্শনের উদ্দেশ্যে কোড নমুনাটি 0.8 এর একটি আলফা মান ব্যবহার করে। আপনি যদি এই ফিল্টারিং পদ্ধতিটি ব্যবহার করেন তবে আপনাকে একটি ভিন্ন আলফা মান বেছে নিতে হতে পারে।

অ্যাক্সিলোমিটারগুলি স্ট্যান্ডার্ড সেন্সর স্থানাঙ্ক সিস্টেম ব্যবহার করে। বাস্তবে, এর অর্থ হল যখন কোনও ডিভাইস তার প্রাকৃতিক অভিমুখে টেবিলের উপর সমতলভাবে শুয়ে থাকে তখন নিম্নলিখিত শর্তগুলি প্রযোজ্য হয়:

• যদি আপনি ডিভাইসটিকে বাম দিকে ঠেলে দেন (যাতে এটি ডানদিকে চলে যায়), তাহলে x ত্বরণের মান ধনাত্মক হবে।
• যদি আপনি ডিভাইসটিকে নীচে ঠেলে দেন (যাতে এটি আপনার থেকে দূরে সরে যায়), তাহলে y ত্বরণের মান ধনাত্মক হবে।
• যদি আপনি A m/s ² ত্বরণে ডিভাইসটিকে আকাশের দিকে ঠেলে দেন, তাহলে z ত্বরণের মান A + 9.81 এর সমান হবে, যা ডিভাইসের ত্বরণ (+A m/s ² ) এর সাথে মাধ্যাকর্ষণ বল (-9.81 m/s ² ) বিয়োগ করে।
• স্থির ডিভাইসটির ত্বরণ মান +9.81 হবে, যা ডিভাইসের ত্বরণের সাথে মিলে যায় (0 m/s ² বিয়োগ মাধ্যাকর্ষণ বল, যা -9.81 m/s ² )।

সাধারণভাবে, ডিভাইসের গতিবিধি পর্যবেক্ষণ করার জন্য অ্যাক্সিলোমিটার ব্যবহার করা ভালো একটি সেন্সর। প্রায় প্রতিটি অ্যান্ড্রয়েড-চালিত হ্যান্ডসেট এবং ট্যাবলেটে একটি অ্যাক্সিলোমিটার থাকে এবং এটি অন্যান্য মোশন সেন্সরের তুলনায় প্রায় ১০ গুণ কম শক্তি ব্যবহার করে। একটি অসুবিধা হল, মহাকর্ষীয় বল দূর করতে এবং শব্দ কমাতে আপনাকে লো-পাস এবং হাই-পাস ফিল্টার প্রয়োগ করতে হতে পারে।

জাইরোস্কোপ ব্যবহার করুন

জাইরোস্কোপ একটি ডিভাইসের x, y, এবং z অক্ষের চারপাশে rad/s-এ ঘূর্ণনের হার পরিমাপ করে। নিম্নলিখিত কোডটি আপনাকে ডিফল্ট জাইরোস্কোপের একটি উদাহরণ কীভাবে পেতে হয় তা দেখায়:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);

দ্রষ্টব্য: যদি আপনার অ্যাপটি Android 12 (API লেভেল 31) বা তার উচ্চতর ভার্সনকে টার্গেট করে, তাহলে এই সেন্সরটি রেট-লিমিটেড ।

সেন্সরের স্থানাঙ্ক ব্যবস্থাটি ত্বরণ সেন্সরের জন্য ব্যবহৃত সিস্টেমের মতোই। ঘূর্ণন ঘড়ির কাঁটার বিপরীত দিকে ধনাত্মক হয়; অর্থাৎ, উৎপত্তিস্থলে অবস্থিত একটি ডিভাইসে x, y বা z অক্ষের কোনও ধনাত্মক অবস্থান থেকে একজন পর্যবেক্ষক যদি ডিভাইসটি ঘড়ির কাঁটার বিপরীতে ঘুরছে বলে মনে হয় তবে ধনাত্মক ঘূর্ণন রিপোর্ট করবে। এটি ধনাত্মক ঘূর্ণনের আদর্শ গাণিতিক সংজ্ঞা এবং এটি ওরিয়েন্টেশন সেন্সর দ্বারা ব্যবহৃত রোলের সংজ্ঞার মতো নয়।

সাধারণত, জাইরোস্কোপের আউটপুট সময়ের সাথে সাথে একত্রিত করা হয় যাতে সময় ধাপে কোণের পরিবর্তন বর্ণনা করে একটি ঘূর্ণন গণনা করা হয়। উদাহরণস্বরূপ:

// Create a constant to convert nanoseconds to seconds.
private val NS2S = 1.0f / 1000000000.0f
private val deltaRotationVector = FloatArray(4) { 0f }
private var timestamp: Float = 0f

override fun onSensorChanged(event: SensorEvent?) {
    // This timestep's delta rotation to be multiplied by the current rotation
    // after computing it from the gyro sample data.
    if (timestamp != 0f && event != null) {
        val dT = (event.timestamp - timestamp) * NS2S
        // Axis of the rotation sample, not normalized yet.
        var axisX: Float = event.values[0]
        var axisY: Float = event.values[1]
        var axisZ: Float = event.values[2]

        // Calculate the angular speed of the sample
        val omegaMagnitude: Float = sqrt(axisX * axisX + axisY * axisY + axisZ * axisZ)

        // Normalize the rotation vector if it's big enough to get the axis
        // (that is, EPSILON should represent your maximum allowable margin of error)
        if (omegaMagnitude > EPSILON) {
            axisX /= omegaMagnitude
            axisY /= omegaMagnitude
            axisZ /= omegaMagnitude
        }

        // Integrate around this axis with the angular speed by the timestep
        // in order to get a delta rotation from this sample over the timestep
        // We will convert this axis-angle representation of the delta rotation
        // into a quaternion before turning it into the rotation matrix.
        val thetaOverTwo: Float = omegaMagnitude * dT / 2.0f
        val sinThetaOverTwo: Float = sin(thetaOverTwo)
        val cosThetaOverTwo: Float = cos(thetaOverTwo)
        deltaRotationVector[0] = sinThetaOverTwo * axisX
        deltaRotationVector[1] = sinThetaOverTwo * axisY
        deltaRotationVector[2] = sinThetaOverTwo * axisZ
        deltaRotationVector[3] = cosThetaOverTwo
    }
    timestamp = event?.timestamp?.toFloat() ?: 0f
    val deltaRotationMatrix = FloatArray(9) { 0f }
    SensorManager.getRotationMatrixFromVector(deltaRotationMatrix, deltaRotationVector);
    // User code should concatenate the delta rotation we computed with the current rotation
    // in order to get the updated rotation.
    // rotationCurrent = rotationCurrent * deltaRotationMatrix;
}

// Create a constant to convert nanoseconds to seconds.
private static final float NS2S = 1.0f / 1000000000.0f;
private final float[] deltaRotationVector = new float[4]();
private float timestamp;

public void onSensorChanged(SensorEvent event) {
    // This timestep's delta rotation to be multiplied by the current rotation
    // after computing it from the gyro sample data.
    if (timestamp != 0) {
      final float dT = (event.timestamp - timestamp) * NS2S;
      // Axis of the rotation sample, not normalized yet.
      float axisX = event.values[0];
      float axisY = event.values[1];
      float axisZ = event.values[2];

      // Calculate the angular speed of the sample
      float omegaMagnitude = sqrt(axisX*axisX + axisY*axisY + axisZ*axisZ);

      // Normalize the rotation vector if it's big enough to get the axis
      // (that is, EPSILON should represent your maximum allowable margin of error)
      if (omegaMagnitude > EPSILON) {
        axisX /= omegaMagnitude;
        axisY /= omegaMagnitude;
        axisZ /= omegaMagnitude;
      }

      // Integrate around this axis with the angular speed by the timestep
      // in order to get a delta rotation from this sample over the timestep
      // We will convert this axis-angle representation of the delta rotation
      // into a quaternion before turning it into the rotation matrix.
      float thetaOverTwo = omegaMagnitude * dT / 2.0f;
      float sinThetaOverTwo = sin(thetaOverTwo);
      float cosThetaOverTwo = cos(thetaOverTwo);
      deltaRotationVector[0] = sinThetaOverTwo * axisX;
      deltaRotationVector[1] = sinThetaOverTwo * axisY;
      deltaRotationVector[2] = sinThetaOverTwo * axisZ;
      deltaRotationVector[3] = cosThetaOverTwo;
    }
    timestamp = event.timestamp;
    float[] deltaRotationMatrix = new float[9];
    SensorManager.getRotationMatrixFromVector(deltaRotationMatrix, deltaRotationVector);
    // User code should concatenate the delta rotation we computed with the current rotation
    // in order to get the updated rotation.
    // rotationCurrent = rotationCurrent * deltaRotationMatrix;
}

স্ট্যান্ডার্ড জাইরোস্কোপগুলি শব্দ এবং প্রবাহের (পক্ষপাত) জন্য কোনও ফিল্টারিং বা সংশোধন ছাড়াই কাঁচা ঘূর্ণন ডেটা সরবরাহ করে। বাস্তবে, জাইরোস্কোপের শব্দ এবং প্রবাহ এমন ত্রুটিগুলি তৈরি করবে যার জন্য ক্ষতিপূরণ প্রয়োজন। আপনি সাধারণত অন্যান্য সেন্সর, যেমন মাধ্যাকর্ষণ সেন্সর বা অ্যাক্সিলোমিটার পর্যবেক্ষণ করে প্রবাহ (পক্ষপাত) এবং শব্দ নির্ধারণ করেন।

আনক্যালিব্রেটেড জাইরোস্কোপ ব্যবহার করুন

আনক্যালিব্রেটেড জাইরোস্কোপ জাইরোস্কোপের মতোই, তবে ঘূর্ণনের হারের জন্য কোনও জাইরো-ড্রিফ্ট ক্ষতিপূরণ প্রয়োগ করা হয় না। কারখানার ক্রমাঙ্কন এবং তাপমাত্রা ক্ষতিপূরণ এখনও ঘূর্ণনের হারের জন্য প্রয়োগ করা হয়। আনক্যালিব্রেটেড জাইরোস্কোপ পোস্ট-প্রসেসিং এবং ওরিয়েন্টেশন ডেটা মেল্ডিংয়ের জন্য কার্যকর। সাধারণভাবে, gyroscope_event.values[0] uncalibrated_gyroscope_event.values[0] - uncalibrated_gyroscope_event.values[3] এর কাছাকাছি হবে। অর্থাৎ,

calibrated_x ~= uncalibrated_x - bias_estimate_x

দ্রষ্টব্য: আনক্যালিব্রেটেড সেন্সরগুলি আরও কাঁচা ফলাফল প্রদান করে এবং কিছু পক্ষপাত অন্তর্ভুক্ত করতে পারে, তবে তাদের পরিমাপে ক্যালিব্রেশনের মাধ্যমে প্রয়োগ করা সংশোধন থেকে কম লাফ থাকে। কিছু অ্যাপ্লিকেশন এই আনক্যালিব্রেটেড ফলাফলগুলিকে মসৃণ এবং আরও নির্ভরযোগ্য হিসাবে পছন্দ করতে পারে। উদাহরণস্বরূপ, যদি কোনও অ্যাপ্লিকেশন নিজস্ব সেন্সর ফিউশন পরিচালনা করার চেষ্টা করে, তাহলে ক্যালিব্রেশন প্রবর্তন আসলে ফলাফলগুলিকে বিকৃত করতে পারে।

ঘূর্ণনের হার ছাড়াও, আনক্যালিব্রেটেড জাইরোস্কোপ প্রতিটি অক্ষের চারপাশে আনুমানিক ড্রিফটও প্রদান করে। নিম্নলিখিত কোডটি আপনাকে ডিফল্ট আনক্যালিব্রেটেড জাইরোস্কোপের একটি উদাহরণ কীভাবে পেতে হয় তা দেখায়:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE_UNCALIBRATED)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE_UNCALIBRATED);

অতিরিক্ত কোড নমুনা

BatchStepSensor নমুনাটি এই পৃষ্ঠায় বর্ণিত API গুলির ব্যবহার আরও প্রদর্শন করে।

তোমারও পড়া উচিত

• সেন্সর
• সেন্সর ওভারভিউ
• অবস্থান সেন্সর
• পরিবেশ সেন্সর