PHPoC Blue, Thingspeak, Temperature and Humidity Sensor

PHPoC Blue, Thingspeak, Temperature and Humidity Sensor

Postby Khanh » Thu Jun 23, 2016 4:22 pm

PHPoC Blue, Thingspeak, Temperature and Humidity Sensor (TH02, HDC1000, HTS221)

This project shows how PHPoC Blue reads data from Temperature and Humidity sensor and then send these values to ThingSpeak.

ThingSpeak is the open platform for Internet of Thing. You can store your data on Thingspeak storage, analyze, visualize… data. For more detail, visit https://thingspeak.com/

Demo

My channel with two fields: temperature and humidity.
phpBB [video]


Things we need:

    - PHPoC Blue
    - Temperature and Humidity sensor (one of three: TH02, HDC1000, HTS221).
    - USB wireless LAN dongle.
    - Grove expansion board for PHPoC (Optional).
    - Expansion board for Click boards (optional).
things.jpg
things.jpg (125.79 KiB) Viewed 2619 times


Steps:


Now let’s look at PHPoC source code. Source code includes:

    - vn_thingspeak.php: update/get data to/from your channel.
    - vd_th02.php: library for TH02 temp&humi sensor.
    - vd_hdc1000.php: library for HDC1000 temp&humi sensor.
    - vd_hts221.php: library for HTS221 temp&humi sensor.
    - task0.php: main program.

You can see one by one below:

<task0.php>

Code: Select all

<?php

if(_SERVER("REQUEST_METHOD"))
    exit; // avoid php execution via http request
 
include_once 
"/lib/sd_340.php";
include_once "/lib/sn_dns.php";
include_once "/lib/sn_http.php";
include_once "/lib/vn_thingspeak.php";
include_once "/lib/vd_th02.php";
include_once "/lib/vd_hdc1000.php";
include_once "/lib/vd_hts221.php";

define("TH02",        0); // grove Temperature&Humidity Sensor (High-Accuracy & Mini) V1.0 
define("HDC1000",    1); // grove Temperature&Humidity Sensor (HDC1000)
define("HTS221",    2); // mikro click

$my_write_api_key = "your write api key";
$my_read_api_key = "your read api key";
$my_channel_id = "your channed id";

$sensor_type = TH02; // choose sensor type here

switch($sensor_type)
{
    case TH02:
        i2c_TH02_setup(0);
        break;
    case HDC1000:
        i2c_HDC1000_setup(0);
        break;
    case HTS221:
        i2c_HTS221_setup(0);
        while(!HTS221_init())
        ;
        break;
    default:
        exit "library is not yet available for this sensor\r\n";
}

while(
1)
{
    
    switch
($sensor_type)
    {    
        case TH02
:
            $temp = TH02_read_temperature();            
            $humi 
= TH02_read_humidity();
            break;
            
        case HDC1000
:
            $temp = HDC1000_read_temperature();            
            $humi 
= HDC1000_read_humidity();
            break;
            
        case HTS221
:
            $temp = HTS221_read_temperature();    
            
            if
(is_bool($temp))
            {
                echo "a new temperature sample is not yet available\r\n";
                usleep(500000);
                continue;
            }
            
            usleep
(1000);
            
            $humi 
= HTS221_read_humidity();
            if(is_bool($humi))
            {
                echo "a new humidity sample is not yet available\r\n";
                usleep(500000);
                continue;
            }
    }
    
    thingspeak_set_field
(1, $temp);
    thingspeak_set_field(2, $humi);
    $reval = thingspeak_write_fields($my_channel_id, $my_write_api_key); 
    
    if
( $reval === OK_SUCCESS)
        echo "write successfully\r\n";
    else 
        echo 
"write unsuccessfully\r\n";
    
    
// maximum update rate of thingspeak is 15 second
    sleep(15);
    
}
 
?>



<vn_thingspeak.php >

Code: Select all

<?php

define
("THINGSPEAK_URL", "api.thingspeak.com");

define("FIELDNUM_MIN",        1);
define("FIELDNUM_MAX",        8);
define("FIELDLENGTH_MAX",    255);  // Max length for a field in ThingSpeak is 255 bytes (UTF-8)

define("OK_SUCCESS",                 200); // OK / Success
define("ERR_BADAPIKEY",                 400); // Incorrect API key (or invalid ThingSpeak server address)
define("ERR_BADURL",                 404); // Incorrect API key (or invalid ThingSpeak server address)
define("ERR_OUT_OF_RANGE",            -101); // Value is out of range or string is too long (> 255 bytes)
define("ERR_INVALID_FIELD_NUM",        -201); // Invalid field number specified
define("ERR_SET_FIELD_NOT_CALLED",    -210); // thingspeak_set_field() was not called before thingspeak_write_fields()
define("ERR_CONNECT_FAILED",        -301); // Failed to connect to ThingSpeak
define("ERR_UNEXPECTED_FAIL",        -302); // Unexpected failure during write to ThingSpeak
define("ERR_BAD_RESPONSE",            -303); // Unable to parse response
define("ERR_TIMEOUT",                -304); // Timeout waiting for server to respond
define("ERR_NOT_INSERTED",            -401); // Point was not inserted (most probable cause is the rate limit of once every 15 seconds)

