🎸 👨‍🎨 🐪 एक Arduino- आधारित मशीन जो ब्लूटूथ के माध्यम से एक एंड्रॉइड डिवाइस द्वारा नियंत्रित होती है

पहले भाग के बारे में

पहले भाग में, मैंने निर्माण के भौतिक भाग और कोड के एक छोटे टुकड़े का वर्णन किया। अब सॉफ्टवेयर घटक पर विचार करें - एक Android एप्लिकेशन और एक Arduino स्केच।

सबसे पहले, मैं प्रत्येक पल का विस्तृत विवरण दूंगा, और अंत में मैं परिणाम के पूरे प्रोजेक्ट + वीडियो से लिंक छोड़ दूंगा, जिससे आपको ~~निराश~~ होना चाहिए।

एंड्रॉइड ऐप

एंड्रॉइड के लिए कार्यक्रम को दो भागों में विभाजित किया गया है: पहला डिवाइस को ब्लूटूथ के माध्यम से कनेक्ट कर रहा है, दूसरा नियंत्रण जॉयस्टिक है।

मैं आपको चेतावनी देता हूं - आवेदन के डिजाइन को बिल्कुल भी काम नहीं किया गया था और एक गड़गड़ाहट पर किया गया था, अगर केवल यह काम करता है। अनुकूलन क्षमता और UX प्रतीक्षा नहीं करते हैं, लेकिन स्क्रीन से बाहर रेंगना नहीं चाहिए।

मेकअप

गतिविधि शुरू करना लेआउट, तत्वों पर निर्भर करता है: उपकरणों की सूची के लिए बटन और लेआउट। बटन सक्रिय ब्लूटूथ के साथ उपकरणों को खोजने की प्रक्रिया शुरू करता है। ListView पाया उपकरणों को प्रदर्शित करता है।

<?xml version="1.0" encoding="utf-8"?> <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" > <Button android:layout_width="wrap_content" android:layout_height="60dp" android:layout_alignParentStart="true" android:layout_alignParentTop="true" android:layout_marginStart="40dp" android:layout_marginTop="50dp" android:text="@string/start_search" android:id="@+id/button_start_find" /> <Button android:layout_width="wrap_content" android:layout_height="60dp" android:layout_marginEnd="16dp" android:layout_marginBottom="16dp" android:id="@+id/button_start_control" android:text="@string/start_control" android:layout_alignParentBottom="true" android:layout_alignParentEnd="true"/> <ListView android:id="@+id/list_device" android:layout_width="300dp" android:layout_height="200dp" android:layout_marginEnd="10dp" android:layout_marginTop="10dp" android:layout_alignParentEnd="true" android:layout_alignParentTop="true" /> </RelativeLayout>

नियंत्रण स्क्रीन एक लेआउट पर आधारित है, जिसमें केवल एक बटन है, जो भविष्य में जॉयस्टिक बन जाएगा। एक बटन पृष्ठभूमि विशेषता के माध्यम से बटन से जुड़ा होता है, जिससे यह गोल हो जाता है।
TextView का उपयोग अंतिम संस्करण में नहीं किया गया है, लेकिन यह मूल रूप से डिबगिंग के लिए जोड़ा गया था: ब्लूटूथ के माध्यम से भेजे गए नंबर प्रदर्शित किए गए थे। प्रारंभिक चरण में, मैं आपको उपयोग करने की सलाह देता हूं। लेकिन तब संख्याओं की गणना एक अलग स्ट्रीम में की जाने लगेगी जहाँ से TextView को एक्सेस करना मुश्किल है।

 <?xml version="1.0" encoding="utf-8"?> <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent"> <Button android:layout_width="200dp" android:layout_height="200dp" android:layout_alignParentStart="true" android:layout_alignParentBottom="true" android:layout_marginBottom="25dp" android:layout_marginStart="15dp" android:id="@+id/button_drive_control" android:background="@drawable/button_control_circle" /> <TextView android:layout_height="wrap_content" android:layout_width="wrap_content" android:layout_alignParentEnd="true" android:layout_alignParentTop="true" android:minWidth="70dp" android:id="@+id/view_result_touch" android:layout_marginEnd="90dp" /> </RelativeLayout>

