| Last Modified: | November 16, 2014, at 01:17 AM |
| Edited By: Polymath Universata | |
| Platform: | UNO (others not tested) |
//
// FILE: dht11_test1.pde
// PURPOSE: DHT11 library test sketch for Arduino
//
//Celsius to Fahrenheit conversion
double Fahrenheit(double celsius)
{
return 1.8 * celsius + 32;
}
// fast integer version with rounding
//int Celcius2Fahrenheit(int celcius)
//{
// return (celsius * 18 + 5)/10 + 32;
//}
//Celsius to Kelvin conversion
double Kelvin(double celsius)
{
return celsius + 273.15;
}
// dewPoint function NOAA
// reference (1) : http://wahiduddin.net/calc/density_algorithms.htm
// reference (2) : http://www.colorado.edu/geography/weather_station/Geog_site/about.htm
//
double dewPoint(double celsius, double humidity)
{
// (1) Saturation Vapor Pressure = ESGG(T)
double RATIO = 373.15 / (273.15 + celsius);
double RHS = -7.90298 * (RATIO - 1);
RHS += 5.02808 * log10(RATIO);
RHS += -1.3816e-7 * (pow(10, (11.344 * (1 - 1/RATIO ))) - 1) ;
RHS += 8.1328e-3 * (pow(10, (-3.49149 * (RATIO - 1))) - 1) ;
RHS += log10(1013.246);
// factor -3 is to adjust units - Vapor Pressure SVP * humidity
double VP = pow(10, RHS - 3) * humidity;
// (2) DEWPOINT = F(Vapor Pressure)
double T = log(VP/0.61078); // temp var
return (241.88 * T) / (17.558 - T);
}
// delta max = 0.6544 wrt dewPoint()
// 6.9 x faster than dewPoint()
// reference: http://en.wikipedia.org/wiki/Dew_point
double dewPointFast(double celsius, double humidity)
{
double a = 17.271;
double b = 237.7;
double temp = (a * celsius) / (b + celsius) + log(humidity*0.01);
double Td = (b * temp) / (a - temp);
return Td;
}
#include <dht11.h>
dht11 DHT11;
#define DHT11PIN 2
void setup()
{
Serial.begin(115200);
Serial.println("DHT11 TEST PROGRAM ");
Serial.print("LIBRARY VERSION: ");
Serial.println(DHT11LIB_VERSION);
Serial.println();
}
void loop()
{
Serial.println("\n");
int chk = DHT11.read(DHT11PIN);
Serial.print("Read sensor: ");
switch (chk)
{
case DHTLIB_OK:
Serial.println("OK");
break;
case DHTLIB_ERROR_CHECKSUM:
Serial.println("Checksum error");
break;
case DHTLIB_ERROR_TIMEOUT:
Serial.println("Time out error");
break;
default:
Serial.println("Unknown error");
break;
}
Serial.print("Humidity (%): ");
Serial.println((float)DHT11.humidity, 2);
Serial.print("Temperature (°C): ");
Serial.println((float)DHT11.temperature, 2);
Serial.print("Temperature (°F): ");
Serial.println(Fahrenheit(DHT11.temperature), 2);
Serial.print("Temperature (°K): ");
Serial.println(Kelvin(DHT11.temperature), 2);
Serial.print("Dew Point (°C): ");
Serial.println(dewPoint(DHT11.temperature, DHT11.humidity));
Serial.print("Dew PointFast (°C): ");
Serial.println(dewPointFast(DHT11.temperature, DHT11.humidity));
delay(2000);
}
//
// END OF FILE
//
In setup() The version string (a define) is displayed. This is for debugging purpose only.
//
// FILE: dht11.h
// VERSION: 0.4.1
// PURPOSE: DHT11 Temperature & Humidity Sensor library for Arduino
// LICENSE: GPL v3 (http://www.gnu.org/licenses/gpl.html)
//
// DATASHEET: http://www.micro4you.com/files/sensor/DHT11.pdf
//
// URL: http://playground.arduino.cc/Main/DHT11Lib
//
// HISTORY:
// George Hadjikyriacou - Original version
// see dht.cpp file
//
#ifndef dht11_h
#define dht11_h
#if defined(ARDUINO) && (ARDUINO >= 100)
#include <Arduino.h>
#else
#include <WProgram.h>
#endif
#define DHT11LIB_VERSION "0.4.1"
#define DHTLIB_OK 0
#define DHTLIB_ERROR_CHECKSUM -1
#define DHTLIB_ERROR_TIMEOUT -2
class dht11
{
public:
int read(int pin);
int humidity;
int temperature;
};
#endif
//
// END OF FILE
//
//
// FILE: dht11.cpp
// VERSION: 0.4.1
// PURPOSE: DHT11 Temperature & Humidity Sensor library for Arduino
// LICENSE: GPL v3 (http://www.gnu.org/licenses/gpl.html)
//
// DATASHEET: http://www.micro4you.com/files/sensor/DHT11.pdf
//
// HISTORY:
// George Hadjikyriacou - Original version (??)
// Mod by SimKard - Version 0.2 (24/11/2010)
// Mod by Rob Tillaart - Version 0.3 (28/03/2011)
// + added comments
// + removed all non DHT11 specific code
// + added references
// Mod by Rob Tillaart - Version 0.4 (17/03/2012)
// + added 1.0 support
// Mod by Rob Tillaart - Version 0.4.1 (19/05/2012)
// + added error codes
//
#include "dht11.h"
// Return values:
// DHTLIB_OK
// DHTLIB_ERROR_CHECKSUM
// DHTLIB_ERROR_TIMEOUT
int dht11::read(int pin)
{
// BUFFER TO RECEIVE
uint8_t bits[5];
uint8_t cnt = 7;
uint8_t idx = 0;
// EMPTY BUFFER
for (int i=0; i< 5; i++) bits[i] = 0;
// REQUEST SAMPLE
pinMode(pin, OUTPUT);
digitalWrite(pin, LOW);
delay(18);
digitalWrite(pin, HIGH);
delayMicroseconds(40);
pinMode(pin, INPUT);
// ACKNOWLEDGE or TIMEOUT
unsigned int loopCnt = 10000;
while(digitalRead(pin) == LOW)
if (loopCnt-- == 0) return DHTLIB_ERROR_TIMEOUT;
loopCnt = 10000;
while(digitalRead(pin) == HIGH)
if (loopCnt-- == 0) return DHTLIB_ERROR_TIMEOUT;
// READ OUTPUT - 40 BITS => 5 BYTES or TIMEOUT
for (int i=0; i<40; i++)
{
loopCnt = 10000;
while(digitalRead(pin) == LOW)
if (loopCnt-- == 0) return DHTLIB_ERROR_TIMEOUT;
unsigned long t = micros();
loopCnt = 10000;
while(digitalRead(pin) == HIGH)
if (loopCnt-- == 0) return DHTLIB_ERROR_TIMEOUT;
if ((micros() - t) > 40) bits[idx] |= (1 << cnt);
if (cnt == 0) // next byte?
{
cnt = 7; // restart at MSB
idx++; // next byte!
}
else cnt--;
}
// WRITE TO RIGHT VARS
// as bits[1] and bits[3] are allways zero they are omitted in formulas.
humidity = bits[0];
temperature = bits[2];
uint8_t sum = bits[0] + bits[2];
if (bits[4] != sum) return DHTLIB_ERROR_CHECKSUM;
return DHTLIB_OK;
}
//
// END OF FILE
//
A small testprogram to compare the dewPoint algorithms
//
// FILE: test_dewPoint.pde
// VERSION: 0.1.01
// PURPOSE: test dewpoint
//
// HISTORY:
// 2011-05-01 first version
// 2013-08-04 updated
//
#include <dewpoint.h> // make a .h file of the dewpoint functions above or copy them here instead
void setup()
{
Serial.begin(115200);
double f;
double x;
unsigned long b = millis();
for (int i=0; i<1000; i++)
{
x = dewPoint(10,50);
}
unsigned long e = millis();
Serial.println(x, 4);
Serial.println(e-b);
f = e-b;
b = millis();
for (int i=0; i<1000; i++)
{
x = dewPointFast(10,50);
}
e = millis();
Serial.println(x, 4);
Serial.println(e-b);
f /= (e-b);
Serial.print("Factor: ");
Serial.println(f);
double m = 0;
for (int t = -30; t < 70; t++)
{
for (int h = 0; h < 100; h++)
{
double x = dewPoint(t, h);
double y = dewPointFast(t, h);
m = max(abs(x-y), m);
if (m > 0.5)
{
Serial.print(t);
Serial.print("\t");
Serial.println(h);
}
}
Serial.print(".");
}
Serial.println();
Serial.print("max: ");
Serial.println(m);
Serial.println("done");
}
void loop()
{
}
KERNEL=="ttyACM0", SYMLINK+="ttyS7"
?json=1 to the URL, the page returns the temperature and humidity in JSON format:
 |
 Completed motor |
 Most of the bits for my first Floppy Drive motor |
 Motor on Speedy Bee |
 Experimetal winding |
 Speed 400 can motor |
 Home-made bell with 2mm magnets vs Speed 400 can |
 'Empty' core plus completed motor |
 How the winding starts |
 Main components with a couple of test cans |
 Some of the magnet options tried |
