Arduino平台软硬件原理及使用——开源库的使用

李优秀  金牌会员 | 2024-10-15 23:56:12 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 553|帖子 553|积分 1659

文章目录：
一、库文件的下载及导入
二、库文件源代码分析
三、库文件应用举例
  一、库文件的下载及导入


有关arduino开源库的导入有两种方案：
1.第一种方案需要借助arduino.cc网站来举行查询下载，然后在Arduino软件中举行导入。
2.第二种方案则只需要使用较新版本的Arduino软件（2.2版本之后），在软件中可以直接搜索并导入开源库。
1.在Arduino.cc举行导入库

首先在网页地点框直接输入arduino.cc便可进入网站：

然后点击上方【DOCUMENTATION】选项：

在此页面点击左侧【Libraries】选项，便可进入官方收录的库文件页面：

选择要用的库文件的类目，这里以【display】为例：

然后点击具体的库文件，以【LiquidCrystal】为例：

进入库文件下载目录后，直接点击要用的版本号即可直接下载。
下载完成后如果不是压缩包，最好压缩成zip文件：

末了打开Arduino软件，选择【项目】-【导入库】-【添加.ZIP库】然后选择对应的zip文件即可导入乐成。
2.使用Arduino软件导入库

上述方案较为复杂，所以建议使用较新版本的Arduino软件直接导入库：

在此版本的软件中直接点选左侧的“册本”样式的图标（其表示为库文件），然后直接在搜索框查找要使用的库文件名，选择对应库文件及版本点击安装即可。
这种方案则最为简洁，当然有些时间要使用的库在软件中查询不到，此时就需要接纳第一种方案举行导入。
2、库文件源代码分析


如上图所示，一般库文件中会有如上几个文件（会存在些许不同）。
1.示例程序的使用

example文件即为【示例】，这里面会有开源文件贡献者编写的几个示例程序，用于资助学习者理解库的使用：

当然只要将库文件导入过Arduino中，也可以在Arduino软件中打开相应的示例程序：

2.【.h文件】及【.cpp】文件分析

在【src】文件夹中存在以下两个文件：
【.h】后缀我们称之为头文件，【.cpp】后缀我们称之为源文件