Button_control_circle.xml फ़ाइल (शैली), इसे ड्रा करने योग्य फ़ोल्डर में रखा जाना चाहिए:

 <?xml version="1.0" encoding="utf-8"?> <shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle"> <solid android:color="#00F" /> <corners android:bottomRightRadius="100dp" android:bottomLeftRadius="100dp" android:topRightRadius="100dp" android:topLeftRadius="100dp"/> </shape>

आपको item_device.xml फ़ाइल बनाने की भी आवश्यकता है, यह प्रत्येक सूची आइटम के लिए आवश्यक है:

 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent"> <TextView android:layout_width="150dp" android:layout_height="40dp" android:id="@+id/item_device_textView"/> </LinearLayout>

घोषणापत्र

बस के मामले में, मैं पूर्ण प्रकट कोड दे दूंगा। आपको उपयोग-अनुमति के माध्यम से ब्लूटूथ तक पूर्ण पहुंच प्राप्त करने की आवश्यकता है और गतिविधि टैग के माध्यम से दूसरी गतिविधि को इंगित करने के लिए मत भूलना।

 <?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.bluetoothapp"> <uses-permission android:name="android.permission.BLUETOOTH" /> <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" /> <application android:allowBackup="true" android:icon="@mipmap/ic_launcher" android:label="@string/app_name" android:roundIcon="@mipmap/ic_launcher_round" android:supportsRtl="true" android:theme="@style/AppTheme"> <activity android:name="com.arproject.bluetoothworkapp.MainActivity" android:theme="@style/Theme.AppCompat.NoActionBar" android:screenOrientation="landscape"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> <activity android:name="com.arproject.bluetoothworkapp.ActivityControl" android:theme="@style/Theme.AppCompat.NoActionBar" android:screenOrientation="landscape"/> </application> </manifest>

मुख्य गतिविधि, Arduino और Android की जोड़ी

हम AppCompatActivity से वर्ग प्राप्त करते हैं और चर घोषित करते हैं:

 public class MainActivity extends AppCompatActivity { private BluetoothAdapter bluetoothAdapter; private ListView listView; private ArrayList<String> pairedDeviceArrayList; private ArrayAdapter<String> pairedDeviceAdapter; public static BluetoothSocket clientSocket; private Button buttonStartControl; }

मैं ऑनक्रिएट () विधि लाइन का वर्णन लाइन से करूंगा:

 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); //  //    setContentView(R.layout.activity_main); //    Button buttonStartFind = (Button) findViewById(R.id.button_start_find); // layout,       listView = (ListView) findViewById(R.id.list_device); //    buttonStartFind.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { //   ( ) if(permissionGranted()) { //    bluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); if(bluetoothEnabled()) { //   ( ) findArduino(); //   ( ) } } } }); //      buttonStartControl = (Button) findViewById(R.id.button_start_control); buttonStartControl.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { //     Intent intent = new Intent(); //    intent.setClass(getApplicationContext(), ActivityControl.class); //  ,    startActivity(intent); } }); }

