├── README.md
├── library.properties
├── examples
    ├── AGS10_calibrate_factory
    │   └── AGS10_calibrate_factory.ino
    ├── AGS10_readTVOC_basic
    │   └── AGS10_readTVOC_basic.ino
    ├── AGS10_readConfig
    │   └── AGS10_readConfig.ino
    └── AGS10_calibrate_custom
    │   └── AGS10_calibrate_custom.ino
├── AGS10.h
└── AGS10.cpp


/README.md:
--------------------------------------------------------------------------------
 1 | # AGS10_sensor
 2 | 
 3 | This library allows you to read the TVOC (total volatile organic compounds) data in ppb as well as read and set current sensor resistance in 0.1 kΩ.
 4 | 
 5 | See the exmaples folder for how to use the library. (more/better ones coming soon)
 6 | 
 7 | Confirmed working with Arduino will check ESP32 soon.
 8 | 
 9 | 
10 | 
11 | 
12 | 


--------------------------------------------------------------------------------
/library.properties:
--------------------------------------------------------------------------------
 1 | name=AGS10
 2 | version=1.0.2
 3 | author=JohnGermann
 4 | maintainer=JohnGermann <maybelater>
 5 | sentence=A library for the AGS10 sensor
 6 | paragraph=allows reading TVOC, Version, and Current Resistance as well as set the Slave Address and Sensor Zero Point.
 7 | category=Sensors
 8 | url=https://github.com/gina-seth/AGS10_sensor
 9 | architectures=*
10 | includes=AGS10.h, AGS10.cpp
11 | 


--------------------------------------------------------------------------------
/examples/AGS10_calibrate_factory/AGS10_calibrate_factory.ino:
--------------------------------------------------------------------------------
 1 | #include <AGS10.h>
 2 | #include <Wire.h>
 3 | #include <Arduino.h>
 4 | 
 5 | // declare sensor 
 6 | AGS10 sensor = AGS10();
 7 | 
 8 | 
 9 | void setup() {
10 |   //  begin a serial monitor 
11 |   Serial.begin(9600);
12 | 
13 |   //  initialize sensor 
14 |   sensor.begin();
15 | 
16 |   // calibrate the sensor to factory resistance
17 |   sensor.calibrateFact();
18 | 
19 | }
20 | 
21 | void loop() {
22 |   //  the code only needs to run once
23 | 
24 | }
25 | 


--------------------------------------------------------------------------------
/examples/AGS10_readTVOC_basic/AGS10_readTVOC_basic.ino:
--------------------------------------------------------------------------------
 1 | #include <AGS10.h>
 2 | #include <Wire.h>
 3 | #include <Arduino.h>
 4 | 
 5 | // declare sensor 
 6 | AGS10 sensor = AGS10();
 7 | 
 8 | // declare data variable
 9 | int tvoc;
10 | 
11 | void setup() {
12 |   // begin a serial monitor
13 |   Serial.begin(9600);
14 | 
15 |   //  initialize sensor 
16 |   sensor.begin();
17 | 
18 | 
19 | }
20 | 
21 | void loop() {
22 |   //  read TVOC sensor data every 1.6 seconds, according to datasheet max speed is 1.5 seconds/reading
23 |   tvoc = sensor.readTVOC();
24 |   Serial.println(tvoc);
25 |   delay(1600);
26 | 
27 | }
28 | 


--------------------------------------------------------------------------------
/examples/AGS10_readConfig/AGS10_readConfig.ino:
--------------------------------------------------------------------------------
 1 | #include <AGS10.h>
 2 | #include <Wire.h>
 3 | #include <Arduino.h>
 4 | 
 5 | // declare sensor 
 6 | AGS10 sensor = AGS10();
 7 | 
 8 | // declare data variables
 9 | int version, resist;
10 | 
11 | void setup() {
12 |   // begin a serial monitor 
13 |   Serial.begin(9600);
14 | 
15 |   //  initialize sensor 
16 |   sensor.begin();
17 | 
18 |   version = sensor.readVersion();
19 |   resist = sensor.readResist();
20 | 
21 |   Serial.println("----------------------------------");
22 |   Serial.print("Firmware version: ");
23 |   Serial.println(version);
24 |   Serial.println("----------------------------------");
25 |   Serial.print("Current Resistance (0.1kR): ");
26 |   Serial.println(resist);
27 |   Serial.println("----------------------------------");
28 | }
29 | 
30 | void loop() {
31 |   // this code only needs to run once
32 | 
33 | }
34 | 