$next_write_fields = array("", "", "", "", "", "", "", "");
$next_write_latitude = "";
$next_write_longitude = "";
$next_write_elevation = "";
$next_write_status = "";
$next_write_twitter = "";
$next_write_tweet = "";
$next_write_created_at = "";

function json_get_value($json_str, $key, &$value, $offset = 0)
{
    $value = "";
    
    if
(strlen($json_str) == 0)
        return false;
    
    $search 
= "\"" . $key . "\":";
    
    $from_pos 
= strpos($json_str, $search, $offset);
    
    if
($from_pos === false)
        return false;
    
    $from_pos 
+= strlen($search);
    
    while
($json_str[$from_pos] == " ")
        $from_pos++;
    
    $to_pos 
= $from_pos;
    $start_char = $json_str[$from_pos];
    
    if
($start_char == "[" || $start_char == "{")
    {
        if($start_char == "[")
            $end_char = "]";
        else
            $end_char 
= "}";
        
        $start_count 
= 0;
        $end_count = 0;
        
        for
($i = $from_pos; $i < strlen($json_str); $i++)
        {
            if($json_str[$i] == $start_char)
                $start_count++;
            if($json_str[$i] == $end_char)
                $end_count++;
            
            if
($end_count == $start_count)
            {
                $to_pos = $i;
                break;
            }
        }
    }
    else
    
{
        $pos1 = strpos($json_str, ",", $from_pos);
        $pos2 = strpos($json_str, "}", $from_pos);
        
        if
($pos1 === false)
            $to_pos = $pos2;
        else if($pos2 === false)
            $to_pos = $pos1;
        else 
            $to_pos 
= ($pos1 > $pos2) ? $pos2: $pos1;
        
        $to_pos
--;
    }
    
    if
($to_pos === false)
        return false;
    
    $length 
= $to_pos - $from_pos + 1;
    
    $value 
= substr($json_str, $from_pos, $length);
    $value = rtrim(ltrim($value, "\""), "\"");
    
    return $to_pos
;
}

function thingspeak_setup($udp_id, $tcp_id, $dns_server = "", $ip6 = false)
{
    http_setup($udp_id, $tcp_id, $dns_server, $ip6);
}

/**
*@brief: Write a raw POST to a ThingSpeak channel
*@param: $channel_id: Channel number
*@param: $post_msg: Raw URL to write to ThingSpeak as a String.  See the documentation at https://thingspeak.com/docs/channels#update_feed.
*@param: $write_api_key: Write API key associated with the channel. If you share code with others, do  not share this key
*@return: status code.
*@remark: This is low level functionality that will not be required by most users.
*@example code:
    $post_msg = "field1=23&created_at=2017-03-23T23:59:59";
    thingspeak_write_raw($my_channel_id, $post_msg, $my_write_api_key);
*/
function thingspeak_write_raw($channel_id, $post_msg, $write_api_key)
{
    $post_msg .= "&headers=false\n";
    $cnt_len = strlen($post_msg);
    
    http_add_header
("Content-Type: application/x-www-form-urlencoded\r\n");
    http_add_header("Content-Length: $cnt_len\r\n");
    http_add_header("X-THINGSPEAKAPIKEY: $write_api_key\r\n");
    
    $rsp_head 
= http_request("post", THINGSPEAK_URL . "/update", $post_msg);
    
    
//echo $rsp_head;
    
    if
($rsp_head === "")
        return ERR_CONNECT_FAILED;
    
    $status 
= http_status($rsp_head);
    
    $rsp_body 
= "";
    $rbuf = "";
    
    while
(http_recv($rbuf))
        $rsp_body .= $rbuf;
    
    http_close
();
    
    if
($status == OK_SUCCESS)
    {
        $entry_id = (int)$rsp_body;
        
        if
($entry_id == 0)
        {
            // ThingSpeak did not accept the write
            $status = ERR_NOT_INSERTED;
        }
    }
    
    return $status
;
}

/**
*@brief: Read a raw response from a ThingSpeak channel
*@param: $rsp_body: buffer to store the http body
*@param: $channel_id: Channel number
*@param: $url_suffix: Raw URL to write to ThingSpeak as a String.  See the documentation at https://thingspeak.com/docs/channels#get_feed
*@param: $read_api_key: Read API key associated with the channel. Igrore this param if reading a public channel. If you share code with others, do  not share this key
*@return: status code.
*@remark: This is low level functionality that will not be required by most users.
*@example code:
    $response = "";
    thingspeak_read_raw($response, $my_channel_id, "/feeds/last.txt", $my_read_api_key);
    echo $response;
*/
function thingspeak_read_raw(&$rsp_body, $channel_id, $url_suffix, $read_api_key = "")
{
    $rsp_body = "";
    $uri = THINGSPEAK_URL . "/channels/$channel_id" . $url_suffix;
    
    http_add_header
("X-THINGSPEAKAPIKEY: $read_api_key\r\n");
    
    $rsp_head 
= http_request("get", $uri);
    
    
//echo $rsp_head;
    
    if
($rsp_head === "")
        return ERR_CONNECT_FAILED;
    
    $status 
= http_status($rsp_head);
    
    $rbuf 
= "";
    
    while
(http_recv($rbuf))
        $rsp_body .= $rbuf;
    
    http_close
();
    
    if
($status != OK_SUCCESS)
    {
        $rsp_body = "";
    }
    
    return $status
;
}

