SmartCityZen återvinning med HX711 (4 / 6 steg)

Steg 4: TX skiss (sändare)

#include < HX711.h >
#include < JeeLib.h >
#include < Manchester.h >
ISR(WDT_vect) {Sleepy::watchdogEvent();}
HX711. DOUT - pin #A1
HX711. PD_SCK - pin #A0
/*
* Hur du kalibrerar din skala
1. Ring set_scale() med ingen parameter.
2. Ring tare() med ingen parameter.
3. Placera en känd vikt på skalan och kalla get_units(10).
4. dela resultatet i steg 3 till din känd vikt. Du borde få om parametern du behov till passera till set_scale.
5. Justera parametern i steg 4 tills du får en noggrann avläsning.
*/
HX711 (Dout, Sck)
HX711 skala (A1, A0); parametern "gain" är utelämnat; används standardvärdet 128 av biblioteket < /p >< p > #define TX_PIN 6 //pin var din sändare är ansluten
#define BUFFER_SIZE 50
#define LED_PIN 13
#define CELL_PIN A0 / / *** serienummer ***
char SerialSens [] = "SCZRE0364";
//*************************************
int volt = 0;
char messaggio [32];
unsigned char data [BUFFER_SIZE] = "";
char msg [BUFFER_SIZE];
char msg2 [10];
char msg3 [10];
char msg4 [10];
flyta carica = 0;
char vuota [32] = "";
int offset_scale = 53;
Hur ofta gör vi avläsningar?
lång tid = 0; //
int timeBetweenReadings = 500. Vi vill ha en läsning varje 200 ms;
void setup() {
Serial.BEGIN(9600);
man.workAround1MhzTinyCore(); Lägg till detta för sändaren att arbeta med 1 Mhz Attiny85/84
man.setupTransmit (TX_PIN, MAN_600);

pinMode (LED_PIN, OUTPUT);
pinMode (TX_PIN, OUTPUT);
Serial.println ("HX711 Demo");
Serial.println ("innan du ställer in skalan:");
Serial.Print ("Läs: \t\t");
Serial.println(Scale.Read()); skriva ut en rå behandling från ADC < /p >< p > Serial.print ("Läs genomsnittet: \t\t");
Serial.println(Scale.read_average(20)); skriva ut ett genomsnitt av 20 avläsningar från ADC < /p >< p > Serial.print ("få värde: \t\t");
Serial.println(Scale.get_value(5)); skriva ut ett genomsnitt av 5 avläsningar från ADC minus containerns Tara (inte angetts ännu) < /p >< p > Serial.print ("få enheter: \t\t");
Serial.println(Scale.get_units(5), 1); skriva ut ett genomsnitt av 5 avläsningar från ADC minus tareringsvikten (ej angivet) dividerat
av SKALAN parametern (inte ännu) < /p >< p > scale.set_scale(291.00); Detta värde erhålls genom att kalibrera skalan med kända vikter; se viktigt-filen för Detaljer
Scale.tare(); återställa skalan 0 < /p >< p > Serial.println ("efter inställning-upp skalan:"); < /p >< p > Serial.print ("Läs: \t\t");
Serial.println(Scale.Read()); skriva ut en rå behandling från ADC < /p >< p > Serial.print ("Läs genomsnittet: \t\t");
Serial.println(Scale.read_average(20)); skriva ut ett genomsnitt av 20 avläsningar från ADC < /p >< p > Serial.print ("få värde: \t\t");
Serial.println(Scale.get_value(5)); skriva ut ett genomsnitt av 5 avläsningar från ADC minus containerns, med tare() < /p >< p > Serial.print ("få enheter: \t\t");
Serial.println(Scale.get_units(5), 1); skriva ut ett genomsnitt av 5 avläsningar från ADC minus containerns, uppdelad
av parametern skala med set_scale < /p >< p > Serial.println("Readings:");
}
void loop() {
Serial.Print ("\t| PESO: \t");
float peso=-scale.get_units(10);
om (peso > -3 & & peso < 3) peso = 0;
Serial.Print (peso, 0); Serial.println ("gr.");
Delay(50);

dtostrf (peso, 4, 1, msg2);

float risultato=readVcc();

dtostrf (risultato, 4, 0, msg4);
carica = risultato/1000;
dtostrf (carica, 1, 3, msg4);
strcpy(MSG,"");
strcat (msg, "SN:");
strcat (msg, SerialSens);
strcat (msg, "PE:");
strcat (msg, msg2);
strcat (msg, "BT:");
strcat (msg, msg4);

för (int jag = 0; jag < = BUFFER_SIZE; i ++)
{
data [i] = msg [i];
}
digitalWrite(LED_PIN, true); Lampeggia il ledde al ricevimento del messaggio
Delay(10);
digitalWrite(LED_PIN, false);
man.transmitArray(BUFFER_SIZE,data);

Scale.power_down(); sätta ADC i viloläge
Sleepy::loseSomeTime(30000);
Scale.power_up();
}
float readVcc() {
Läs 1.1v referens mot AVcc
Ange referensen till Vcc och mätning till den inre 1.1v referens
#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#elif definieras (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
ADMUX = _BV(MUX5) | _BV(MUX0);
#elif definieras (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
ADMUX = _BV(MUX3) | _BV(MUX2);
#else
ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#endif

Delay(2); Vänta på Vref sedimentera
ADCSRA | = _BV(ADSC); Starta konvertering
samtidigt (bit_is_set(ADCSRA,ADSC)); mäta

uint8_t låg = ADCL; måste läsa ADCL första - det sedan Lås ADCH
uint8_t hög = ADCH; låser upp både

långa leda = (hög << 8) | låg;

resultat = 1125300L / leda; Beräkning av Vcc (mV); 1125300 = 1,1 * 1023 * 1000
returnera resultat; VCC i millivolt
}

Naturligtvis på linje ändras 71 värdet med vad du fick under kalibreringen.

Skissen är baserat på projektets SmartCityZen protokoll, och sedan jämfört den enda avfall kontroll funktionalitet finns det vissa överflödig information skickas (till exempel sensor koden eller batteri volt).

På detta sätt emellertid kan den överförda informationen läsas från SCZ Station och överförs via Internet på SmartCityZen webbserver och delas via portalen.

Skissen skickar till mottagaren var 30 sekunder vikten av avfall, detta värde kan ändras helt enkelt ändra värdet av detta kommando

Sleepy:: loseSomeTime (30000);

Ändra 30000 mS till ett max värde på 60000 mS, som ger en paus på 1 minut, att öka det och gör till exempel en skicka var 3 minuter med följande syntax:

Sleepy:: loseSomeTime (60000);
Sleepy:: loseSomeTime (60000); < br > sömnig:: loseSomeTime (60000);

Ringer 3 gånger kommandot.