--------------------------------------------------------------------------------
/examples/AGS10_calibrate_custom/AGS10_calibrate_custom.ino:
--------------------------------------------------------------------------------
 1 | #include <AGS10.h>
 2 | #include <Wire.h>
 3 | #include <Arduino.h>
 4 | 
 5 | // declare sensor 
 6 | AGS10 sensor = AGS10();
 7 | 
 8 | // declare calibration variables
 9 | uint8_t calib_CMD1 = 0xFF;
10 | uint8_t calib_CMD2 = 0xFF;
11 | 
12 | void setup() {
13 |   //  begin a serial monitor 
14 |   Serial.begin(9600);
15 | 
16 |   //  initialize sensor 
17 |   sensor.begin();
18 | 
19 |   /* calibrate the sensor
20 | 
21 |      this function works like such:
22 |      xxx.calibrateCust(ResistanceByte1, ResistanceByte2);
23 | 
24 |      the two values are the bytes that will make up the resistanace that you will
25 |      set for the sensor. see the AGS10 datasheet for more info about these values: 
26 |      http://www.aosong.com/en/products-86.html
27 | 
28 |      in the future, i may just add the math and such into the library, until then...
29 |   */
30 |   sensor.calibrateCust(calib_CMD1,calib_CMD2);
31 | 
32 | }
33 | 
34 | void loop() {
35 |   //  the code only needs to run once
36 | 
37 | }
38 | 


--------------------------------------------------------------------------------
/AGS10.h:
--------------------------------------------------------------------------------
 1 | // AGS10.h
 2 | 
 3 | // This is a library for the AGS10 sensor // It measures the total volatile organic compounds (TVOC) in the air // The sensor uses I2C communication protocol
 4 | 
 5 | #ifndef AGS10_H 
 6 | #define AGS10_H
 7 | 
 8 | #include <Arduino.h> 
 9 | #include <Wire.h>
10 | 
11 | // Define the I2C address of the sensor
12 | #define AGS10_ADDR 0x1A
13 | 
14 | // Define the register addresses
15 | #define TVOC_REG 0x00
16 | #define VERS_REG 0x11
17 | #define RESIST_REG 0x20
18 | #define CALIB_REG 0x01
19 | #define SLAVE_REG 0x21
20 | 
21 | // Define the calibration commands
22 | #define CALIB_CMD1 0x00
23 | #define CALIB_CMD2 0x0C
24 | #define CALIB_FACT 0xFF
25 | #define CALIB_ZERO 0x00
26 | 
27 | class AGS10 { 
28 |   
29 |   public:
30 | 
31 |     AGS10();  // Constructor 
32 |     void begin(); // Initialize the sensor
33 |     void calibrateFact(); // Calibrate the sensor
34 | 	void calibrateCust(uint8_t CALIB_RES1, uint8_t CALIB_RES2); // Calibrate the sensor using a custom resistance value (measured in 0.1kΩ)
35 |     void setAddress(uint8_t newAddr); // Set the sensor's i2c addr to have more than one sensor on the same bus
36 |     int readResist(); // Read the current resistance of the sensor in 0.1 kO
37 |     int readVersion();  // Read the sensor's current firmware version 
38 |     int readTVOC(); // Read the TVOC value in ppb
39 |     uint8_t Calc_CRC8(uint8_t *dat, uint8_t Num); 
40 | 
41 | 
42 |   private: 
43 | 
44 |     int _tvoc; // Variable to store the TVOC value 
45 |     int _version; // Variable to store the version value 
46 |     int _resist;  // Variable to store the resistance value
47 |     int _status; // Variable to store the status of the sensor [INACTIVE]
48 |     byte _crc;
49 | 
50 |   };
51 | 
52 | #endif
53 | 