/**
*@brief: Write data (any type) to a single field in a ThingSpeak channel
*@param: $channel_id: Channel number
*@param: $field: Field number (1-8) within the channel to write to.
*@param: $value: Value to write (any type).  ThingSpeak limits this field to 255 bytes. 
*@param: $write_api_key: Write API key associated with the channel. If you share code with others, do  not share this key
*@return: status code.
*@remark: Visit https://thingspeak.com/docs/channels for more information about channels, API keys, and fields.  ThingSpeak limits the number of writes to a channel to once every 15 seconds.
*@example code:
    thingspeak_write_field($my_channel_id, 1, 25, $my_write_api_key);
    thingspeak_write_field($my_channel_id, 3, "Too Hot!", $my_write_api_key);
*/
function thingspeak_write_field($channel_id, $field, $value, $write_api_key)
{
    $post_msg = "field$field=$value";
    return thingspeak_write_raw($channel_id, $post_msg, $write_api_key);
}

/**
*@brief: Set the value of a single field that will be part of a multi-field update. To write multiple fields at once, call thingspeak_set_field() for each of the fields you want to write, and then call thingspeak_write_fields()
*@param: $field: Field number (1-8) within the channel to set
*@param: $value: value to write (any type).  ThingSpeak limits this to 255 bytes.
*@return: status code.
*@example code:
    thingspeak_set_field(1, 1.2);
    thingspeak_set_field(2, 15);
    thingspeak_set_field(3, "state ON");
    thingspeak_write_fields($my_channel_id, $my_write_api_key);
*/
function thingspeak_set_field($field, $value)
{
    global $next_write_fields;
    
    $str_value 
= "$value";
    
    if
($field < FIELDNUM_MIN || $field > FIELDNUM_MAX) 
        return ERR_INVALID_FIELD_NUM
;
    
    
// Max # bytes for ThingSpeak field is 255 (UTF-8)
    if(strlen($str_value) > FIELDLENGTH_MAX) 
        return ERR_OUT_OF_RANGE
;
    
    $next_write_fields
[$field - 1] = $str_value;
    
    return OK_SUCCESS
;
}

/**
*@brief: Set the latitude of a multi-field update. To record latitude, longitude and elevation of a write, call thingspeak_set_field() for each of the fields you want to write, thingspeak_set_latitude() / thingspeak_set_longitude() / thingspeak_set_elevation(), and then call thingspeak_write_fields()
*@param: $latitude: Latitude of the measurement (degrees N, use negative values for degrees S)
*@return: status code.
*@see thingspeak_set_field(), thingspeak_set_longitude(), thingspeak_set_elevation(), thingspeak_write_fields()
*@example code:
    thingspeak_set_field(1, 1.2);
    thingspeak_set_field(2, 15);
    thingspeak_set_field(3, "state ON");
    thingspeak_set_latitude(42.2833);
    thingspeak_set_longitude(-71.3500);
    thingspeak_set_elevation(100);
    thingspeak_write_fields($my_channel_id, $my_write_api_key);
*/
function thingspeak_set_latitude($latitude)
{
    global $next_write_latitude;
    
    $next_write_latitude 
= "$latitude";
    return OK_SUCCESS;
}

/**
*@brief: Set the longitude of a multi-field update. To record latitude, longitude and elevation of a write, call thingspeak_set_field() for each of the fields you want to write, thingspeak_set_latitude() / thingspeak_set_longitude() / thingspeak_set_elevation(), and then call thingspeak_write_fields()
*@param: $longitude: Longitude of the measurement (degrees E, use negative values for degrees W)
*@return: status code.
*@see thingspeak_set_field(), thingspeak_set_latitude(), thingspeak_set_elevation(), thingspeak_write_fields()
*@example code:
    thingspeak_set_field(1, 1.2);
    thingspeak_set_field(2, 15);
    thingspeak_set_field(3, "state ON");
    thingspeak_set_latitude(42.2833);
    thingspeak_set_longitude(-71.3500);
    thingspeak_set_elevation(100);
    thingspeak_write_fields($my_channel_id, $my_write_api_key);
*/
function thingspeak_set_longitude($longitude)
{
    global $next_write_longitude;
    
    $next_write_longitude 
= "$longitude";
    return OK_SUCCESS;
}

/**
*@brief: Set the elevation of a multi-field update. To record latitude, longitude and elevation of a write, call thingspeak_set_field() for each of the fields you want to write, thingspeak_set_latitude() / thingspeak_set_longitude() / thingspeak_set_elevation(), and then call thingspeak_write_fields()
*@param: $elevation: Elevation of the measurement (meters above sea level)
*@return: status code.
*@see thingspeak_set_field(), thingspeak_set_latitude(), thingspeak_set_longitude(), thingspeak_write_fields()
*@example code:
    thingspeak_set_field(1, 1.2);
    thingspeak_set_field(2, 15);
    thingspeak_set_field(3, "state ON");
    thingspeak_set_latitude(42.2833);
    thingspeak_set_longitude(-71.3500);
    thingspeak_set_elevation(100);
    thingspeak_write_fields($my_channel_id, $my_write_api_key);
*/
function thingspeak_set_elevation($elevation)
{
    global $next_write_elevation;
    
    $next_write_elevation 
= "$elevation";
    return OK_SUCCESS;
}

