Ksenia Kondrashova / Mbed 2 deprecated Temp_&_RH_at_TFT_with_touchscreen-RUS

Русифицированная версия программы для измерения температуры и отн. влажности и вывода информации на сенсорный TFT

Dependencies:   FT800_2 HYT mbed

Компоненты

Подключение

Отладочная плата к TFT-модулю

Отладочная плата подключается к модулю через переходник Break Out Board 20. На плате-переходнике используется 6 сигналов: SCK, MOSI, MISO, SS (интерфейс SPI), PD (powerdown) и INT (interrupt).

Питание должно быть подано не только на VDD, но и на BLVDD - подсветку экрана. Соответствующие выводы можно просто соединить между собой:

/media/uploads/Ksenia/4_-5-.jpg

Отладочная плата к датчику серии HYT

К датчику отладочная плата подключается по I2C. Не забываем про подтяжку к питанию:

/media/uploads/Ksenia/freshpaint-20-2016.09.16-10.37.03.png

Демонстрация работы

Процесс создания приложения подробно описан тут: https://habrahabr.ru/users/uuuulala/topics/

TFT/display.StringsTransform.cpp

Committer:
Ksenia
Date:
2016-10-12
Revision:
1:8ca8a4ecbe6b
Parent:
0:9db07391e780

File content as of revision 1:8ca8a4ecbe6b:

#include "display.h"

/**************************************************************************************************************************
************************** Transform humiditity / temperature float value to string ***************************************
**************************************************************************************************************************/
// If isTemp = 0, resulting string includes
// 1. current humididty
// 3. " %"

// If isTemp = 1, resulting string includes
// 1. "-" (optional),
// 2. current temperature with decimal mark
// 3. " С"

// Returns offset using for placing degree sign
char Display::CreateStringTempHum(char *str, float number, bool isTemp)
{
    char offsetForDegreeSign;
    short int multipedNumber = (short int)(number * 100);
    char strCnt = 0;
    if (isTemp) {
        if (multipedNumber < 0) {
            multipedNumber = -multipedNumber;
            str[strCnt] = '-';
            strCnt++;
        }
    }
    if (multipedNumber >= 10000) {
        str[strCnt] = '0' + (multipedNumber % 100000) / 10000;
        strCnt++;
    }
    if (multipedNumber >= 1000) {
        str[strCnt] = '0' + (multipedNumber % 10000) / 1000;
        strCnt++;
    }
    if (multipedNumber >= 100) {
        str[strCnt] = '0' + (multipedNumber % 1000) / 100;
        strCnt++;
    }
    if (isTemp) {
        str[strCnt] = '.';
        strCnt++;
        str[strCnt] = '0' + (multipedNumber % 100) / 10;
        strCnt++;
        str[strCnt] = ' ';
        strCnt++;
        offsetForDegreeSign = strCnt;
        str[strCnt] = 'C';
        strCnt++;
    } else {
        str[strCnt] = '%';
        strCnt++;
    }
    str[strCnt] = 0;
    
    return offsetForDegreeSign;
}


/**************************************************************************************************************************
************************** Transform multiplied temperature value to string ***********************************************
**************************************************************************************************************************/
// Resulting string includes
// 1. "-" (optional),
// 2. current temperature with decimal mark
void Display::CreateStringMultipliedTemp(char *str, short int number)
{
    char strCnt = 0;
    if (number < 0) {
        number = -number;
        str[strCnt] = '-';
        strCnt++;
    }
    if (number >= 1000) {
        str[strCnt] = '0' + (number % 10000) / 1000;
        strCnt++;
    }
    if (number >= 100) {
        str[strCnt] = '0' + (number % 1000) / 100;
        strCnt++;
    }
    if (number >= 10) {
        str[strCnt] = '0' + (number % 100) / 10;
        strCnt++;
    }
    str[strCnt] = '.';
    strCnt++;
    str[strCnt] = '0' + (number % 100) / 10;
    strCnt++;
    str[strCnt] = 0;
}


/**************************************************************************************************************************
************************** Transform number of seconds to HH:MM:SS string *************************************************
**************************************************************************************************************************/
void Display::CreateStringTime(char *str, uint32_t numberOfSeconds)
{
    char hrs = (numberOfSeconds / 3600);
    if (hrs < 10) {
        str[0] = '0';
    } else {
        str[0] = '0' + hrs / 10;
    }
    str[1] = '0' + hrs % 10;
    str[2] = ':';
    char minutes = (numberOfSeconds / 60) % 60;
    if (minutes < 10) {
        str[3] = '0';
    } else {
        str[3] = '0' + minutes / 10;
    }
    str[4] = '0' + minutes % 10;
    str[5] = ':';
    char sec = numberOfSeconds % 60;
    if (sec < 10) {
        str[6] = '0';
    } else {
        str[6] = '0' + sec / 10;
    }
    str[7] = '0' + sec % 10;
    str[8] = 0;
}

void Display::CreateStringRussian(const string rustext)
{
// CHANGED ASCII:
//  0123456789АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя.,:-°±%<>rHYTICS
    int len = rustext.length();
    int j = 0;
    for (int i = 0; i < len; i ++) {
        uint16_t res = uint8_t(rustext[i]);
        if (res > 0x7F) {
            res = res << 8 | uint8_t(rustext[i + 1]);
            // АБВ ... ноп
            if ((res >= 0xD090) && (res <= 0xD0BF)) {
                char offset = (char)(res - 0xD090);
                russianStr[j] = 32 + 11 + offset;
            // рст ... эюя
            } else if ((res >= 0xD180) && (res <= 0xD18F)) {
                char offset = (char)(res - 0xD180);
                russianStr[j] = 32 + 59 + offset;
            }
            // Degree sign
            else if (res == 0xC2B0) {
                russianStr[j] = 32 + 79;
            }
            // Plus-minus sign
            else if (res == 0xC2B1) {
                russianStr[j] = 32 + 80;
            }
            i++;
        } else {
            // Space
            if (res == 0x20) {
                russianStr[j] = 32;
            } 
            // Numbers
            else if (res >= 0x30 && res <= 0x39) {  
                russianStr[j] = 32 + 1 + (res - 0x30);
            } 
            // .
            else if (res == 0x2E) {
                russianStr[j] = 32 + 75;
            }
            // ,
            else if (res == 0x2C) {
                russianStr[j] = 32 + 76;
            }
            // :
            else if (res == 0x3A) {
                russianStr[j] = 32 + 77;
            }
            // -
            else if (res == 0x2D) {
                russianStr[j] = 32 + 78;
            }
            // %
            else if (res == 0x25) {
                russianStr[j] = 32 + 81;
            } 
            // <
            else if (res == 0x3C) {
                russianStr[j] = 32 + 82;
            }
            // >
            else if (res == 0x3C) {
                russianStr[j] = 32 + 83;
            }
            // "r"
            else if (res == 0x72) {
                russianStr[j] = 32 + 84;
            }
            // "H"
            else if (res == 0x48) {
                russianStr[j] = 32 + 85;
            }
            // "Y"
            else if (res == 0x59) {
                russianStr[j] = 32 + 86;
            }
            // "T"
            else if (res == 0x54) {
                russianStr[j] = 32 + 87;
            }
            // "I"
            else if (res == 0x49) {
                russianStr[j] = 32 + 88;
            }
            // "C"
            else if (res == 0x43) {
                russianStr[j] = 32 + 89;
            }
            // "S"
            else if (res == 0x53) {
                russianStr[j] = 32 + 90;
            }
        }
        j++;
    }
    russianStr[j] = 0;
}