--------------------------------------------------------------------------------
/AGS10.cpp:
--------------------------------------------------------------------------------
  1 | //  AGS10.cpp
  2 | 
  3 | #include "AGS10.h"
  4 | 
  5 | 
  6 | uint8_t AGS10::Calc_CRC8(uint8_t *dat, uint8_t Num)
  7 | {
  8 |   uint8_t i,byte1,crc=0xFF;
  9 |   for(byte1=0; byte1<Num; byte1++)
 10 |   {
 11 |     crc^=(dat[byte1]);
 12 |     for(i=0;i<8;i++)
 13 |     {
 14 |       if(crc & 0x80) crc=(crc<<1)^0x31;
 15 |       else crc=(crc<<1);
 16 |     }
 17 |   }
 18 |   return crc;
 19 | }
 20 | 
 21 | 
 22 | 
 23 | AGS10::AGS10()
 24 | {
 25 |   _tvoc = 0;
 26 | }
 27 | 
 28 | void AGS10::begin()
 29 | {
 30 |   Wire.begin();
 31 | }
 32 | 
 33 | void AGS10::calibrateFact()
 34 | {
 35 |   uint8_t data[4] = {CALIB_CMD1, CALIB_CMD2, CALIB_FACT, CALIB_FACT};
 36 |   _crc = Calc_CRC8(uint8_t(data), uint8_t(0x01));
 37 |   Wire.beginTransmission(AGS10_ADDR);
 38 |   Wire.write(CALIB_REG);
 39 |   Wire.write(CALIB_CMD1);
 40 |   Wire.write(CALIB_CMD2);
 41 |   Wire.write(CALIB_FACT);
 42 |   Wire.write(CALIB_FACT);
 43 |   Wire.write(_crc);
 44 |   Wire.endTransmission();
 45 | }
 46 |   
 47 | void AGS10::calibrateCust(uint8_t CALIB_RES1, uint8_t CALIB_RES2)
 48 | {
 49 | 	
 50 |     byte data[4] = {CALIB_CMD1, CALIB_CMD2, CALIB_RES1, CALIB_RES2};
 51 |     _crc = Calc_CRC8(data, 0x01);
 52 |     Wire.beginTransmission(AGS10_ADDR);
 53 |     Wire.write(CALIB_REG);
 54 |     Wire.write(CALIB_CMD1);
 55 |     Wire.write(CALIB_CMD2);
 56 |     Wire.write(CALIB_RES1);
 57 |     Wire.write(CALIB_RES2);
 58 |     Wire.write(_crc);
 59 |     Wire.endTransmission();
 60 | }
 61 |   
 62 | 
 63 | 
 64 | void AGS10::setAddress(uint8_t newAddr)
 65 | {
 66 |   uint8_t newAddrInv = (uint8_t) ~newAddr;
 67 |   uint8_t data[4] = {newAddr, newAddrInv, newAddr, newAddrInv}; 
 68 |   _crc = Calc_CRC8(data, 0x01);
 69 |   Wire.beginTransmission(AGS10_ADDR);
 70 |   Wire.write(SLAVE_REG);
 71 |   Wire.write(newAddr);
 72 |   Wire.write(newAddrInv);
 73 |   Wire.write(newAddr);
 74 |   Wire.write(newAddrInv);
 75 |   Wire.write(_crc);
 76 |   Wire.endTransmission();
 77 | }
 78 | 
 79 | int AGS10::readVersion()
 80 | {
 81 |   Wire.beginTransmission(AGS10_ADDR);
 82 |   Wire.write(VERS_REG);
 83 |   Wire.endTransmission();
 84 |   Wire.requestFrom(AGS10_ADDR, 5);
 85 | 
 86 |   if (Wire.available() == 5)  {
 87 |     byte reserved1 = Wire.read();
 88 |     byte reserved2 = Wire.read();
 89 |     byte reserved3 = Wire.read();
 90 |     byte version = Wire.read();
 91 |     byte crcByte = Wire.read();
 92 | 
 93 |     _version = version;
 94 | 
 95 |     return _version;
 96 |   }
 97 | }
 98 | 
 99 | int AGS10::readResist()
100 | {
101 |   Wire.beginTransmission(AGS10_ADDR);
102 |   Wire.write(RESIST_REG);
103 |   Wire.endTransmission();
104 | 
105 |   Wire.requestFrom(AGS10_ADDR, 5);
106 | 
107 |   if (Wire.available() == 5)  {
108 |     byte resistByteA = Wire.read();
109 |     byte resistByteB = Wire.read();
110 |     byte resistByteC = Wire.read();
111 |     byte resistByteD = Wire.read();
112 |     byte crcByte = Wire.read();
113 | 
114 |     _resist = (resistByteA << 24) | (resistByteB << 16) | (resistByteC << 8) | resistByteD;
115 |     
116 |     return _resist;
117 |   }
118 | }
119 | 
120 | int AGS10::readTVOC()
121 | {
122 |   Wire.beginTransmission(AGS10_ADDR);
123 |   Wire.write(TVOC_REG);
124 |   Wire.endTransmission();
125 | 
126 |   Wire.requestFrom(AGS10_ADDR, 5);
127 | 
128 |   if (Wire.available() == 5)  {
129 |     byte statusByte = Wire.read();
130 |     byte tvocByteA = Wire.read();
131 |     byte tvocByteB = Wire.read();
132 |     byte tvocByteC = Wire.read();
133 |     byte crcByte = Wire.read();
134 | 
135 |     int statusBit = (statusByte & 0x01) != 0;
136 |     _status = statusBit;
137 |     _tvoc = (tvocByteA << 16) | (tvocByteB << 8) | tvocByteC;
138 |   
139 |     return _tvoc;
140 |   }
141 | }
142 | 
143 | 


--------------------------------------------------------------------------------