/**
*@brief: Set the status of a multi-field update. To record a status message on a write, call thingspeak_set_status() then call thingspeak_write_fields(). Use status to provide additonal details when writing a channel update.
*@param: $status: String to write (UTF8).  ThingSpeak limits this to 255 bytes.
*@return: status code.
*@see thingspeak_write_fields()
*@example code:
    thingspeak_set_field(1, 1.2);
    thingspeak_set_field(2, 15);
    thingspeak_set_field(3, "state ON");
    thingspeak_set_status("Too Cold!");
    thingspeak_write_fields($my_channel_id, $my_write_api_key);
*/
function thingspeak_set_status($status)
{
    global $next_write_status;
    
    
// Max # bytes for ThingSpeak field is 255 (UTF-8)
    if(strlen($status) > FIELDLENGTH_MAX) 
        return ERR_OUT_OF_RANGE
;
    
    $next_write_status 
= $status;
    return OK_SUCCESS;
}

/**
*@brief: Set the Twitter account and message to use for an update to be tweeted. To send a message to twitter call thingspeak_set_twitter_tweet() then call thingspeak_write_fields()
*@param: $twitter: Twitter account name as a String.
*@param: $tweet: Twitter message as a String (UTF-8) limited to 140 character.
*@return: status code.
*@remark: Prior to using this feature, a twitter account must be linked to your ThingSpeak account. Do this by logging into ThingSpeak and going to Apps, then ThingTweet and clicking Link Twitter Account.
*@see thingspeak_write_fields()
*@example code:
    thingspeak_set_field(1, 1.2);
    thingspeak_set_field(2, 15);
    thingspeak_set_field(3, "state ON");
    thingspeak_set_status("Too Cold!");
    thingspeak_set_twitter_tweet("YourTwitterAccountName", "Too Hot!");
    thingspeak_write_fields($my_channel_id, $my_write_api_key);
*/
function thingspeak_set_twitter_tweet($twitter, $tweet)
{
    global $next_write_twitter;
    global $next_write_tweet;
    
    if
((strlen($twitter) > FIELDLENGTH_MAX) || (strlen($tweet) > FIELDLENGTH_MAX)) 
        return ERR_OUT_OF_RANGE
;
    
    $next_write_twitter 
= $twitter;
    $next_write_tweet = $tweet;
    return OK_SUCCESS;
}

/**
*@brief: Set the created-at date of a multi-field update. To record created-at of a write, call thingspeak_set_field() for each of the fields you want to write, thingspeak_set_created_at(), and then call thingspeak_write_fields()
*@param: $created_at Desired timestamp to be included with the channel update as a String.  The timestamp string must be in the ISO 8601 format. Example "2017-03-23T13:59:59"
*@return: status code.
*@remark: Timezones can be set using the timezone hour offset parameter. For example, a timestamp for Eastern Standard Time is: "2017-01-12 13:22:54-05".  If no timezone hour offset parameter is used, UTC time is assumed.
*@see thingspeak_set_field(), thingspeak_write_fields()
*@example code:
    thingspeak_set_field(1, 1.2);
    thingspeak_set_field(2, 15);
    thingspeak_set_field(3, "state ON");
    thingspeak_set_status("Too Cold!");
    thingspeak_set_created_at("2017-03-23T13:59:59");
    thingspeak_write_fields($my_channel_id, $my_write_api_key);
*/
function thingspeak_set_created_at($created_at)
{
    global $next_write_created_at;
    
    $next_write_created_at 
= $created_at;
    
    return OK_SUCCESS
;
}

/**
*@brief: Write a multi-field update. Call thingspeak_set_field() for each of the fields you want to write, thingspeak_set_latitude() / thingspeak_set_longitude() / thingspeak_set_elevation(), and then call thingspeak_write_fields()
*@param: $channel_id: Channel number
*@param: $write_api_key: Write API key associated with the channel. If you share code with others, do  not share this key
*@return: status code.
*@see thingspeak_set_field(), thingspeak_set_latitude(), thingspeak_set_longitude(), thingspeak_set_elevation()
*@example code:
    thingspeak_set_field(1, 1.2);
    thingspeak_set_field(2, 15);
    thingspeak_set_field(3, "state ON");
    thingspeak_set_latitude(42.2833);
    thingspeak_set_longitude(-71.3500);
    thingspeak_set_elevation(100);
    thingspeak_write_fields($my_channel_id, $my_write_api_key);
*/
function thingspeak_write_fields($channel_id, $write_api_key)
{
    global $next_write_fields;
    global $next_write_latitude;
    global $next_write_longitude;
    global $next_write_elevation;
    global $next_write_status;
    global $next_write_twitter;
    global $next_write_tweet;
    global $next_write_created_at;
    
    $post_msg 
= "";
    
    $is_first_item 
= true;
    
    for
($i = 0; $i < 8; $i++)
    {
        if($next_write_fields[$i] != "")
        {
            if(!$is_first_item)
            {
                $post_msg .= "&";
            }
            $field = $i + 1;
            $post_msg .= "field$field=" . $next_write_fields[$i];
            $is_first_item = false;
            $next_write_fields[$i] = "";
        }
    }

    if($next_write_latitude != "")
    {
        if(!$is_first_item)
        {
            $post_msg .= "&";
        }
        $post_msg .= "lat=" . $next_write_latitude;
        $is_first_item = false;
        $next_write_latitude = "";
    }

    if($next_write_longitude != "")
    {
        if(!$is_first_item)
        {
            $post_msg .= "&";
        }
        $post_msg .= "long=" . $next_write_longitude;
        $is_first_item = false;
        $next_write_longitude = "";
    }


    if($next_write_elevation != "")
    {
        if(!$is_first_item)
        {
            $post_msg .= "&";
        }
        $post_msg .= "elevation=" . $next_write_elevation;
        $is_first_item = false;
        $next_write_elevation = "";
    }
    
    if
($next_write_status != "")
    {
        if(!$is_first_item)
        {
            $post_msg .= "&";
        }
        $post_msg .= "status=" . $next_write_status;
        $is_first_item = false;
        $next_write_status = "";
    }
    
    if
($next_write_twitter != "")
    {
        if(!$is_first_item)
        {
            $post_msg .= "&";
        }
        $post_msg .= "twitter=" . $next_write_twitter;
        $is_first_item = false;
        $next_write_twitter = "";
    }
    
    if
($next_write_tweet != "")
    {
        if(!$is_first_item)
        {
            $post_msg .= "&";
        }
        $post_msg .= "tweet=" . $next_write_tweet;
        $is_first_item = false;
        $next_write_tweet = "";
    }
    
    if
($next_write_created_at != "")
    {
        if(!$is_first_item)
        {
            $post_msg .= "&";
        }
        $post_msg .= "created_at=" . $next_write_created_at;
        $is_first_item = false;
        $next_write_created_at = "";
    }
    
    
    if
($is_first_item)
    {
        // thingspeak_set_field() was not called before write_fields
        return ERR_SET_FIELD_NOT_CALLED;
    }

    return thingspeak_write_raw($channel_id, $post_msg, $write_api_key);
}