头文件通常包含类声明、函数原型、宏定义和全局变量声明等。它们的目的是提供一种方式来共享代码，并确保在多个源文件中使用一致的声明：
  1. /*
  2.   HCSR04 - Library for arduino, for HC-SR04 ultrasonic distance sensor.
  3.   Created by Dirk Sarodnick, 2020.
  4. */
  6. #ifndef HCSR04_H
  7. #define HCSR04_H
  9. #include "Arduino.h"
  11. #define HCSR04_INVALID_RESULT  -1;
  12. #define HCSR04_NO_TRIGGER      -2;
  13. #define HCSR04_NO_ECHO         -3;
  15. class HCSR04Sensor {
  16.         public:
  17.                 HCSR04Sensor();
  18.                 ~HCSR04Sensor();
  20.                 typedef enum eUltraSonicUnlock {
  21.                         unlockSkip = 0,
  22.                         unlockMaybe = 1,
  23.                         unlockForced = 2
  24.                 } eUltraSonicUnlock_t;
  25.                
  26.                 void begin(uint8_t triggerPin, uint8_t echoPin) { begin(triggerPin, new uint8_t[1]{ echoPin }, 1); }
  27.                 void begin(uint8_t triggerPin, uint8_t* echoPins, uint8_t echoCount) { begin(triggerPin, echoPins, echoCount, 100000, eUltraSonicUnlock_t::unlockSkip); }
  28.                 void begin(uint8_t triggerPin, uint8_t echoPin, uint32_t timeout, eUltraSonicUnlock_t unlock) { begin(triggerPin, new uint8_t[1]{ echoPin }, 1, timeout, unlock); }
  29.                 void begin(uint8_t triggerPin, uint8_t* echoPins, uint8_t echoCount, uint32_t timeout, eUltraSonicUnlock_t unlock) { begin(triggerPin, echoPins, echoCount, timeout, 10, 10, unlock); }
  30.                 void begin(uint8_t triggerPin, uint8_t* echoPins, uint8_t echoCount, uint32_t timeout, uint16_t triggerTime, uint16_t triggerWait, eUltraSonicUnlock_t unlock);
  31.                 void end();
  32.                
  33.                 long* measureMicroseconds() { measureMicroseconds(lastMicroseconds); return lastMicroseconds; }
  34.                 void measureMicroseconds(long* results);
  36.                 double* measureDistanceMm() { measureDistanceMm(defaultTemperature, lastDistances); return lastDistances; }
  37.                 void measureDistanceMm(double* results) { measureDistanceMm(defaultTemperature, results == NULL ? lastDistances : results); }
  38.                 double* measureDistanceMm(float temperature) { measureDistanceMm(temperature, lastDistances); return lastDistances; }
  39.                 void measureDistanceMm(float temperature, double* results);
  41.                 double* measureDistanceCm() { measureDistanceCm(defaultTemperature, lastDistances); return lastDistances; }
  42.                 void measureDistanceCm(double* results) { measureDistanceCm(defaultTemperature, results == NULL ? lastDistances : results); }
  43.                 double* measureDistanceCm(float temperature) { measureDistanceCm(temperature, lastDistances); return lastDistances; }
  44.                 void measureDistanceCm(float temperature, double* results);
  46.                 double* measureDistanceIn() { measureDistanceIn(defaultTemperature, lastDistances); return lastDistances; }
  47.                 void measureDistanceIn(double* results) { measureDistanceIn(defaultTemperature, results == NULL ? lastDistances : results); }
  48.                 double* measureDistanceIn(float temperature) { measureDistanceIn(temperature, lastDistances); return lastDistances; }
  49.                 void measureDistanceIn(float temperature, double* results);
  50.                
  51.                 static void triggerInterrupt0(void);
  52.                 static void triggerInterrupt1(void);
  53.                 static void triggerInterrupt2(void);
  54.                 static void triggerInterrupt3(void);
  55.                 static void triggerInterrupt4(void);
  56.                 static void triggerInterrupt5(void);
  57.                 static void triggerInterrupt6(void);
  58.                 static void triggerInterrupt7(void);
  59.                 static void triggerInterrupt8(void);
  60.                 static void triggerInterrupt9(void);
  61.                
  62.                 static void echoInterrupt0(void);
  63.                 static void echoInterrupt1(void);
  64.                 static void echoInterrupt2(void);
  65.                 static void echoInterrupt3(void);
  66.                 static void echoInterrupt4(void);
  67.                 static void echoInterrupt5(void);
  68.                 static void echoInterrupt6(void);
  69.                 static void echoInterrupt7(void);
  70.                 static void echoInterrupt8(void);
  71.                 static void echoInterrupt9(void);
  72.        
  73.         private:
  74.                 float defaultTemperature = 19.307;
  75.                 long* lastMicroseconds;
  76.                 double* lastDistances;
  78.                 uint32_t timeout;
  79.                 uint16_t triggerTime = 10; // HC-SR04 needs at least 10�s trigger. Others may need longer trigger pulses.
  80.                 uint16_t triggerWait = 10; // HC-SR04 sends its signal about 200�s. We only wait a small amount to reduce interference, but to not miss anything on slower clock speeds.
  81.                 volatile uint8_t triggerPin;
  82.                 volatile unsigned long* volatile triggerTimes;
  83.                
  84.                 uint8_t echoCount;
  85.                 volatile int16_t* volatile echoStages;
  86.                 volatile int16_t* volatile echoInts;
  87.                 volatile int16_t* volatile echoPorts;
  88.                 volatile unsigned long* volatile echoTimes;
  89.                
  90.                 void triggerInterrupt(uint8_t);
  91.                 void echoInterrupt(uint8_t);
  92.                 void unlockSensors(eUltraSonicUnlock_t, uint8_t*);
  93. };
  95. extern HCSR04Sensor HCSR04;
  97. #endif // HCSR04_H