This article will concentrate on the following aspects of BLDC motor design:
- Construction of the BLDC motor
- Operation of the BLDC motor
- Torque and Efficiency requirements
- Comparison with Induction and Brushed DC motors
- Selection criteria for a BLDC motor
- Motor control – Speed, Position and Torque, to be covered in Part II of this article.
ConstructionBLDC motors have many similarities to AC induction motors and brushed DC motors in terms of construction and working principles respectively. Like all other motors, BLDC motors also have a rotor and a stator. Stator
Similar to an Induction AC motor, the BLDC motor stator is made out of laminated steel stacked up to carry the windings. Windings in a stator can be arranged in two patterns; i.e. a star pattern (Y) or delta pattern (∆). The major difference between the two patterns is that the Y pattern gives high torque at low RPM and the ∆ pattern gives low torque at low RPM. This is because in the ∆ configuration, half of the voltage is applied across the winding that is not driven, thus increasing losses and, in turn, efficiency and torque.
Rotor
The rotor of a typical BLDC motor is made out of permanent magnets. Depending upon the application requirements, the number of poles in the rotor may vary. Increasing the number of poles does give better torque but at the cost of reducing the maximum possible speed.
Working Principles and Operation
The underlying principles for the working of a BLDC motor are the same as for a brushed DC motor; i.e., internal shaft position feedback. In case of a brushed DC motor, feedback is implemented using a mechanical commutator and brushes. With a in BLDC motor, it is achieved using multiple feedback sensors. The most commonly used sensors are hall sensors and optical encoders.
Note: Hall sensors work on the hall-effect principle that when a current-carrying conductor is exposed to the magnetic field, charge carriers experience a force based on the voltage developed across the two sides of the conductor.
If the direction of the magnetic field is reversed, the voltage developed will reverse as well. For Hall-effect sensors used in BLDC motors, whenever rotor magnetic poles (N or S) pass near the hall sensor, they generate a HIGH or LOW level signal, which can be used to determine the position of the shaft.
In a commutation system – one that is based on the position of the motor identified using feedback sensors – two of the three electrical windings are energized at a time as shown in figure 4.
In figure 4 (A), the GREEN winding labeled “001” is energized as the NORTH pole and the BLUE winding labeled as “010” is energized as the SOUTH pole. Because of this excitation, the SOUTH pole of the rotor aligns with the GREEN winding and the NORTH pole aligns with the RED winding labeled “100”. In order to move the rotor, the “RED” and “BLUE” windings are energized in the direction shown in figure 4(B). This causes the RED winding to become the NORTH pole and the BLUE winding to become the SOUTH pole. This shifting of the magnetic field in the stator produces torque because of the development of repulsion (Red winding – NORTH-NORTH alignment) and attraction forces (BLUE winding – NORTH-SOUTH alignment), which moves the rotor in the clockwise direction.