/**
*@brief: Read the latest field value from a ThingSpeak channel
*@param: $buf: buffer to store the field value
*@param: $channel_id: Channel number
*@param: $field: Field number (1-8) within the channel to read from.
*@param: $read_api_key: Read API key associated with the channel. Igrore this param if reading a public channel. If you share code with others, do  not share this key
*@return: status code.
*@example code:
    $value = "";
    $status = thingspeak_read_field($value, $my_channel_id, 1, $my_read_api_key);
    echo "status: $status\r\n";
    echo "value: $value\r\n";
*/
function thingspeak_read_field(&$buf, $channel_id, $field, $read_api_key = "")
{
    if($field < FIELDNUM_MIN || $field > FIELDNUM_MAX) 
        return ERR_INVALID_FIELD_NUM
;
    
    return thingspeak_read_raw
($buf, $channel_id, "/fields/$field/last", $read_api_key);
}

/**
*@brief: Read the latest status from a ThingSpeak channel
*@param: $channel_id: Channel number
*@param: $read_api_key: Read API key associated with the channel. Igrore this param if reading a public channel. If you share code with others, do  not share this key
*@return: Value read (UTF8 string). An empty string is returned if there was no status written to the channel or in case of an error.  Use getLastthingspeak_read_status() to get more specific information.
*@example code:
    $status  = thingspeak_read_status($my_channel_id, $my_read_api_key);
    echo "Latest status is: $status"; 
*/
function thingspeak_read_status($channel_id, $read_api_key = "")
{
    $buf = "";
    
    $ret 
= thingspeak_read_raw($buf, $channel_id, "/feeds/last.txt?status=true", $read_api_key);
    
    $status 
= "";
    
    if
($ret == OK_SUCCESS)
        json_get_value($buf, "status", $status);
    
    return $status
;
}

/**
*@brief: Read the created-at timestamp associated with the latest update to a ThingSpeak channel
*@param: $channel_id: Channel number
*@param: $read_api_key: Read API key associated with the channel. Igrore this param if reading a public channel. If you share code with others, do  not share this key
*@return: Value read (UTF8 string). An empty string is returned if there was no created-at timestamp written to the channel or in case of an error.  Use getLastthingspeak_read_status() to get more specific information.
*@example code:
    $created_at = thingspeak_read_created_at($my_channel_id, $my_read_api_key);
    echo "Latest update timestamp is: $created_at"; 
*/
function thingspeak_read_created_at($channel_id, $read_api_key = "")
{
    $buf = "";
    
    $ret 
= thingspeak_read_raw($buf, $channel_id, "/feeds/last.txt", $read_api_key);
    
    $created_at 
= "";
    
    if
($ret == OK_SUCCESS)
        json_get_value($buf, "created_at", $created_at);
    
    return $created_at
;
}

?>



<vd_th02.php>

Code: Select all

<?php

include_once 
"/lib/sd_340.php";

define("TH02_ADDR", 0x40);

define("REG_STATUS",       0x00); 
define
("REG_DATA_H",       0x01);
define("REG_DATA_L",       0x02);
define("REG_CONFIG",       0x03);
define("REG_ID",           0x11);

define("STATUS_RDY_MASK",  0x01);    //poll RDY,0 indicate the conversion is done

define("CMD_MEASURE_HUMI", 0x01);    //perform a humility measurement
define("CMD_MEASURE_TEMP", 0x11);    //perform a temperature measurement

define("TH02_WR_REG_MODE", 0xC0);
define("TH02_RD_REG_MODE", 0x80);