नीचे दिए गए फ़ंक्शन यह जांचते हैं कि क्या ब्लूटूथ का उपयोग करने की अनुमति प्राप्त की गई है (उपयोगकर्ता की अनुमति के बिना हम डेटा स्थानांतरित नहीं कर पाएंगे) और क्या ब्लूटूथ चालू है:

 private boolean permissionGranted() { //   ,  true if (ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.BLUETOOTH) == PermissionChecker.PERMISSION_GRANTED && ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.BLUETOOTH_ADMIN) == PermissionChecker.PERMISSION_GRANTED) { return true; } else { ActivityCompat.requestPermissions(this, new String[] {Manifest.permission.BLUETOOTH, Manifest.permission.BLUETOOTH_ADMIN}, 0); return false; } } private boolean bluetoothEnabled() { //  ,  true,  ,      if(bluetoothAdapter.isEnabled()) { return true; } else { Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE); startActivityForResult(enableBtIntent, 0); return false; } }

यदि सभी जांचें पास हो जाती हैं, तो डिवाइस खोज शुरू होती है। यदि किसी एक शर्त को पूरा नहीं किया जाता है, तो एक अधिसूचना प्रदर्शित होगी, जिसमें कहा जाएगा, "allow \ enable?", और यह तब तक दोहराया जाएगा जब तक कि चेक पास नहीं हो जाता।

डिवाइस खोज को तीन भागों में विभाजित किया गया है: सूची तैयार करना, पाए गए उपकरणों की सूची में जोड़ना, चयनित डिवाइस के साथ संबंध स्थापित करना।

 private void findArduino() { //    Set<BluetoothDevice> pairedDevice = bluetoothAdapter.getBondedDevices(); if (pairedDevice.size() > 0) { //     pairedDeviceArrayList = new ArrayList<>(); //  for(BluetoothDevice device: pairedDevice) { //      //: " /" pairedDeviceArrayList.add(device.getAddress() + "/" + device.getName()); } } //  ,    item_device.xml pairedDeviceAdapter = new ArrayAdapter<String>(getApplicationContext(), R.layout.item_device, R.id.item_device_textView, pairedDeviceArrayList); listView.setAdapter(pairedDeviceAdapter); //      listView.setOnItemClickListener(new AdapterView.OnItemClickListener() { @Override public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) { //    String itemMAC = listView.getItemAtPosition(i).toString().split("/", 2)[0]; //      BluetoothDevice connectDevice = bluetoothAdapter.getRemoteDevice(itemMAC); try { // socket - ,      Method m = connectDevice.getClass().getMethod( "createRfcommSocket", new Class[]{int.class}); clientSocket = (BluetoothSocket) m.invoke(connectDevice, 1); clientSocket.connect(); if(clientSocket.isConnected()) { //  ,   bluetoothAdapter.cancelDiscovery(); } } catch(Exception e) { e.getStackTrace(); } } }); }

जब एक ब्लूटूथ मॉड्यूल Arduino (इस पर बाद में) में लटका हुआ पाया जाता है, तो यह सूची में दिखाई देगा। उस पर क्लिक करके, आप एक सॉकेट बनाना शुरू करेंगे (आपको एक क्लिक के बाद 3-5 सेकंड इंतजार करना पड़ सकता है या फिर से क्लिक करना होगा)। आप समझेंगे कि कनेक्शन ब्लूटूथ मॉड्यूल पर एल ई डी द्वारा स्थापित किया गया है: एक कनेक्शन के बिना, वे जल्दी से झपकी लेते हैं, अगर कोई कनेक्शन होता है, तो आवृत्ति बिल्कुल कम हो जाती है।

प्रबंधित करें और कमांड भेजें

कनेक्शन स्थापित होने के बाद, आप दूसरी गतिविधि के लिए आगे बढ़ सकते हैं - एक्टिविटीकंट्रोल। स्क्रीन पर केवल एक नीला सर्कल होगा - जॉयस्टिक। यह सामान्य बटन से बनाया गया है, मार्कअप ऊपर दिया गया है।

 public class ActivityControl extends AppCompatActivity { //,   private Button buttonDriveControl; private float BDCheight, BDCwidth; private float centerBDCheight, centerBDCwidth; private String angle = "90"; //0, 30, 60, 90, 120, 150, 180 private ConnectedThread threadCommand; private long lastTimeSendCommand = System.currentTimeMillis(); }

ऑनक्रिएट () विधि में, सभी मुख्य क्रिया होती है:

 //        performClick() //    @SuppressLint("ClickableViewAccessibility") @Override protected void onCreate(Bundle savedInstanceState) { //  super.onCreate(savedInstanceState); // ,    setContentView(R.layout.activity_control); //  buttonDriveControl = (Button) findViewById(R.id.button_drive_control); //    final ViewTreeObserver vto = buttonDriveControl.getViewTreeObserver(); vto.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() { @Override public void onGlobalLayout() { //      (!) BDCheight = buttonDriveControl.getHeight(); BDCwidth = buttonDriveControl.getWidth(); //    (!) centerBDCheight = BDCheight/2; centerBDCwidth = BDCwidth/2; // GlobalListener,     buttonDriveControl.getViewTreeObserver().removeOnGlobalLayoutListener(this); } }); // ,     //    buttonDriveControl.setOnTouchListener(new ControlDriveInputListener()); //  ,      //    ,     //    threadCommand = new ConnectedThread(MainActivity.clientSocket); threadCommand.run(); }

ध्यान दें (!) - हमें पता चलेगा कि बटन कितने पिक्सेल पर है। इसके लिए धन्यवाद, हमें अनुकूलनशीलता मिलती है: बटन का आकार स्क्रीन रिज़ॉल्यूशन पर निर्भर करेगा, लेकिन बाकी कोड आसानी से इसके लिए अनुकूल हो जाएंगे, क्योंकि हम आकारों को पहले से ठीक नहीं करते हैं। बाद में, हम एप्लिकेशन को यह पता लगाने के लिए सिखाएंगे कि स्पर्श कहां था, और फिर इसे उन मानों में अनुवाद करें, जो 0 से 255 तक अर्दुंकी के लिए समझ में आते हैं (आखिरकार, केंद्र से स्पर्श 456 पिक्सेल हो सकता है, और एमके उस नंबर के साथ काम नहीं करेगा)।

निम्नलिखित ControlDriveInputListener () कोड है, यह वर्ग onCreate () पद्धति के बाद, गतिविधि के वर्ग में ही स्थित है। एक्टिविटीकंट्रोल फाइल में होने के कारण, ControlDriveInputListener वर्ग एक बच्चा बन जाता है, जिसका अर्थ है कि इसमें मुख्य वर्ग के सभी चर हैं।

क्लिक किए जाने वाले कार्यों पर ध्यान न दें। अब हम स्पर्श को पकड़ने की प्रक्रिया में रुचि रखते हैं: किस बिंदु पर व्यक्ति अपनी उंगली डालता है और इसके बारे में हमें क्या डेटा मिलेगा।

कृपया ध्यान दें कि मैं java.util.Timer वर्ग का उपयोग करता हूं: यह आपको एक नया थ्रेड बनाने की अनुमति देता है जिसमें देरी हो सकती है और प्रत्येक nth संख्या में सेकंड के बाद अनंत बार दोहराया जाएगा। इसका उपयोग निम्न स्थिति के लिए किया जाना चाहिए: व्यक्ति ने एक उंगली डाल दी, ACTION_DOWN विधि ने काम किया, जानकारी arduino में चली गई, और उसके बाद उस व्यक्ति ने उंगली को स्थानांतरित नहीं करने का फैसला किया, क्योंकि गति उसे सूट करती है। दूसरी बार, ACTION_DOWN विधि काम नहीं करेगी, क्योंकि पहले आपको ACTION_UP (स्क्रीन से अपनी उंगली उठाने के लिए) को कॉल करने की आवश्यकता है।

खैर, हम टाइमर () क्लास लूप शुरू करते हैं और हर 10 मिलीसेकंड पर एक ही डेटा भेजना शुरू करते हैं। जब उंगली को स्थानांतरित किया जाता है (ACTION_MOVE काम करेगा) या उठाया (ACTION_UP), टाइमर चक्र को मार दिया जाना चाहिए ताकि पुराने प्रेस से डेटा फिर से भेजा जाना शुरू न हो।

 public class ControlDriveInputListener implements View.OnTouchListener { private Timer timer; @Override public boolean onTouch(View view, MotionEvent motionEvent) { //     //      (!) final float x = motionEvent.getX(); final float y = motionEvent.getY(); //,     switch(motionEvent.getAction()) { //  //  ,      case MotionEvent.ACTION_DOWN: //  timer = new Timer(); //  // :    0, //  10  timer.schedule(new TimerTask() { @Override public void run() { //   calculateAndSendCommand(x, y); } }, 0, 10); break; //    (  ACTION_DOWN) case MotionEvent.ACTION_MOVE: // (!) //     Timer(),   if(timer != null) { timer.cancel(); timer = null; } //   timer = new Timer(); //     ,    ACTION_UP timer.schedule(new TimerTask() { @Override public void run() { calculateAndSendCommand(x, y); } }, 0, 10); break; //     case MotionEvent.ACTION_UP: //  if(timer != null) { timer.cancel(); timer = null; } break; } return false; } }

फिर से ध्यान दें: एक्स और वाई काउंट ऑनटू () विधि व्यू के ऊपरी बाएं कोने से जाती है। हमारे मामले में, बिंदु (0; 0) यहां बटन पर स्थित है:

अब जब हमने सीखा है कि बटन पर उंगली का वर्तमान स्थान कैसे प्राप्त करें, तो हम कार्य मानों के लिए पिक्सेल (क्योंकि x और y पिक्सेल में बस दूरी हैं) का पता लगाने के लिए पता करेंगे। ऐसा करने के लिए, मैं CalculAndSendCommand (x, y) विधि का उपयोग करता हूं, जिसे ControlDriveInputListener वर्ग में रखा जाना चाहिए। आपको कुछ सहायक विधियों की भी आवश्यकता होगी, हम उन्हें गणना के बाद उसी कक्षा में लिखते हैं AndSendCommand (x, y)।

 private void calculateAndSendCommand(float x, float y) { //    //   // - 1, 2, 3, 4 // ,   ,      // ,     ,     int quarter = identifyQuarter(x, y); //       // y,        int speed = speedCalculation(centerBDCheight - y); //   //   ,    7   String angle = angleCalculation(x); //     ,     //      ,      /*String resultDown = "x: "+ Float.toString(x) + " y: " + Float.toString(y) + " qr: " + Integer.toString(quarter) + "\n" + "height: " + centerBDCheight + " width: " + centerBDCwidth + "\n" + "speed: " + Integer.toString(speed) + " angle: " + angle; */ //viewResultTouch.setText(resultDown); //  ,    //      (  ),   100  if((System.currentTimeMillis() - lastTimeSendCommand) > 100) { //   threadCommand.sendCommand(Integer.toString(speed), angle); //     lastTimeSendCommand = System.currentTimeMillis(); } } private int identifyQuarter(float x, float y) { //,      //  if(x > centerBDCwidth && y > centerBDCheight) { return 4; } else if (x < centerBDCwidth && y >centerBDCheight) { return 3; } else if (x < centerBDCwidth && y < centerBDCheight) { return 2; } else if (x > centerBDCwidth && y < centerBDCheight) { return 1; } return 0; } private int speedCalculation(float deviation) { //  //      float coefficient = 255/(BDCheight/2); //    //   int speed = Math.round(deviation * coefficient); //    70,    // ,    ,    if(speed > 0 && speed < 70) speed = 0; if(speed < 0 && speed > - 70) speed = 0; //     120 // ,     if(speed < 120 && speed > 70) speed = 120; if(speed > -120 && speed < -70) speed = -120; //     , ACTION_MOVE   //    ,     //      if(speed > 255 ) speed = 255; if(speed < - 255) speed = -255; //:  > 0 -  , < 0 -  return speed; } private String angleCalculation(float x) { //    7  //0 -  , 180 -  //90 -    if(x < BDCwidth/6) { angle = "0"; } else if (x > BDCwidth/6 && x < BDCwidth/3) { angle = "30"; } else if (x > BDCwidth/3 && x < BDCwidth/2) { angle = "60"; } else if (x > BDCwidth/2 && x < BDCwidth/3*2) { angle = "120"; } else if (x > BDCwidth/3*2 && x < BDCwidth/6*5) { angle = "150"; } else if (x > BDCwidth/6*5 && x < BDCwidth) { angle = "180"; } else { angle = "90"; } return angle; }

जब डेटा की गणना और स्थानांतरण किया जाता है, तो दूसरी धारा खेल में प्रवेश करती है। वह सूचना भेजने के लिए जिम्मेदार है। आप इसके बिना नहीं कर सकते, अन्यथा सॉकेट संचारित डेटा स्पर्श के कैप्चर को धीमा कर देगा, एक कतार बनाई जाएगी और पूरा अंत छोटा होगा।

ConnectedThread क्लास एक्टिविटीकंट्रोल क्लास में भी स्थित है।

 private class ConnectedThread extends Thread { private final BluetoothSocket socket; private final OutputStream outputStream; public ConnectedThread(BluetoothSocket btSocket) { //  this.socket = btSocket; //  -       OutputStream os = null; try { os = socket.getOutputStream(); } catch(Exception e) {} outputStream = os; } public void run() { } public void sendCommand(String speed, String angle) { //    ,   byte[] speedArray = speed.getBytes(); byte[] angleArray = angle.getBytes(); //    //  ,  ,       String a = "#"; String b = "@"; String c = "*"; try { outputStream.write(b.getBytes()); outputStream.write(speedArray); outputStream.write(a.getBytes()); outputStream.write(c.getBytes()); outputStream.write(angleArray); outputStream.write(a.getBytes()); } catch(Exception e) {} } }

Android एप्लिकेशन को सारांशित करना

ऊपर दिए गए सभी बोझ को संक्षेप में संक्षेप में बताएं।

ActivMain में हम ब्लूटूथ को कॉन्फ़िगर करते हैं, हम एक कनेक्शन स्थापित करते हैं।
एक्टिविटीकंट्रोल में हम बटन को संलग्न करते हैं और इसके बारे में डेटा प्राप्त करते हैं।
हम OnTouchListener बटन को लटकाते हैं, यह स्पर्श, गति और उंगली उठाता है।
प्राप्त डेटा (x और y निर्देशांक के साथ बिंदु) रोटेशन कोण और गति में परिवर्तित हो जाता है
हम डेटा भेजते हैं, उन्हें विशेष वर्णों के साथ अलग करते हैं

और अंतिम समझ आपको तब मिलेगी जब आप पूरे कोड को देखेंगे - github.com/IDolgopolov/BluaxyWorkAPP.git । कोई टिप्पणी कोड नहीं है, इसलिए यह बहुत साफ, छोटा और सरल दिखता है।

स्केच अरुडिनो

एंड्रॉइड एप्लिकेशन असंतुष्ट, लिखित, समझा गया ... और यहां यह आसान हो जाएगा। मैं चरणों में सब कुछ पर विचार करने की कोशिश करूंगा, और फिर मैं पूरी फाइल का लिंक दूंगा।

चर

सबसे पहले, स्थिरांक और चर पर विचार करें जिनकी आपको आवश्यकता होगी।

 #include <SoftwareSerial.h> //  \  //          SoftwareSerial BTSerial(8, 9); //    int speedRight = 6; int dirLeft = 3; int speedLeft = 11; int dirRight = 7; // ,   int angleDirection = 4; int angleSpeed = 5; //,     ,   //      int pinAngleStop = 12; //    String val; //  int speedTurn = 180; //,    //       int pinRed = A0; int pinWhite = A1; int pinBlack = A2; //   long lastTakeInformation; //, ,     boolean readAngle = false; boolean readSpeed = false;

सेटअप () विधि

सेटअप () विधि में, हम पिन के पैरामीटर सेट करते हैं: वे इनपुट या आउटपुट पर काम करेंगे। हमने Arduino के साथ कंप्यूटर की संचार गति, Arduino के साथ ब्लूटूथ भी सेट किया है।

 void setup() { pinMode(dirLeft, OUTPUT); pinMode(speedLeft, OUTPUT); pinMode(dirRight, OUTPUT); pinMode(speedRight, OUTPUT); pinMode(pinRed, INPUT); pinMode(pinBlack, INPUT); pinMode(pinWhite, INPUT); pinMode(pinAngleStop, OUTPUT); pinMode(angleDirection, OUTPUT); pinMode(angleSpeed, OUTPUT); //      HC-05 //     ,   BTSerial.begin(38400); //   Serial.begin(9600); }

लूप () विधि और अतिरिक्त कार्य

लगातार दोहराए जाने वाले लूप () विधि में, डेटा पढ़ा जाता है। सबसे पहले, मुख्य एल्गोरिथ्म पर विचार करें, और फिर इसमें शामिल फ़ंक्शन।

 void loop() { //    if(BTSerial.available() > 0) { //    char a = BTSerial.read(); if (a == '@') { //   @ (   ) //  val val = ""; //,     readSpeed = true; } else if (readSpeed) { //         //   val if(a == '#') { //   ,     //      Serial.println(val); //,      readSpeed = false; //      go(val.toInt()); // val val = ""; //  ,     return; } val+=a; } else if (a == '*') { //    readAngle = true; } else if (readAngle) { // ,     //  ,    val if(a == '#') { Serial.println(val); Serial.println("-----"); readAngle = false; //     turn(val.toInt()); val= ""; return; } val+=a; } //     lastTakeInformation = millis(); } else { //   ,      150  //  if(millis() - lastTakeInformation > 150) { lastTakeInformation = 0; analogWrite(angleSpeed, 0); analogWrite(speedRight, 0); analogWrite(speedLeft, 0); } } }

हमें परिणाम मिलता है: फोन से हम "@ गति # कोण #" की शैली में बाइट्स भेजते हैं (उदाहरण के लिए, एक सामान्य कमांड "@ 200 # 60 #"। यह चक्र हर 100 मिलीसेकंड को दोहराता है, क्योंकि एंड्रॉइड पर हम कमांड भेजने के लिए इस अंतराल को सेट करते हैं। संक्षेप में, करते हैं। इसका कोई मतलब नहीं है, क्योंकि वे कतार में लगने लगते हैं, और यदि आप इसे लंबा करते हैं, तो पहिए जोर-जोर से चलने लगते हैं

। देरी () कमांड के माध्यम से देरी, जिसे आप बाद में देखेंगे, शारीरिक और गणितीय गणनाओं के माध्यम से नहीं, बल्कि आनुभविक रूप से चुना जाता है। zadrezham, मशीन आसानी से चला जाता है, और में सभी टीमों के पास काम करने का समय है (धाराओं के माध्यम से चलने का समय है।)

चक्र में दो पक्ष कार्यों का उपयोग किया जाता है, वे प्राप्त डेटा लेते हैं और मशीन को चलते हैं और स्पिन करते हैं।

 void go(int mySpeed) { //   0 if(mySpeed > 0) { //  digitalWrite(dirRight, HIGH); analogWrite(speedRight, mySpeed); digitalWrite(dirLeft, HIGH); analogWrite(speedLeft, mySpeed); } else { //   0,   digitalWrite(dirRight, LOW); analogWrite(speedRight, abs(mySpeed) + 30); digitalWrite(dirLeft, LOW); analogWrite(speedLeft, abs(mySpeed) + 30); } delay(10); } void turn(int angle) { //      digitalWrite(pinAngleStop, HIGH); // ,     delay(5); //  150  ,   // 30  ,   //  31  149     if(angle > 149) { //  ,      //   ,    //    return if( digitalRead(pinWhite) == HIGH && digitalRead(pinBlack) == LOW && digitalRead(pinRed) == LOW) { return; } //      //  digitalWrite(angleDirection, HIGH); analogWrite(angleSpeed, speedTurn); } else if (angle < 31) { if(digitalRead(pinRed) == HIGH && digitalRead(pinBlack) == HIGH && digitalRead(pinWhite) == HIGH) { return; } digitalWrite(angleDirection, LOW); analogWrite(angleSpeed, speedTurn); } //  digitalWrite(pinAngleStop, LOW); delay(5); }

जब एंड्रॉइड डाटा भेजता है तो उपयोगकर्ता 60, 90, 120 के कोण पर चढ़ जाता है, इसके लायक नहीं है, अन्यथा आप सीधे नहीं जा पाएंगे। हां, हो सकता है कि अगर कोण बहुत छोटा है, तो आपको तुरंत एंड्रॉइड से एक टर्न कमांड भेजना चाहिए, लेकिन यह मेरी राय में किसी तरह अनाड़ी है।

स्केच परिणाम

एक स्केच में केवल तीन महत्वपूर्ण चरण होते हैं: एक कमांड पढ़ना, रोटेशन की सीमा को संसाधित करना और मोटर्स को करंट की आपूर्ति करना। सब कुछ सरल लगता है, और निष्पादन में यह आसान से आसान है, हालांकि यह लंबे समय तक और कुंद के साथ बनाया गया था। स्केच का पूर्ण संस्करण ।

अंत में

काम के कई महीनों की एक पूरी सूची खत्म हो गई है। भौतिक भाग विघटित है, सॉफ्टवेयर सभी और अधिक। सिद्धांत एक ही रहता है - असंगत घटनाओं के लिए संपर्क, हम एक साथ समझेंगे।

और पहले भाग के तहत टिप्पणियां दिलचस्प हैं, उन्होंने सभी के लिए धन्यवाद , उपयोगी सुझावों के एक पहाड़ की सलाह दी ।