diff --git a/include/README b/include/README new file mode 100644 index 0000000..194dcd4 --- /dev/null +++ b/include/README @@ -0,0 +1,39 @@ + +This directory is intended for project header files. + +A header file is a file containing C declarations and macro definitions +to be shared between several project source files. You request the use of a +header file in your project source file (C, C++, etc) located in `src` folder +by including it, with the C preprocessing directive `#include'. + +```src/main.c + +#include "header.h" + +int main (void) +{ + ... +} +``` + +Including a header file produces the same results as copying the header file +into each source file that needs it. Such copying would be time-consuming +and error-prone. With a header file, the related declarations appear +in only one place. If they need to be changed, they can be changed in one +place, and programs that include the header file will automatically use the +new version when next recompiled. The header file eliminates the labor of +finding and changing all the copies as well as the risk that a failure to +find one copy will result in inconsistencies within a program. + +In C, the usual convention is to give header files names that end with `.h'. +It is most portable to use only letters, digits, dashes, and underscores in +header file names, and at most one dot. + +Read more about using header files in official GCC documentation: + +* Include Syntax +* Include Operation +* Once-Only Headers +* Computed Includes + +https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html diff --git a/lib/README b/lib/README new file mode 100644 index 0000000..6debab1 --- /dev/null +++ b/lib/README @@ -0,0 +1,46 @@ + +This directory is intended for project specific (private) libraries. +PlatformIO will compile them to static libraries and link into executable file. + +The source code of each library should be placed in a an own separate directory +("lib/your_library_name/[here are source files]"). + +For example, see a structure of the following two libraries `Foo` and `Bar`: + +|--lib +| | +| |--Bar +| | |--docs +| | |--examples +| | |--src +| | |- Bar.c +| | |- Bar.h +| | |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html +| | +| |--Foo +| | |- Foo.c +| | |- Foo.h +| | +| |- README --> THIS FILE +| +|- platformio.ini +|--src + |- main.c + +and a contents of `src/main.c`: +``` +#include +#include + +int main (void) +{ + ... +} + +``` + +PlatformIO Library Dependency Finder will find automatically dependent +libraries scanning project source files. + +More information about PlatformIO Library Dependency Finder +- https://docs.platformio.org/page/librarymanager/ldf.html diff --git a/platformio.ini b/platformio.ini new file mode 100644 index 0000000..e7154c1 --- /dev/null +++ b/platformio.ini @@ -0,0 +1,14 @@ +; PlatformIO Project Configuration File +; +; Build options: build flags, source filter +; Upload options: custom upload port, speed and extra flags +; Library options: dependencies, extra library storages +; Advanced options: extra scripting +; +; Please visit documentation for the other options and examples +; https://docs.platformio.org/page/projectconf.html + +[env:sparkfun_promicro8] +platform = atmelavr +board = sparkfun_promicro8 +framework = arduino diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..bcc3a28 --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,197 @@ +// CONNECTIONS: +// DS1307 SDA --> SDA +// DS1307 SCL --> SCL +// DS1307 VCC --> 5v +// DS1307 GND --> GND + +#define countof(a) (sizeof(a) / sizeof(a[0])) + +/* for software wire use below +#include // must be included here so that Arduino library object file references work +#include +#include + +SoftwareWire myWire(SDA, SCL); +RtcDS1307 Rtc(myWire); +/* for software wire use above */ + +/* for normal hardware wire use below */ +#include // must be included here so that Arduino library object file references work +#include +#include + +RtcDS3231 Rtc(Wire); +EepromAt24c32 RtcEeprom(Wire); + +// if you have any of the address pins on the RTC soldered together +// then you need to provide the state of those pins, normally they +// are connected to vcc with a reading of 1, if soldered they are +// grounded with a reading of 0. The bits are in the order A2 A1 A0 +// thus the following would have the A2 soldered together +// EepromAt24c32 RtcEeprom(Wire, 0b011); + +/* for normal hardware wire use above */ + +// nothing longer than 32 bytes +// rtc eeprom memory is 32 byte pages +// writing is limited to each page, so it will wrap at page +// boundaries. +// But reading is only limited by the buffer in Wire class which +// by default is 32 +const char data[] = "What time is it in Greenwich?"; +const uint16_t stringAddr = 64; // stored on page boundary + +void printDateTime(const RtcDateTime& dt); + +void setup () +{ + Serial.begin(9600); + + Serial.print("compiled: "); + Serial.print(__DATE__); + Serial.println(__TIME__); + + //--------RTC SETUP ------------ + // if you are using ESP-01 then uncomment the line below to reset the pins to + // the available pins for SDA, SCL + // Wire.begin(0, 2); // due to limited pins, use pin 0 and 2 for SDA, SCL + + Rtc.Begin(); + RtcEeprom.Begin(); + + RtcDateTime compiled = RtcDateTime(__DATE__, __TIME__); + printDateTime(compiled); + Serial.println(); + + if (!Rtc.IsDateTimeValid()) + { + if (Rtc.LastError() != 0) + { + // we have a communications error + // see https://www.arduino.cc/en/Reference/WireEndTransmission for + // what the number means + Serial.print("RTC communications error = "); + Serial.println(Rtc.LastError()); + } + else + { + Serial.println("RTC lost confidence in the DateTime!"); + Rtc.SetDateTime(compiled); + } + } + + if (!Rtc.GetIsRunning()) + { + Serial.println("RTC was not actively running, starting now"); + Rtc.SetIsRunning(true); + } + + RtcDateTime now = Rtc.GetDateTime(); + if (now < compiled) + { + Serial.println("RTC is older than compile time! (Updating DateTime)"); + Rtc.SetDateTime(compiled); + } + + // never assume the Rtc was last configured by you, so + // just clear them to your needed state + Rtc.Enable32kHzPin(false); + Rtc.SetSquareWavePin(DS3231SquareWavePin_ModeNone); + +/* comment out on a second run to see that the info is stored long term */ + // Store something in memory on the Eeprom + + // store starting address of string + RtcEeprom.SetMemory(0, stringAddr); + // store the string, nothing longer than 32 bytes due to paging + uint8_t written = RtcEeprom.SetMemory(stringAddr, (const uint8_t*)data, sizeof(data) - 1); // remove the null terminator strings add + // store the length of the string + RtcEeprom.SetMemory(1, written); // store the +/* end of comment out section */ +} + +void loop () +{ + if (!Rtc.IsDateTimeValid()) + { + if (Rtc.LastError() != 0) + { + // we have a communications error + // see https://www.arduino.cc/en/Reference/WireEndTransmission for + // what the number means + Serial.print("RTC communications error = "); + Serial.println(Rtc.LastError()); + } + else + { + // Common Causes: + // 1) the battery on the device is low or even missing and the power line was disconnected + Serial.println("RTC lost confidence in the DateTime!"); + } + } + + RtcDateTime now = Rtc.GetDateTime(); + + printDateTime(now); + Serial.println(); + + delay(5000); + + // read data + + // get the offset we stored our data from address zero + uint8_t address = RtcEeprom.GetMemory(0); + if (address != stringAddr) + { + Serial.print("address didn't match "); + Serial.println(address); + } + + { + // get the size of the data from address 1 + uint8_t count = RtcEeprom.GetMemory(1); + uint8_t buff[64]; + + // get our data from the address with the given size + uint8_t gotten = RtcEeprom.GetMemory(address, buff, count); + + if (gotten != count || + count != sizeof(data) - 1) // remove the extra null terminator strings add + { + Serial.print("something didn't match, count = "); + Serial.print(count, DEC); + Serial.print(", gotten = "); + Serial.print(gotten, DEC); + Serial.println(); + } + Serial.print("data read ("); + Serial.print(gotten); + Serial.print(") = \""); + for (uint8_t ch = 0; ch < gotten; ch++) + { + Serial.print((char)buff[ch]); + } + Serial.println("\""); + } + + + delay(5000); +} + + + +void printDateTime(const RtcDateTime& dt) +{ + char datestring[20]; + + snprintf_P(datestring, + countof(datestring), + PSTR("%02u/%02u/%04u %02u:%02u:%02u"), + dt.Month(), + dt.Day(), + dt.Year(), + dt.Hour(), + dt.Minute(), + dt.Second() ); + Serial.print(datestring); +} \ No newline at end of file diff --git a/src/main.cpp_ b/src/main.cpp_ new file mode 100644 index 0000000..0668ad2 --- /dev/null +++ b/src/main.cpp_ @@ -0,0 +1,138 @@ +/** + * + * HX711 library for Arduino - example file + * https://github.com/bogde/HX711 + * + * MIT License + * (c) 2018 Bogdan Necula + * +** + +#include "HX711.h" + + +// HX711 circuit wiring +const int LOADCELL_DOUT_PIN = 21; +const int LOADCELL_SCK_PIN = 20; + + +HX711 scale; + +void setup() { + Serial.begin(38400); + Serial.println("HX711 Demo"); + + Serial.println("Initializing the scale"); + + // Initialize library with data output pin, clock input pin and gain factor. + // Channel selection is made by passing the appropriate gain: + // - With a gain factor of 64 or 128, channel A is selected + // - With a gain factor of 32, channel B is selected + // By omitting the gain factor parameter, the library + // default "128" (Channel A) is used here. + scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN); + + Serial.println("Before setting up the scale:"); + Serial.print("read: \t\t"); + Serial.println(scale.read()); // print a raw reading from the ADC + + Serial.print("read average: \t\t"); + Serial.println(scale.read_average(20)); // print the average of 20 readings from the ADC + + Serial.print("get value: \t\t"); + Serial.println(scale.get_value(5)); // print the average of 5 readings from the ADC minus the tare weight (not set yet) + + Serial.print("get units: \t\t"); + Serial.println(scale.get_units(5), 1); // print the average of 5 readings from the ADC minus tare weight (not set) divided + // by the SCALE parameter (not set yet) + + scale.set_scale(1000.f); // this value is obtained by calibrating the scale with known weights; see the README for details + scale.tare(); // reset the scale to 0 + + Serial.println("After setting up the scale:"); + + Serial.print("read: \t\t"); + Serial.println(scale.read()); // print a raw reading from the ADC + + Serial.print("read average: \t\t"); + Serial.println(scale.read_average(20)); // print the average of 20 readings from the ADC + + Serial.print("get value: \t\t"); + Serial.println(scale.get_value(5)); // print the average of 5 readings from the ADC minus the tare weight, set with tare() + + Serial.print("get units: \t\t"); + Serial.println(scale.get_units(5), 1); // print the average of 5 readings from the ADC minus tare weight, divided + // by the SCALE parameter set with set_scale + + Serial.println("Readings:"); +} + +void loop() { + Serial.print("one reading:\t"); + Serial.print(scale.get_units(), 1); + Serial.print("\t| average:\t"); + Serial.println(scale.get_units(10), 1); + + scale.power_down(); // put the ADC in sleep mode + delay(1000); + scale.power_up(); +} + + + +/* #include +#include +#include + + + +int RXLED = 17; // The RX LED has a defined Arduino pin + // Note: The TX LED was not so lucky, we'll need to use pre-defined + // macros (TXLED1, TXLED0) to control that. + // (We could use the same macros for the RX LED too -- RXLED1, + // and RXLED0.) + +// 1. HX711 circuit wiring +const int LOADCELL_DOUT_PIN = 21; +const int LOADCELL_SCK_PIN = 20; + +// 2. Adjustment settings +const long LOADCELL_OFFSET = 50682624; +const long LOADCELL_DIVIDER = 5895655; + +HX711 loadcell; + +void setup() +{ + pinMode(RXLED, OUTPUT); // Set RX LED as an output + // TX LED is set as an output behind the scenes + + Serial.begin(9600); //This pipes to the serial monitor + Serial.println("Initialize Serial Monitor"); + + Serial1.begin(9600); //This is the UART, pipes to sensors attached to board + Serial1.println("Initialize Serial Hardware UART Pins"); + + // 3. Initialize library + loadcell.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN); + loadcell.set_scale(LOADCELL_DIVIDER); + loadcell.set_offset(LOADCELL_OFFSET); +} + +void loop() +{ + // Serial.println("Hello world!!!"); // Print "Hello World" to the Serial Monitor + // Serial1.println("Hello! Can anybody hear me?"); // Print "Hello!" over hardware UART + + // 4. Acquire reading + Serial.print("Weight: "); + Serial.println(loadcell.get_units(10), 2); + + digitalWrite(RXLED, LOW); // set the RX LED ON + TXLED0; //TX LED is not tied to a normally controlled pin so a macro is needed, turn LED OFF + delay(200); // wait for a second + + digitalWrite(RXLED, HIGH); // set the RX LED OFF + TXLED1; //TX LED macro to turn LED ON + delay(200); // wait for a second +} */ \ No newline at end of file diff --git a/test/README b/test/README new file mode 100644 index 0000000..df5066e --- /dev/null +++ b/test/README @@ -0,0 +1,11 @@ + +This directory is intended for PIO Unit Testing and project tests. + +Unit Testing is a software testing method by which individual units of +source code, sets of one or more MCU program modules together with associated +control data, usage procedures, and operating procedures, are tested to +determine whether they are fit for use. Unit testing finds problems early +in the development cycle. + +More information about PIO Unit Testing: +- https://docs.platformio.org/page/plus/unit-testing.html