$pid = 0;

function i2c_TH02_setup($i2c_id)
{
    global $pid ;
    
    $sensor_addr 
= sprintf("%02x", TH02_ADDR << 1);
    
    $pid 
= pid_open("/mmap/i2c$i2c_id");
    pid_ioctl($pid, "req reset");
    pid_ioctl($pid, "set saddr $sensor_addr");
    pid_ioctl($pid, "set mode sm");
    pid_ioctl($pid, "set role master");
}

// Generic I2C write $data to register (single byte)
function TH02_write8($addr_reg, $data)
{
    global $pid ;
    
    pid_ioctl
($pid, "req reset");
    pid_ioctl($pid, "req write wait");
    //register to read
    pid_write($pid, $addr_reg, 1); 
    pid_write
($pid, $data, 1); 
    
    pid_ioctl
($pid, "req stop"); // stop writing data
}

// Generic I2C read registers (two bytes, LSB first)
function TH02_read16($addr_reg)
{
    global $pid ;
    
    $data_lsb 
= 0x00;
    $data_msb = 0x00;
    
    pid_ioctl
($pid, "req reset");
    pid_ioctl($pid, "req write wait");
    // register to read
    pid_write($pid, $addr_reg, 1); 
    
    pid_ioctl
($pid, "req stop"); // stop writing data
    
    pid_ioctl
($pid, "req read 2"); // request to read 2 bytes
    while(pid_ioctl($pid, "get rxlen") < 2); // check received data
    
    pid_read
($pid, $data_lsb, 1); // read buffer
    pid_read($pid, $data_msb, 1); // read buffer    
    
    return 
($data_lsb | ($data_msb << 8));
}

function TH02_read_temperature()
{
    TH02_write8(REG_CONFIG, CMD_MEASURE_TEMP);
    
    usleep
(50000);
    
    $value 
= TH02_read16(REG_DATA_H);
    $value = (float)($value >> 2);
    /* 
      Formula:
      Temperature(C) = (Value/32) - 50      
    */
    
    $temper 
= ($value/32.0)-50.0;
    return $temper;
}

function TH02_read_humidity()
{
    TH02_write8(REG_CONFIG, CMD_MEASURE_HUMI);
    
    usleep
(50000);
    
    $value 
= TH02_read16(REG_DATA_H);
    $value = (float)($value >> 4);
 
    
/* 
      Formula:
      Humidity(%) = (Value/16) - 24      
    */
    

    $humility 
= ($value/16.0)-24.0;
    
    return $humility
;
}

?>


<vd_hdc1000.php>

Code: Select all

<?php

include_once 
"/lib/sd_340.php";

define("HDC1000_ADDR",                0x40);

define("HDC1000_TEMP",                0x00);
define("HDC1000_HUMI",                0x01);
define("HDC1000_CONFIG",            0x02);

define("HDC1000_SERID_1",            0xFB);
define("HDC1000_SERID_2",            0xFC);
define("HDC1000_SERID_3",            0xFD);
define("HDC1000_MFID",                0xFE);
define("HDC1000_DEVID",                0xFF);

define("HDC1000_RST",                0x80);
define("HDC1000_HEAT_ON",            0x20);
define("HDC1000_HEAT_OFF",            0x00);
define("HDC1000_BOTH_TEMP_HUMI",    0x10);
define("HDC1000_SINGLE_MEASUR",        0x00);
define("HDC1000_TEMP_HUMI_14BIT",    0x00);
define("HDC1000_TEMP_11BIT",        0x40);
define("HDC1000_HUMI_11BIT",        0x01);
define("HDC1000_HUMI_8BIT",            0x02);

$pid = 0;

function i2c_HDC1000_setup($i2c_id)
{
    global $pid ;
    
    $sensor_addr 
= sprintf("%02x", HDC1000_ADDR << 1);
    
    $pid 
= pid_open("/mmap/i2c$i2c_id");
    pid_ioctl($pid, "req reset");
    pid_ioctl($pid, "set saddr $sensor_addr");
    pid_ioctl($pid, "set mode sm");
    pid_ioctl($pid, "set role master");
}

// Generic I2C read registers (two bytes, LSB first)
function HDC1000_read16($addr_reg)
{
    global $pid ;
    
    $data_lsb 
= 0x00;
    $data_msb = 0x00;
    
    pid_ioctl
($pid, "req reset");
    pid_ioctl($pid, "req write wait");
    // register to read
    pid_write($pid, $addr_reg, 1); 
    
    pid_ioctl
($pid, "req stop"); // stop writing data
    usleep(20000);    
    pid_ioctl
($pid, "req read 2"); // request to read 2 bytes
    while(pid_ioctl($pid, "get rxlen") < 2); // check received data
    
    pid_read
($pid, $data_msb, 1); // read buffer
    pid_read($pid, $data_lsb, 1); // read buffer
            
    return 
($data_lsb | ($data_msb << 8));
}

// Generic I2C write $data to registers (two bytes, LSB first)
function HDC1000_write16($addr_reg, $data)
{
        
    global $pid 
;
    
    $data_lsb 
= $data & 0xff;
    $data_msb = $data >> 8;
    
    pid_ioctl
($pid, "req reset");
    pid_ioctl($pid, "req write wait");
    //register to read
    pid_write($pid, $addr_reg, 1); 
    pid_write
($pid, $data_lsb, 1); 
    pid_write
($pid, $data_msb, 1); 
    while
(pid_ioctl($pid, "get txlen")); // check received data
    
    pid_ioctl
($pid, "req stop"); // stop writing data
}

