10534l1.txt0000664000175400017510000000073111272100444012063 0ustar jillljeditorListing 1. Generate SHT11 Start Transmission Sequence void writeSHT1xTransmissionStartSequence(void) { writeSHT1xOne(DATA_SHT); writeSHT1xZero(SCK_SHT); udelay(2); writeSHT1xOne(SCK_SHT); udelay(2); writeSHT1xZero(DATA_SHT); udelay(2); writeSHT1xZero(SCK_SHT); udelay(2); udelay(2); udelay(2); writeSHT1xOne(SCK_SHT); udelay(2); writeSHT1xOne(DATA_SHT); udelay(2); writeSHT1xZero(SCK_SHT); udelay(2); } 10534l2.txt0000664000175400017510000000232111272100533012060 0ustar jillljeditorListing 2. Transmit Command Sequence void writeSHT1xCommand(int iMode) { unsigned char ucBitToCheck; unsigned char ucAckBit; driveDataLine(DATA_SHT); /* All 3 address bits always zero * so start with those */ writeSHT1xZero(DATA_SHT); udelay(2); writeSHT1xOne(SCK_SHT); udelay(2); writeSHT1xZero(SCK_SHT); writeSHT1xZero(DATA_SHT); udelay(2); writeSHT1xOne(SCK_SHT); udelay(2); writeSHT1xZero(SCK_SHT); writeSHT1xZero(DATA_SHT); udelay(2); writeSHT1xOne(SCK_SHT); udelay(2); writeSHT1xZero(SCK_SHT); /* Now transmit the 5 command bits, * in the order of MSb to LSb */ for (ucBitToCheck=0x10; ucBitToCheck != 0;) { if (iMode & ucBitToCheck) writeSHT1xOne(DATA_SHT); else writeSHT1xZero(DATA_SHT); udelay(2); writeSHT1xOne(SCK_SHT); udelay(2); writeSHT1xZero(SCK_SHT); ucBitToCheck >>= 1; } /* Now tri-state the data DIO so the * device can ACK the transfer */ tristateDataLine(DATA_SHT); udelay(2); writeSHT1xOne(SCK_SHT); udelay(2); ucAckBit = readSHT1x(DATA_SHT); writeSHT1xZero(SCK_SHT); mdelay(250); } 10534l3.txt0000664000175400017510000000241511272100616012067 0ustar jillljeditorListing 3. Read Sensor Data unsigned int readSHT1xData(void) { int iLoop; unsigned int uiBitRead; unsigned int uiMSB=0; unsigned int uiLSB=0; unsigned int uiRetValue; /* Read MSB from SHT1x */ for (iLoop = 0; iLoop < 8; iLoop++) { uiMSB <<= 1; writeSHT1xOne(SCK_SHT); uiBitRead = readSHT1x(DATA_SHT); udelay(2); writeSHT1xZero(SCK_SHT); udelay(2); if (uiBitRead) uiMSB |= 1; } /* Acknowledge sequence; must drive data * line as it is tri-stated at this point */ driveDataLine(DATA_SHT); writeSHT1xZero(DATA_SHT); udelay(2); writeSHT1xOne(SCK_SHT); udelay(2); writeSHT1xZero(SCK_SHT); tristateDataLine(DATA_SHT); udelay(2); /* Read LSB from SHT1x */ for (iLoop = 0; iLoop < 8; iLoop++) { uiLSB <<= 1; writeSHT1xOne(SCK_SHT); uiBitRead = readSHT1x(DATA_SHT); udelay(2); writeSHT1xZero(SCK_SHT); udelay(2); if (uiBitRead) uiLSB |= 1; } /* Don't acknowledge last byte so the device * doesn't transmit the 8-bit CRC as it isn't * really necessary for this application */ uiRetValue = u8tou16(uiMSB, uiLSB); return(uiRetValue); } 10534l4.txt0000664000175400017510000000024011272100657012067 0ustar jillljeditorListing 4. Read Humidity Sequence writeSHT1xTransmissionStartSequence(); writeSHT1xCommand(SHT1x_MEASURE_HUMIDITY); uiHumidity = readSHT1xData(); 10534l5.txt0000664000175400017510000000167411272100733012077 0ustar jillljeditorListing 5. Read/Write Relays unsigned char readRelay8(int iRelay8Address) { /* Read Relay8 register and return the value */ return(readb(iRelay8Address)); } void writeRelay8(int iRelay8Address, unsigned char ucValues) { /* Write Relay8 register with the values */ writeb(ucValues, iRelay8Address); } // Excerpt from ioctl function: switch(cmd) { case RELAY8_IOC_READ_RELAYS: /* Read Relay8 relay values */ ucRelayValues = readRelay8(relay8_base + RELAY8_CONTROL); if (copy_to_user((typeof(relay8_relayValues)) arg, &ucRelayValues, sizeof(relay8_relayValues))) { ret = -EFAULT; } break; case RELAY8_IOC_WRITE_RELAYS: /* Write Relay8 relay values */ writeRelay8(relay8_base + RELAY8_CONTROL, *(typeof(relay8_relayValues)) arg); break; default: ret = -ENOTTY; } 10534l6.txt0000664000175400017510000000127611272100776012105 0ustar jillljeditorListing 6. mib2c-Generated C Code netsnmp_register_scalar( netsnmp_create_handler_registration( "targetHumidity", handle_targetHumidity, targetHumidity_oid, OID_LENGTH(targetHumidity_oid), HANDLER_CAN_RWRITE)); int handle_targetHumidity(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo, netsnmp_request_info *requests) { switch (reqinfo->mode) { case MODE_GET: break; case MODE_SET_RESERVE1: break; case MODE_SET_COMMIT: break; } return SNMP_ERR_NOERROR; } 10534l7.txt0000664000175400017510000001752311254505367012115 0ustar jillljeditorListing 7. Humidity Controller Application C Code /* * Humidity Controller Application * * Copyright (C) 2009 Jeffrey Ramsey * * http://www.e2atechnology.com * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version, so long * as an * acknowledgment appears in derived source files. The * citation should list where the code came from. No warranty is * attached; I assume no responsibility for errors or fitness for use. * */ #include #include #include #include #include #include "/mnt/lfs/linux24/drivers/relay8/relay8Ioctl.h" #include "/mnt/lfs/linux24/drivers/sht1x/sht1xIoctl.h" /* Only expect this many characters in the * targetHumidity output from snmpget */ #define MAX_LINE 132 /* This is the humidifier power relay set */ #define HUMIDIFIER_RELAY_ID 0x03 /* This is the dehumidifier power relay set */ #define DEHUMIDIFIER_RELAY_ID 0x0c /* Let dehumidifier settle for this # of seconds */ #define DEHUMIDIFIER_SETTLING_TIME 60 /* Maximum # readings before the average is rescaled */ #define MAX_READINGS_BEFORE_RESCALE 500 int main(int argc, char *argv[]) { int fdSht11, fdRelays; unsigned int uiHumidity, uiTemperature; unsigned int uiMaxHumidity=0, uiMinHumidity=1000; unsigned int uiAvgHumidity=0, uiAvgCumulativeHumidity=0; unsigned int uiNumReadings=0; int iVals, iSetVals; unsigned int uiTargetHumidity = 50; FILE *fp1; char sTarget[MAX_LINE]; unsigned long ulLastDehumidifierSecondStamp = 0; unsigned long ulCurrentSeconds = 0; unsigned long tdiff; /* Open device instances */ fdRelays = open("/dev/relay80", O_RDWR); if (fdRelays <= 0) { printf("cannot open relay8-0!\n"); exit(0); } fdSht11 = open("/dev/sht1x0", O_RDWR); if( fdSht11 > 0 ) { printf("cannot open sht1x-0!\n"); exit(0); } /* Perpetually process; * Fetch MIB value for targetHumidity * Read current humidity/temperature and * process/switch relays if necessary * Gather statistics and update the SNMP OIDs */ while (1) { /* Periodically poll system */ sleep(1); /* Increment the seconds count; if it wraps to zero, * reset the last dehumidifier second stamp even though * the system will have to be up for many years for * this to ever happen! */ if (++ulCurrentSeconds == 0) { ulLastDehumidifierSecondStamp = 0; } /* Fetch the current target humidity and just * save it to be checked below against current readings */ system("snmpget -Ovqe -v 1 -c private " "localhost targetHumidity.0 1>vals.txt"); fp1 = fopen("./vals.txt", "r"); if (fp1) { fgets(sTarget, sizeof( sTarget ) - 1, fp1); sscanf(sTarget, "%d", &uiTargetHumidity); close(fp1); } /* Read current humidity/temperature */ ioctl(fdSht11, SHT1X_IOC_READ_HUMIDITY, &uiHumidity); ioctl(fdSht11, SHT1X_IOC_READ_TEMPERATURE, &uiTemperature); /* Process depending on state determined by relay settings */ /* Check if adjustment required; +- 3.5% rH */ if ((uiHumidity * 10) > ((uiTargetHumidity * 10) + 35)) { /* Need to dehumidify as long as dehumidifier * isn't already running */ ioctl(fdRelays, RELAY8_IOC_READ_RELAYS, &iSetVals); if (!(iSetVals & DEHUMIDIFIER_RELAY_ID)) { /* Dehumidifier isn't on; but check if it was * on in the settling period and defer if it was * to give the compressor time to settle */ tdiff = ulCurrentSeconds - ulLastDehumidifierSecondStamp; if (tdiff > DEHUMIDIFIER_SETTLING_TIME) { /* Safe to turn on dehumidifer */ iVals = DEHUMIDIFIER_RELAY_ID; ioctl(fdRelays, RELAY8_IOC_WRITE_RELAYS, &iVals); /* New second stamp for dehumidifier * settling time */ ulLastDehumidifierSecondStamp = ulCurrentSeconds; } } } else if ((uiHumidity * 10) < ((uiTargetHumidity * 10) - 35)) { /* Need to humidify as long as humidifier * isn't already running */ ioctl(fdRelays, RELAY8_IOC_READ_RELAYS, &iSetVals); if (!(iSetVals & HUMIDIFIER_RELAY_ID)) { /* Humidifier isn't on; no settling period * required as there is no compressor */ /* Safe to turn on humidifer */ iVals = HUMIDIFIER_RELAY_ID; ioctl(fdRelays, RELAY8_IOC_WRITE_RELAYS, &iVals); } } else { /* All relays should be off; humidity * is within target range */ iVals = 0; ioctl(fdRelays, RELAY8_IOC_WRITE_RELAYS, &iVals); } /* Accumulate some statistics */ if (uiHumidity > uiMaxHumidity) { uiMaxHumidity = uiHumidity; } if (uiHumidity < uiMinHumidity) { uiMinHumidity = uiHumidity; } uiAvgCumulativeHumidity += uiHumidity; uiAvgHumidity = uiAvgCumulativeHumidity / ++uiNumReadings; /* Display current status on the console if debugging */ printf("targetH=%d " "currentH=%d currentT=%d " "minH=%d maxH=%d avgH=%d\n", uiTargetHumidity, uiHumidity, uiTemperature, uiMinHumidity, uiMaxHumidity, uiAvgHumidity); /* One more reading, and if it reaches a value where * the previous might overrun for average calculations, * rescale to 1. The average across a sampling shouldn't * be substantially different than the next sampling. */ if (uiNumReadings == MAX_READINGS_BEFORE_RESCALE) { uiNumReadings = 1; uiAvgCumulativeHumidity = uiHumidity; } /* Now refresh the SNMP settings given what was just read. * The following permits checking the set values to ensure * the OIDs were really set (i.e. read back vals.txt and * compare it against what was set), but this isn't * done here. Settings can be checked on the web * interface values. */ sprintf(sTarget, "snmpset -Ovqe -v 1 -c private " "localhost currentHumidity.0 i %d", uiHumidity); system(sTarget); sprintf(sTarget, "snmpset -Ovqe -v 1 -c private " "localhost currentTemperature.0 i %d", uiTemperature); system(sTarget); sprintf(sTarget, "snmpset -Ovqe -v 1 -c private " "localhost minHumidity.0 i %d", uiMinHumidity); system(sTarget); sprintf(sTarget, "snmpset -Ovqe -v 1 -c private " "localhost maxHumidity.0 i %d", uiMaxHumidity); system(sTarget); sprintf(sTarget, "snmpset -Ovqe -v 1 -c private " "localhost avgHumidity.0 i %d", uiAvgHumidity); system(sTarget); } /* The previous loop will normally never exit, * but if it did, e.g. from testing, close the devices */ close(fdRelays); close(fdSht11); return(1); } 10534l8.txt0000664000175400017510000000052111272101046012066 0ustar jillljeditorListing 8. Perl Script setTargetHumidity use CGI; $query = new CGI; $targetH = $query->param('targetH'); $SNMP_SET_CMD = "snmpset -v 1 -c private"; $SNMP_TARGET = "localhost"; $SNMP_TARGETHUM_OID = "targetHumidity .0"; $SNMP_TYPE = "i"; chomp($retVal = `${SNMP_SET_CMD} ${SNMP_TARGET} $SNMP_TARGETHUM_OID $SNMP_TYPE $targetH`);