复制代码
源文件包含了实现代码，即函数和方法的定义。它们通常包含与头文件对应的实现：
  1. /*
  2.   HCSR04 - Library for arduino, for HC-SR04 ultrasonic distance sensor.
  3.   Created by Dirk Sarodnick, 2020.
  4. */
  6. #include "Arduino.h"
  7. #include "HCSR04.h"
  9. HCSR04Sensor::HCSR04Sensor() {}
  10. HCSR04Sensor::~HCSR04Sensor() { this->end(); }
  12. void HCSR04Sensor::begin(uint8_t triggerPin, uint8_t* echoPins, uint8_t echoCount, uint32_t timeout, uint16_t triggerTime, uint16_t triggerWait, eUltraSonicUnlock_t unlock) {
  13.         if (this->echoCount != echoCount) this->end();
  14.        
  15.         this->triggerPin = triggerPin;
  16.         pinMode(triggerPin, OUTPUT);
  18.         this->timeout = timeout;
  19.         this->triggerTime = triggerTime;
  20.         this->triggerWait = triggerWait;
  21.         this->echoCount = echoCount;
  22.        
  23.         if (this->lastMicroseconds == NULL) this->lastMicroseconds = new long[echoCount];
  24.         if (this->lastDistances == NULL) this->lastDistances = new double[echoCount];
  25.        
  26.         if (this->triggerTimes == NULL) this->triggerTimes = new unsigned long[echoCount];
  27.         if (this->echoTimes == NULL) this->echoTimes = new unsigned long[echoCount];
  29.         if (this->echoStages == NULL) this->echoStages = new int16_t[echoCount];
  30.         if (this->echoInts == NULL) this->echoInts = new int16_t[echoCount];
  31.         if (this->echoPorts == NULL) this->echoPorts = new int16_t[echoCount];
  33.         for (uint8_t i = 0; i < this->echoCount; i++) {
  34.                 this->triggerTimes[i] = 0;
  35.                 this->echoTimes[i] = 0;
  37.                 int16_t interrupt = digitalPinToInterrupt(echoPins[i]);
  38.                 if (interrupt == NOT_AN_INTERRUPT) {
  39.                         this->echoStages[i] = -1;
  40.                         this->echoInts[i] = -1;
  41.                         this->echoPorts[i] = echoPins[i];
  42.                 } else {
  43.                         this->echoStages[i] = 0;
  44.                         this->echoInts[i] = interrupt;
  45.                         this->echoPorts[i] = -1;
  46.                 }
  48.                 pinMode(echoPins[i], INPUT);
  49.         }
  50.        
  51.         // Unlock sensors that are possibly in a locked state, if this feature is enabled.
  52.         this->unlockSensors(unlock, echoPins);
  53. }
  55. void HCSR04Sensor::end() {
  56.         if (this->lastMicroseconds != NULL) delete []this->lastMicroseconds;
  57.         if (this->lastDistances != NULL) delete []this->lastDistances;
  58.         if (this->triggerTimes != NULL) delete []this->triggerTimes;
  59.         if (this->echoTimes != NULL) delete []this->echoTimes;
  60.        
  61.         if (this->echoPorts != NULL) delete []this->echoPorts;
  62.         if (this->echoInts != NULL) delete []this->echoInts;
  63.         if (this->echoStages != NULL) delete []this->echoStages;
  64.        
  65.         this->lastMicroseconds = NULL;
  66.         this->lastDistances = NULL;
  67.         this->triggerTimes = NULL;
  68.         this->echoTimes = NULL;
  69.         this->echoPorts = NULL;
  70.         this->echoInts = NULL;
  71.         this->echoStages = NULL;
  72. }
  74. void HCSR04Sensor::measureMicroseconds(long* results) {
  75.         if (results == NULL) results = this->lastMicroseconds;
  77.         bool finished = true;
  78.         bool waiting = true;
  79.         unsigned long startMicros = micros();
  80.         unsigned long currentMicros = 0;
  81.         unsigned long elapsedMicros = 0;
  83.         // Make sure that trigger pin is LOW.
  84.         digitalWrite(triggerPin, LOW);
  85.         delayMicroseconds(4);
  86.        
  87.         // Hold trigger HIGH for 10 microseconds (default), which signals the sensor to measure distance.
  88.         digitalWrite(triggerPin, HIGH);
  89.         delayMicroseconds(this->triggerTime);
  91.         // Set trigger LOW again and wait to give the sensor time for sending the signal without interference
  92.         digitalWrite(triggerPin, LOW);
  93.         delayMicroseconds(this->triggerWait);
  94.        
  95.         // Attach interrupts to echo pins for the starting point
  96.         for (uint8_t i = 0; i < this->echoCount; i++) {
  97.                 if (this->echoInts[i] >= 0 && this->echoStages[i] == 0) {
  98.                         this->echoStages[i] = 1;
  99.                         switch (i) {
  100.                                 case 0: attachInterrupt(this->echoInts[i], &triggerInterrupt0, RISING); break;
  101.                                 case 1: attachInterrupt(this->echoInts[i], &triggerInterrupt1, RISING); break;
  102.                                 case 2: attachInterrupt(this->echoInts[i], &triggerInterrupt2, RISING); break;
  103.                                 case 3: attachInterrupt(this->echoInts[i], &triggerInterrupt3, RISING); break;
  104.                                 case 4: attachInterrupt(this->echoInts[i], &triggerInterrupt4, RISING); break;
  105.                                 case 5: attachInterrupt(this->echoInts[i], &triggerInterrupt5, RISING); break;
  106.                                 case 6: attachInterrupt(this->echoInts[i], &triggerInterrupt6, RISING); break;
  107.                                 case 7: attachInterrupt(this->echoInts[i], &triggerInterrupt7, RISING); break;
  108.                                 case 8: attachInterrupt(this->echoInts[i], &triggerInterrupt8, RISING); break;
  109.                                 case 9: attachInterrupt(this->echoInts[i], &triggerInterrupt9, RISING); break;
  110.                         }
  111.                 }
  112.         }
  113.        
  114.         // Wait until all echos are returned or timed out.
  115.         while(true) {
  116.                 delayMicroseconds(1);
  117.                
  118.                 finished = true;
  119.                 waiting = true;
  120.                 currentMicros = micros();
  121.                 elapsedMicros = currentMicros - startMicros;
  123.                 for (uint8_t i = 0; i < this->echoCount; i++) {
  124.                         waiting &= elapsedMicros < this->timeout || (this->triggerTimes[i] > 0 && this->echoTimes[i] == 0 && (currentMicros - this->triggerTimes[i]) < this->timeout);
  126.                         if (this->echoPorts[i] >= 0 && this->triggerTimes[i] == 0) {
  127.                                 if (digitalRead(this->echoPorts[i]) == HIGH) this->triggerTimes[i] = micros();
  128.                         }
  130.                         if (this->triggerTimes[i] > 0 || !waiting) {
  131.                                 if (this->echoInts[i] >= 0 && (this->echoStages[i] == 1 || !waiting)) {
  132.                                         if (this->echoStages[i] == 1) this->echoStages[i] = 2;
  133.                                         detachInterrupt(this->echoInts[i]);
  134.                                 }
  135.                         } else finished &= false;
  137.                         if (this->echoInts[i] >= 0 && this->triggerTimes[i] > 0 && this->echoStages[i] == 2 && waiting) {
  138.                                 this->echoStages[i] = 3;
  139.                                 switch (i) {
  140.                                         case 0: attachInterrupt(this->echoInts[i], &echoInterrupt0, FALLING); break;
  141.                                         case 1: attachInterrupt(this->echoInts[i], &echoInterrupt1, FALLING); break;
  142.                                         case 2: attachInterrupt(this->echoInts[i], &echoInterrupt2, FALLING); break;
  143.                                         case 3: attachInterrupt(this->echoInts[i], &echoInterrupt3, FALLING); break;
  144.                                         case 4: attachInterrupt(this->echoInts[i], &echoInterrupt4, FALLING); break;
  145.                                         case 5: attachInterrupt(this->echoInts[i], &echoInterrupt5, FALLING); break;
  146.                                         case 6: attachInterrupt(this->echoInts[i], &echoInterrupt6, FALLING); break;
  147.                                         case 7: attachInterrupt(this->echoInts[i], &echoInterrupt7, FALLING); break;
  148.                                         case 8: attachInterrupt(this->echoInts[i], &echoInterrupt8, FALLING); break;
  149.                                         case 9: attachInterrupt(this->echoInts[i], &echoInterrupt9, FALLING); break;
  150.                                 }
  151.                         }
  153.                         if (this->echoPorts[i] >= 0 && this->triggerTimes[i] > 0 && this->echoTimes[i] == 0) {
  154.                                 if (digitalRead(this->echoPorts[i]) == LOW) this->echoTimes[i] = micros();
  155.                         }
  156.                        
  157.                         if ((this->triggerTimes[i] > 0 && this->echoTimes[i] > 0) || !waiting) {
  158.                                 if (this->echoInts[i] >= 0 && (this->echoStages[i] == 3 || !waiting)) {
  159.                                         if (this->echoStages[i] == 3) this->echoStages[i] = 4;
  160.                                         detachInterrupt(this->echoInts[i]);
  161.                                 }
  162.                         } else finished &= false;
  163.                 }
  164.                
  165.                 if (!waiting || finished) break;
  166.         }
  167.        
  168.         // Determine the durations of each sensor.
  169.         for (uint8_t i = 0; i < this->echoCount; i++) {
  170.                 if (this->echoInts[i] >= 0) this->echoStages[i] = 0;
  171.                 if (this->triggerTimes[i] > 0 && this->echoTimes[i] > 0) {
  172.                         long resultTime = this->echoTimes[i] - this->triggerTimes[i];
  173.                         results[i] = resultTime > 0 ? resultTime : HCSR04_INVALID_RESULT;
  174.                 } else if (this->triggerTimes[i] > 0) {
  175.                         results[i] = HCSR04_NO_ECHO;
  176.                 } else {
  177.                         results[i] = HCSR04_NO_TRIGGER;
  178.                 }
  180.                 this->triggerTimes[i] = 0;
  181.                 this->echoTimes[i] = 0;
  182.         }
  183. }
  185. void HCSR04Sensor::measureDistanceMm(float temperature, double* results) {
  186.         if (results == NULL) results = this->lastDistances;
  188.         double speedOfSoundInMmPerMs = (331.3 + 0.606 * temperature) / 1000; // Cair ≈ (331.3 + 0.606 ⋅ ϑ) m/s
  189.         long* times = measureMicroseconds();
  190.        
  191.         // Calculate the distance in mm for each result.
  192.         for (uint8_t i = 0; i < this->echoCount; i++) {
  193.                 double distanceMm = times[i] / 2.0 * speedOfSoundInMmPerMs;
  194.                 if (distanceMm < 10 || distanceMm > 4000) {
  195.                         results[i] = HCSR04_INVALID_RESULT;
  196.                 } else {
  197.                         results[i] = distanceMm;
  198.                 }
  199.         }
  200. }
  202. void HCSR04Sensor::measureDistanceCm(float temperature, double* results) {
  203.         if (results == NULL) results = this->lastDistances;
  205.         double speedOfSoundInCmPerMs = (331.3 + 0.606 * temperature) / 1000 / 10; // Cair ≈ (331.3 + 0.606 ⋅ ϑ) m/s
  206.         long* times = measureMicroseconds();
  207.        
  208.         // Calculate the distance in cm for each result.
  209.         for (uint8_t i = 0; i < this->echoCount; i++) {
  210.                 double distanceCm = times[i] / 2.0 * speedOfSoundInCmPerMs;
  211.                 if (distanceCm < 1 || distanceCm > 400) {
  212.                         results[i] = HCSR04_INVALID_RESULT;
  213.                 } else {
  214.                         results[i] = distanceCm;
  215.                 }
  216.         }
  217. }
  219. void HCSR04Sensor::measureDistanceIn(float temperature, double* results) {
  220.         if (results == NULL) results = this->lastDistances;
  222.         double speedOfSoundInCmPerMs = (331.3 + 0.606 * temperature) * 39.37007874 / 1000 / 1000; // Cair ≈ (331.3 + 0.606 ⋅ ϑ) m/s
  223.         long* times = measureMicroseconds();
  225.         // Calculate the distance in cm for each result.
  226.         for (uint8_t i = 0; i < this->echoCount; i++) {
  227.                 double distanceIn = times[i] / 2.0 * speedOfSoundInCmPerMs;
  228.                 if (distanceIn < 1 || distanceIn > 157.4804) {
  229.                         results[i] = HCSR04_INVALID_RESULT;
  230.                 }
  231.                 else {
  232.                         results[i] = distanceIn;
  233.                 }
  234.         }
  235. }
  237. void HCSR04Sensor::unlockSensors(eUltraSonicUnlock_t unlock, uint8_t* echoPins) {
  238.         if (unlock == eUltraSonicUnlock_t::unlockSkip) return;
  239.         bool hasLocked = false;
  241.         // Check if any sensor is in a locked state and unlock it if necessary.
  242.         for (uint8_t i = 0; echoPins[i] != 0; i++) {
  243.                 if (unlock == eUltraSonicUnlock_t::unlockMaybe && digitalRead(echoPins[i]) == LOW) continue;
  244.                 pinMode(echoPins[i], OUTPUT);
  245.                 digitalWrite(echoPins[i], LOW);
  246.                 hasLocked = true;
  247.         }
  248.        
  249.         if (hasLocked) delay(100);
  251.         // Revert the pinMode after potential unlocking.
  252.         for (uint8_t i = 0; echoPins[i] != 0; i++) {
  253.                 pinMode(echoPins[i], INPUT);
  254.         }
  255.        
  256.         if (hasLocked) delay(100);
  257. }
  259. void HCSR04Sensor::triggerInterrupt(uint8_t index) {
  260.         if (this->triggerTimes[index] == 0) this->triggerTimes[index] = micros();
  261. }
  263. void HCSR04Sensor::echoInterrupt(uint8_t index) {
  264.         if (this->triggerTimes[index] > 0 && this->echoTimes[index] == 0) this->echoTimes[index] = micros();
  265. }
  267. void HCSR04Sensor::triggerInterrupt0() { HCSR04.triggerInterrupt(0); }
  268. void HCSR04Sensor::triggerInterrupt1() { HCSR04.triggerInterrupt(1); }
  269. void HCSR04Sensor::triggerInterrupt2() { HCSR04.triggerInterrupt(2); }
  270. void HCSR04Sensor::triggerInterrupt3() { HCSR04.triggerInterrupt(3); }
  271. void HCSR04Sensor::triggerInterrupt4() { HCSR04.triggerInterrupt(4); }
  272. void HCSR04Sensor::triggerInterrupt5() { HCSR04.triggerInterrupt(5); }
  273. void HCSR04Sensor::triggerInterrupt6() { HCSR04.triggerInterrupt(6); }
  274. void HCSR04Sensor::triggerInterrupt7() { HCSR04.triggerInterrupt(7); }
  275. void HCSR04Sensor::triggerInterrupt8() { HCSR04.triggerInterrupt(8); }
  276. void HCSR04Sensor::triggerInterrupt9() { HCSR04.triggerInterrupt(9); }
  278. void HCSR04Sensor::echoInterrupt0() { HCSR04.echoInterrupt(0); }
  279. void HCSR04Sensor::echoInterrupt1() { HCSR04.echoInterrupt(1); }
  280. void HCSR04Sensor::echoInterrupt2() { HCSR04.echoInterrupt(2); }
  281. void HCSR04Sensor::echoInterrupt3() { HCSR04.echoInterrupt(3); }
  282. void HCSR04Sensor::echoInterrupt4() { HCSR04.echoInterrupt(4); }
  283. void HCSR04Sensor::echoInterrupt5() { HCSR04.echoInterrupt(5); }
  284. void HCSR04Sensor::echoInterrupt6() { HCSR04.echoInterrupt(6); }
  285. void HCSR04Sensor::echoInterrupt7() { HCSR04.echoInterrupt(7); }
  286. void HCSR04Sensor::echoInterrupt8() { HCSR04.echoInterrupt(8); }
  287. void HCSR04Sensor::echoInterrupt9() { HCSR04.echoInterrupt(9); }
  289. HCSR04Sensor HCSR04;
复制代码
三、库文件应用举例

下文以超声波传感器的库HCSR04来举行举例（仅分析代码用法，不作实物接线）
在导入HCSR04库之后，可打开库文件中的实例：
  1. #include <HCSR04.h>
  3. HCSR04 hc(5, 6); //initialisation class HCSR04 (trig pin , echo pin)
  4.                  //初始化超声波传感器，即表明接口号。
  6. void setup()
  7. {
  8.     Serial.begin(9600);  //串口初始化
  9. }
  11. void loop()
  12. {
  13.     Serial.println(hc.dist()); // return curent distance in serial
  14.                                // hc.dist()会返回超声波传感器检测的距离数据
  15.     delay(60);                 // 延时60毫秒
  16. }
复制代码
具体实例可参考文章——Arduino项目式编程讲授第四章——超声波测距
如果想要了解此库文件下的方法，则可以在Arduino软件中，按住【Alt / cmd】键，然后使用鼠标点击对应的库文件名，即可打开其头文件：


在头文件中，可以阅读文件贡献者做出的注释来了解此库文件中可供使用的方法。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

李优秀

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表