function HDC1000_read_temperature()
{
    
    $temp 
= HDC1000_read16(HDC1000_TEMP);

    return $temp/65536.0*165.0-40.0;
}

function HDC1000_read_humidity()
{
    
    $humi 
= HDC1000_read16(HDC1000_HUMI);
         
    return $humi
/65536.0*100.0;
}

?>


< vd_hts221.php >

Code: Select all

<?php

include_once 
"/lib/sd_340.php";

define("HTS221_ADDR",        0x5F);

//Define a few of the registers that we will be accessing on the HTS221
define("WHO_AM_I",           0x0F);
define("WHO_AM_I_RETURN",    0xBC); //This read-only register contains the device identifier, set to BCh

define("AVERAGE_REG",        0x10); // To configure humidity/temperature average.
define("AVERAGE_DEFAULT",    0x1B);

define("CTRL_REG1",          0x20);
define("POWER_UP",           0x80);
define("BDU_SET",            0x4);
define("ODR0_SET",           0x1);   // setting sensor reading period 1Hz

define("CTRL_REG2",          0x21);
define("CTRL_REG3",          0x22);
define("REG_DEFAULT",        0x00);

define("STATUS_REG",         0x27);
define("TEMPERATURE_READY",  0x1);
define("HUMIDITY_READY",     0x2);

define("HUMIDITY_L_REG",     0x28);
define("HUMIDITY_H_REG",     0x29);
define("TEMP_L_REG",         0x2A);
define("TEMP_H_REG",         0x2B);

define("CALIB_START",        0x30);
define("CALIB_END",           0x3F);

/*
define("CALIB_T0_DEGC_X8",   0x32);
define("CALIB_T1_DEGC_X8",   0x33);
define("CALIB_T1_T0_MSB",    0x35);
define("CALIB$T0_OUT_L",     0x3C);
define("CALIB$T0_OUT_H",     0x3D);
define("CALIB$T1_OUT_L",     0x3E);
define("CALIB$T1_OUT_H",     0x3F);
 */

$h0_rH = 0;
$h1_rH = 0;
$T0_degC = 0;
$T1_degC = 0;
$H0_T0 = 0;
$H1_T0 = 0;
$T0_OUT = 0;
$T1_OUT = 0;

$pid = 0;

function twobyte2singedint($twobyte)
{
    if($twobyte & 0x8000)
    {
        $twobyte = ($twobyte & 0x7fff) - 0x8000;
    }
    
    return $twobyte
;
}

function i2c_HTS221_setup($i2c_id)
{
    global $pid ;
    
    $sensor_addr 
= sprintf("%02x", HTS221_ADDR << 1);
    
    $pid 
= pid_open("/mmap/i2c$i2c_id");
    pid_ioctl($pid, "req reset");
    pid_ioctl($pid, "set saddr $sensor_addr");
    pid_ioctl($pid, "set mode sm");
    pid_ioctl($pid, "set role master");
    //pid_close($pid);
}

// Generic I2C read register (single byte)
function HTS221_read8($addr_reg)
{
    global $pid ;
    //$pid = pid_open("/mmap/i2c0"); // open I2C 0
    pid_ioctl($pid, "req reset");
    //pid_write($pid, "\x30\x00");
    pid_ioctl($pid, "req write wait");
    // register to read
    pid_write($pid, $addr_reg, 1); 
    
//while(pid_ioctl($pid, "get txlen")); // check transmitted data
    
    pid_ioctl
($pid, "req stop"); // stop writing data
    
    $data 
= 0;
    pid_ioctl($pid, "req read 1"); // request to read 1 bytes
    while(pid_ioctl($pid, "get rxlen") < 1) // check received data
    ;
    pid_read($pid, $data, 1); // read buffer
    //pid_close($pid);
    
    return $data
;
}

// Generic I2C write $data to register (single byte)
function HTS221_write8($addr_reg, $data)
{
    global $pid ;
    //$pid = pid_open("/mmap/i2c0"); // open I2C 0
    pid_ioctl($pid, "req reset");
    //pid_write($pid, "\x40\x00");
    pid_ioctl($pid, "req write wait");
    //register to read
    pid_write($pid, $addr_reg, 1); 
    pid_write
($pid, $data, 1); 
    while
(pid_ioctl($pid, "get txlen")); // check transmitted data
    
    pid_ioctl
($pid, "req stop"); // stop writing data
    //pid_close($pid);
}

function HTS221_activate()
{
    $data = HTS221_read8(CTRL_REG1);
    $data |= POWER_UP;
    $data |= ODR0_SET;
    HTS221_write8(CTRL_REG1, $data);
    
    return true
;
}

function HTS221_store_calibration()
{
    global $h0_rH;
    global $h1_rH;
    global $T0_degC;
    global $T1_degC;
    global $H0_T0;
    global $H1_T0;
    global $T0_OUT;
    global $T1_OUT;    
    
    for 
($reg=CALIB_START; $reg<=CALIB_END; $reg++) 
    
{
        if (($reg!=CALIB_START+8) && ($reg!=CALIB_START+9) && ($reg!=CALIB_START+4)) 
        
{
            
            $data 
= HTS221_read8($reg);
            
            switch 
($reg) 
            
{
                case CALIB_START:
                    $h0_rH = $data;
                    break;
                case CALIB_START+1:
                    $h1_rH = $data;
                    break;
                case CALIB_START+2:
                    $T0_degC = $data;
                    break;
                case CALIB_START+3:
                    $T1_degC = $data;
                    break;
                    
                case CALIB_START
+5:
                    $tmp = $T0_degC;
                    $T0_degC = ($data&0x3)<<8;
                    $T0_degC |= $tmp;
                    
                    $tmp 
= $T1_degC;
                    $T1_degC = (($data&0xC)>>2)<<8;
                    $T1_degC |= $tmp;
                    break;
                case CALIB_START+6:
                    $H0_T0 = $data;
                    break;
                case CALIB_START+7:
                    $H0_T0 |= $data<<8;
                    break;
                case CALIB_START+0xA:
                    $H1_T0 = $data;
                    break;
                case CALIB_START+0xB:
                    $H1_T0 |= $data <<8;
                    break;
                case CALIB_START+0xC:
                    $T0_OUT = $data;
                    break;
                case CALIB_START+0xD:
                    $T0_OUT |= $data << 8;
                    break;
                case CALIB_START+0xE:
                    $T1_OUT = $data;
                    break;
                case CALIB_START+0xF:
                    $T1_OUT |= $data << 8;
                    break;
                    
                    
                case CALIB_START
+8:
                case CALIB_START+9:
                case CALIB_START+4:
                //DO NOTHING
                break;
                
                
// to cover any possible error
                default:
                    return false;
            } /* switch */
        } /* if */
    }  /* for */
    
    $T0_OUT 
= twobyte2singedint($T0_OUT);
    $T1_OUT = twobyte2singedint($T1_OUT);
    $H0_T0 = twobyte2singedint($H0_T0);
    $H1_T0 = twobyte2singedint($H1_T0);
    
    return true
;
}

function HTS221_init()
{
    $data = HTS221_read8(WHO_AM_I);
    
    if 
($data == WHO_AM_I_RETURN)
    {
        if (HTS221_activate())
        {
            HTS221_store_calibration();
            return true;
        }
    }
    
    return false
;
}

function HTS221_read_temperature()
{
    
    global $h0_rH
;
    global $h1_rH;
    global $T0_degC;
    global $T1_degC;
    global $H0_T0;
    global $H1_T0;
    global $T0_OUT;
    global $T1_OUT;    
    
    $data   
= 0;
    $t_out = 0;
    $t_temp  = 0.0;
    $deg     = 0.0;
    
    $data 
= HTS221_read8( STATUS_REG);
    
    if 
($data & TEMPERATURE_READY) 
    
{
        
        $data
= HTS221_read8( TEMP_H_REG);
        $t_out = $data  << 8; // MSB
        $data = HTS221_read8( TEMP_L_REG);
        $t_out |= $data;      // LSB
        
        $t_out 
= twobyte2singedint($t_out);
        
        
// Decode Temperature
        $deg = (float)($T1_degC - $T0_degC); 
        
        
// Calculate Temperature in decimal of grade centigrades i.e. 15.0 = 150.
        $t_temp = ($t_out - $T0_OUT) * $deg / ($T1_OUT - $T0_OUT);
        $temperature = $t_temp + $T0_degC;   // provide signed celsius measurement unit
        // remove x8 multiple
        $temperature /= 8;
    }
    else
        $temperature 
= false;
    
    return $temperature
;
}

function HTS221_read_humidity()
{
    
    global $h0_rH
;
    global $h1_rH;
    global $T0_degC;
    global $T1_degC;
    global $H0_T0;
    global $H1_T0;
    global $T0_OUT;
    global $T1_OUT;
    
    $data   
= 0;
    $h_out = 0;
    $h_temp  = 0.0;
    $hum     = 0.0;
    
    $data 
= HTS221_read8( STATUS_REG);
    
    if 
($data & HUMIDITY_READY) 
    
{
        $data = HTS221_read8( HUMIDITY_H_REG);
        $h_out = $data << 8;  // MSB
        $data = HTS221_read8( HUMIDITY_L_REG);
        $h_out |= $data;      // LSB
        
        $h_out 
= twobyte2singedint($h_out);
        
        
// Decode Humidity
        $hum = (($h1_rH) - ($h0_rH))/2.0;  // remove x2 multiple
        
        
// Calculate humidity in decimal of grade centigrades i.e. 15.0 = 150.
        $h_temp = (($h_out - $H0_T0) * $hum) / ($H1_T0 - $H0_T0);
        $hum    = ($h0_rH) / 2.0; // remove x2 multiple
        $humidity = (($hum + $h_temp)); // provide signed % measurement unit
    }
    else
        $humidity 
= false;
    return $humidity;
}

?>


Open web browser, access to your channel (https://thingspeak.com/channels/YOURID and see result.

For my case, I put the sensor to fridge for some minutes.

test.jpg
test.jpg (57.39 KiB) Viewed 2633 times


Result: you can see result in demo part.
Khanh
 
Posts: 70
Joined: Fri Mar 11, 2016 10:57 am

Return to Project

Who is online

Users browsing this forum: Bing [Bot] and 1 guest

cron