BLEによる温度センサー計測
CySmartアプリケーション表示：
I2C：
PSoC Creator 回路図エディタにI2Cコンポーネントを登録します。
I2Cモジュールをダブルクリックしてコンフィグレーションします。
I2C_1_SCL, I2C_1_SDAのピンを設定します。
RGB LED：
PSoC 4 BLE Pioneer KitにはRGBのLEDが存在しますのでインディケータとして使用します。
OutputとPWMコンポーネントを追加します。
PWM_BLUE:
ControlLED:
ひとつはHeart Beat用にPWMを接続しておきます。
BLE：
BLEコンポーネントを登録します。
PROFILES:
GAP:
コード：
BLE Code
#include "project.h"
#include <stdbool.h>
#include <math.h>
#define bool _Bool
#define true 1
#define false 0
#define min(a, b) ((a) < (b) ? (a) : (b))
volatile uint32_t gTick = 0;
CY_ISR(SysTick_Handler)
{
gTick++;
}
void Delay(uint32_t tick_delay)
{
uint32_t tick_entry = gTick;
while(gTick - tick_entry < tick_delay);
}
void I2CDev_initialize(void);
void I2CDev_cleanup(void);
bool I2CDev_readByte(uint8_t devAddr, uint8_t regAddr, uint8_t *data);
bool I2CDev_readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint8_t length);
int8_t I2CDev_readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data);
int8_t I2CDev_readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data, uint16_t timeout);
int8_t I2CDev_readBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t *data, uint16_t timeout);
int8_t I2CDev_readBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t *data, uint16_t timeout);
int8_t I2CDev_readBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t *data, uint16_t timeout);
int8_t I2CDev_readBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t *data, uint16_t timeout);
bool I2CDev_writeCommand(uint8_t devAddr, uint8_t command);
bool I2CDev_writeByte(uint8_t devAddr, uint8_t regAddr, uint8_t data);
bool I2CDev_writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint8_t length);
bool I2CDev_writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t* data);
bool I2CDev_writeWord(uint8_t devAddr, uint8_t regAddr, uint16_t data);
bool I2CDev_writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t data);
bool I2CDev_writeBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data);
bool I2CDev_writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t data);
bool I2CDev_writeBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t data);
static uint8_t I2CDev_devAddr;
#define I2C_1_WRITE_XFER_MODE I2C_1_I2C_WRITE_XFER_MODE
#define I2C_1_READ_XFER_MODE I2C_1_I2C_READ_XFER_MODE
#define I2C_1_ACK_DATA I2C_1_I2C_ACK_DATA
#define I2C_1_NAK_DATA I2C_1_I2C_NAK_DATA
void I2CDev_initialize(void)
{
I2C_1_Start();
}
void I2CDev_cleanup(void)
{
I2C_1_Stop();
}
bool I2CDev_readByte(uint8_t devAddr, uint8_t regAddr, uint8_t *data)
{
I2C_1_I2CMasterSendStart(devAddr, I2C_1_WRITE_XFER_MODE);
I2C_1_I2CMasterWriteByte(regAddr);
I2C_1_I2CMasterSendRestart(devAddr, I2C_1_READ_XFER_MODE);
*data = I2C_1_I2CMasterReadByte(I2C_1_ACK_DATA);
I2C_1_I2CMasterSendStop();
return true;
}
bool I2CDev_readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint8_t length)
{
uint8_t i=0;
I2C_1_I2CMasterSendStart(devAddr, I2C_1_WRITE_XFER_MODE);
I2C_1_I2CMasterWriteByte(regAddr);
I2C_1_I2CMasterSendRestart(devAddr, I2C_1_READ_XFER_MODE);
while (i++ < (length-1)) {
*data++ = I2C_1_I2CMasterReadByte(I2C_1_ACK_DATA);
}
*data = I2C_1_I2CMasterReadByte(I2C_1_NAK_DATA);
I2C_1_I2CMasterSendStop();
return true;
}
int8_t I2CDev_readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data)
{
int8_t count;
for (uint8_t k = 0; k < length * 2; k += length * 2) {
I2C_1_I2CMasterSendStart(devAddr, I2C_1_WRITE_XFER_MODE);
I2C_1_I2CMasterWriteByte(regAddr);
I2C_1_I2CMasterSendRestart(devAddr, I2C_1_READ_XFER_MODE);
bool msb = true; // starts with MSB, then LSB
for (count = 0; count < length;) {
if (msb == true) {
// first byte is bits 15-8 (MSb=15)
data[count] = I2C_1_I2CMasterReadByte(I2C_1_ACK_DATA) << 8;
msb = false;
} else {
// second byte is bits 7-0 (LSb=0)
data[count] |= I2C_1_I2CMasterReadByte(I2C_1_NAK_DATA);
count++;
msb = true;
}
}
}
I2C_1_I2CMasterSendStop();
return count;
}
int8_t I2CDev_readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data, uint16_t timeout)
{
return I2CDev_readWords(devAddr, regAddr, 1, data);
}
int8_t I2CDev_readBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t *data, uint16_t timeout)
{
uint8_t b;
uint8_t count = I2CDev_readByte(devAddr, regAddr, &b);
*data = b & (1 << bitNum);
return count;
}
int8_t I2CDev_readBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t *data, uint16_t timeout)
{
uint16_t b;
uint8_t count = I2CDev_readWord(devAddr, regAddr, &b, timeout);
*data = b & (1 << bitNum);
return count;
}
int8_t I2CDev_readBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t *data, uint16_t timeout)
{
// 01101001 read byte
// 76543210 bit numbers
// xxx args: bitStart=4, length=3
// 010 masked
// -> 010 shifted
uint8_t count, b;
if ((count = I2CDev_readByte(devAddr, regAddr, &b)) != 0) {
uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
b &= mask;
b >>= (bitStart - length + 1);
*data = b;
}
return count;
}
int8_t I2CDev_readBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t *data, uint16_t timeout)
{
// 1101011001101001 read byte
// fedcba9876543210 bit numbers
// xxx args: bitStart=12, length=3
// 010 masked
// -> 010 shifted
uint8_t count;
uint16_t w;
if ((count = I2CDev_readWord(devAddr, regAddr, &w, timeout)) != 0) {
uint16_t mask = ((1 << length) - 1) << (bitStart - length + 1);
w &= mask;
w >>= (bitStart - length + 1);
*data = w;
}
return count;
}
bool I2CDev_writeCommand(uint8_t devAddr, uint8_t command)
{
I2C_1_I2CMasterSendStart(devAddr, I2C_1_WRITE_XFER_MODE);
I2C_1_I2CMasterWriteByte(command);
I2C_1_I2CMasterSendStop();
return true;
}
bool I2CDev_writeByte(uint8_t devAddr, uint8_t regAddr, uint8_t data)
{
I2C_1_I2CMasterSendStart(devAddr, I2C_1_WRITE_XFER_MODE);
I2C_1_I2CMasterWriteByte(regAddr);
I2C_1_I2CMasterWriteByte(data);
I2C_1_I2CMasterSendStop();
return true;
}
bool I2CDev_writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint8_t length)
{
uint8_t i;
I2C_1_I2CMasterSendStart(devAddr, I2C_1_WRITE_XFER_MODE);
I2C_1_I2CMasterWriteByte(regAddr);
for (i = 0; i < length; i++)
{
I2C_1_I2CMasterWriteByte(*(data+i));
}
I2C_1_I2CMasterSendStop();
return true;
}
bool I2CDev_writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t* data)
{
I2C_1_I2CMasterSendStart(devAddr, I2C_1_WRITE_XFER_MODE);
I2C_1_I2CMasterWriteByte(regAddr);
for (uint8_t i = 0; i < length * 2; i++) {
I2C_1_I2CMasterWriteByte((uint8_t)((data[i] >> 8) & 0xFF));
I2C_1_I2CMasterWriteByte( (uint8_t)(data[i++] & 0xFF));
}
I2C_1_I2CMasterSendStop();
return true;
}
bool I2CDev_writeWord(uint8_t devAddr, uint8_t regAddr, uint16_t data)
{
return I2CDev_writeWords(devAddr, regAddr, 1, &data);
}
bool I2CDev_writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t data)
{
uint8_t b;
I2CDev_readByte(devAddr, regAddr, &b);
b = (data != 0) ? (b | (1 << bitNum)) : (b & ~(1 << bitNum));
return I2CDev_writeByte(devAddr, regAddr, b);
}
bool I2CDev_writeBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data)
{
uint16_t w;
I2CDev_readWord(devAddr, regAddr, &w, 0);
w = (data != 0) ? (w | (1 << bitNum)) : (w & ~(1 << bitNum));
return I2CDev_writeWord(devAddr, regAddr, w);
}
bool I2CDev_writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t data)
{
// 010 value to write
// 76543210 bit numbers
// xxx args: bitStart=4, length=3
// 00011100 mask byte
// 10101111 original value (sample)
// 10100011 original & ~mask
// 10101011 masked | value
uint8_t b;
if (I2CDev_readByte(devAddr, regAddr, &b) != 0) {
uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
data <<= (bitStart - length + 1); // shift data into correct position
data &= mask; // zero all non-important bits in data
b &= ~(mask); // zero all important bits in existing byte
b |= data; // combine data with existing byte
return I2CDev_writeByte(devAddr, regAddr, b);
} else {
return false;
}
}
bool I2CDev_writeBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t data)
{
// 010 value to write
// fedcba9876543210 bit numbers
// xxx args: bitStart=12, length=3
// 0001110000000000 mask word
// 1010111110010110 original value (sample)
// 1010001110010110 original & ~mask
// 1010101110010110 masked | value
uint16_t w;
if (I2CDev_readWord(devAddr, regAddr, &w, 0) != 0) {
uint16_t mask = ((1 << length) - 1) << (bitStart - length + 1);
data <<= (bitStart - length + 1); // shift data into correct position
data &= mask; // zero all non-important bits in data
w &= ~(mask); // zero all important bits in existing word
w |= data; // combine data with existing word
return I2CDev_writeWord(devAddr, regAddr, w);
} else {
return false;
}
}
uint16_t w_temperature;
float f_temperature;
float prev_f_temperature;
#define TMP006_ADDRESS 0x40 // 100 0000
#define TMP006_EXISTS
#define LED_ON (0u)
#define LED_OFF (1u)
#define NO_ALERT (0u)
#define MILD_ALERT (1u)
#define HIGH_ALERT (2u)
#define LED_TOGGLE_TIMEOUT (100u)
uint8_t alertLevel;
#define WAKEUP_SOURCE_WDT (1u << 0)
#define MEASUREMENT_INTERVAL (1u << 1)
#define SLEEP_DISABLED (1u << 2)
#define ENABLE_HIBERNATE (1u << 3)
#define IMO_FREQUENCY_3MHZ (3u)
#define IMO_FREQUENCY_12MHZ (12u)
#define DEFAULT_MEASUREMENT_INTERVAL (1u)
#define REFRESH_INTERVAL (1000u)
#define HTSS_TEMPERATURE_MEASURE_SIZE (6u)
/* htssInterval holds the Health Thermometer Service measurement interval */
uint32 htssInterval = DEFAULT_MEASUREMENT_INTERVAL;
/* Indicates the status of Indication */
static bool htssIndication = false;
/* Connection handle used for transmitting information over BLE */
CYBLE_CONN_HANDLE_T connectionHandle;
#define DRIVE_HIGH (1u)
#define DRIVE_LOW (0u)
/* System Flag used to indicate system status */
uint32 SystemFlag = 0;
#define WDT_INTERRUPT_NUM (8)
#define WATCHDOG_DEFAULT_PERIOD_MS (20)
#define WATCHDOG_TICKS_PER_MS (32)
#define CLK_ILO_CONFIG_ILO_ENABLE (1u << 31)
#define WDT_CONFIG_WDT_MODE0_INT (1u << 0)
#define WDT_CONTROL_WDT_ENABLE0 (1u << 0)
#define WDT_CONTROL_WDT_ENABLED0 (1u << 1)
#define WDT_CONTROL_WDT_INT0 (1u << 2)
#define CLK_SELECT_WDT_LOCK_SET01 ((1u << 14) | (1u << 15))
#define CLK_SELECT_WDT_LOCK_CLR0 (1u << 14)
#define CLK_SELECT_WDT_LOCK_CLR1 (1u << 15)
#define UPDATE_WDT_MATCH(value) CY_SET_REG32(CYREG_WDT_MATCH, \
(CY_GET_REG32(CYREG_WDT_MATCH) & 0xFFFF0000) + (uint16)value)
volatile static uint32 watchdogPeriodMs = WATCHDOG_DEFAULT_PERIOD_MS;
volatile static uint32 nextTicks = WATCHDOG_DEFAULT_PERIOD_MS * WATCHDOG_TICKS_PER_MS;
static void WatchdogTimer_Lock(void)
{
uint32 ClkSelectValue;
/* Update CLK_SELECT register to lock watchdog timer */
ClkSelectValue = CY_GET_REG32(CYREG_CLK_SELECT) | CLK_SELECT_WDT_LOCK_SET01;
CY_SET_REG32(CYREG_CLK_SELECT, ClkSelectValue);
}
static void WatchdogTimer_Unlock(void)
{
uint32 ClkSelectValue;
/* Update CLK_SELECT register to unlock watchdog timer */
ClkSelectValue = CY_GET_REG32(CYREG_CLK_SELECT) & ~CLK_SELECT_WDT_LOCK_SET01;
CY_SET_REG32(CYREG_CLK_SELECT, ClkSelectValue | CLK_SELECT_WDT_LOCK_CLR0);
CY_SET_REG32(CYREG_CLK_SELECT, ClkSelectValue | CLK_SELECT_WDT_LOCK_CLR1);
}
CY_ISR(WatchdogTimer_Isr)
{
/* Initializes the interval timer with default measurement interval */
static uint32 intervalTimer = DEFAULT_MEASUREMENT_INTERVAL;
/* Unlock watchdog timer to enable configuration changes*/
WatchdogTimer_Unlock();
/* Update WDT match register for next interrupt */
UPDATE_WDT_MATCH((uint16)(CY_GET_REG32(CYREG_WDT_MATCH) + nextTicks));
/* Clear WDT pending interrupt */
CY_SET_REG32(CYREG_WDT_CONTROL, CY_GET_REG32(CYREG_WDT_CONTROL) | WDT_CONTROL_WDT_INT0);
/* Lock watchdog timer to prevent configuration changes */
WatchdogTimer_Lock();
/* Decrement interval timer */
intervalTimer--;
/* If interval timer has elapsed then enable MEASUREMENT_INTERVAL flag */
if(intervalTimer == 0)
{
/* Initialize interval timer and set MEASUREMENT_INTERVAL flag */
intervalTimer = htssInterval;
SystemFlag |= MEASUREMENT_INTERVAL;
}
/* Set WDT flag for application processing */
SystemFlag |= WAKEUP_SOURCE_WDT;
}
void WatchdogTimer_Start(uint32 wdtPeriodMs)
{
CyIntSetVector(WDT_INTERRUPT_NUM, &WatchdogTimer_Isr);
WatchdogTimer_Unlock();
/* Set the WDT period */
watchdogPeriodMs = wdtPeriodMs;
nextTicks = watchdogPeriodMs * WATCHDOG_TICKS_PER_MS;
UPDATE_WDT_MATCH(nextTicks);
/* Set WDT_CONFIG register */
CY_SET_REG32(CYREG_WDT_CONFIG, CY_GET_REG32(CYREG_WDT_CONFIG) | WDT_CONFIG_WDT_MODE0_INT);
/* Enable WDT interrupt for the NVIC */
CyIntEnable(WDT_INTERRUPT_NUM);
/* Set WDT_CONTROL register */
CY_SET_REG32(CYREG_WDT_CONTROL, CY_GET_REG32(CYREG_WDT_CONTROL) | WDT_CONTROL_WDT_ENABLE0);
/* Wait for the WDT enable to complete */
while((CY_GET_REG32(CYREG_WDT_CONTROL) & WDT_CONTROL_WDT_ENABLED0) == 0);
WatchdogTimer_Lock();
}
void WatchdogTimer_Stop (void)
{
WatchdogTimer_Unlock();
/* Clear WDT_CONFIG register */
CY_SET_REG32(CYREG_WDT_CONFIG, CY_GET_REG32(CYREG_WDT_CONFIG) & ~WDT_CONFIG_WDT_MODE0_INT);
/* Clear WDT pending interrupt */
CY_SET_REG32(CYREG_WDT_CONTROL, CY_GET_REG32(CYREG_WDT_CONTROL) | WDT_CONTROL_WDT_INT0);
WatchdogTimer_Lock();
}
uint8_t led_enable_control = 0; // all off, bit0:blue, bit1:green, bit0:red
void EnLEDBlue(bool enable)
{
if (enable) {
led_enable_control |= 0x01;
} else {
led_enable_control &= 0xFE;
}
Control_LED_Write( led_enable_control);
}
void EnLEDGreen(bool enable)
{
if (enable) {
led_enable_control |= 0x02;
} else {
led_enable_control &= 0xFD;
}
Control_LED_Write( led_enable_control);
}
void EnLEDRed(bool enable)
{
if (enable) {
led_enable_control |= 0x04;
} else {
led_enable_control &= 0xFB;
}
Control_LED_Write( led_enable_control);
}
uint8_t status_led = 0;
void Status_Init(void)
{
//return;
if (status_led != 1)
{
PWM_BLUE_WriteCompare(10);
PWM_BLUE_WritePeriod(999);
//PWM_BLUE_Start();
status_led = 1;
EnLEDBlue(true);
EnLEDGreen(false);
EnLEDRed(false);
}
}
void Status_Advertise(void)
{
//return;
if (status_led != 2)
{
PWM_BLUE_WriteCompare(5);
PWM_BLUE_WritePeriod(799);
//PWM_BLUE_Start();
status_led = 2;
EnLEDBlue(true);
EnLEDGreen(false);
EnLEDRed(false);
}
}
void Status_Disconn(void)
{
//return;
if (status_led != 3)
{
PWM_BLUE_WriteCompare(499);
PWM_BLUE_WritePeriod(999);
//PWM_BLUE_Start();
status_led = 3;
EnLEDBlue(true);
EnLEDGreen(false);
EnLEDRed(false);
}
}
void Status_Conn(void)
{
//return;
if (status_led != 4)
{
PWM_BLUE_WriteCompare(99);
PWM_BLUE_WritePeriod(199);
//PWM_BLUE_Start();
status_led = 4;
EnLEDBlue(true);
EnLEDGreen(true);
EnLEDRed(false);
}
}
void GenericEventHandler(uint32 event, void *eventParam)
{
switch(event)
{
/* This event is received when component is Started */
case CYBLE_EVT_STACK_ON:
/* Stop watchdog to reduce power consumption during advertising */
//WatchdogTimer_Stop();
/* Start Advertisement and enter Discoverable mode*/
CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);
Status_Advertise();
break;
/* This event is received when device is disconnected or advetising times out*/
case CYBLE_EVT_GAP_DEVICE_DISCONNECTED:
case CYBLE_EVT_TIMEOUT:
/* Sets the ENABLE_HIBERNATE flag to put system in Hibernate mode */
SystemFlag |= ENABLE_HIBERNATE;
CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);
Status_Advertise();
break;
/* This event is received when connection is established */
case CYBLE_EVT_GATT_CONNECT_IND:
/* Start watchdog timer with 1s refresh interval */
/* Note: For this application, wakeup should be 1s because htssInterval
* resolution is configured as 1s */
//WatchdogTimer_Start(REFRESH_INTERVAL);
/* Retrieve BLE connection handle */
connectionHandle = *(CYBLE_CONN_HANDLE_T *) eventParam;
Status_Conn();
break;
default:
/* Error handling */
break;
}
}
void HtssEventHandler(uint32 event, void* eventParam)
{
CYBLE_HTS_CHAR_VALUE_T *interval;
switch(event)
{
/* This event is received when indication are enabled by the central */
case CYBLE_EVT_HTSS_INDICATION_ENABLED:
/* Set the htssIndication flag */
htssIndication = true;
break;
/* This event is received when indication are enabled by the central */
case CYBLE_EVT_HTSS_INDICATION_DISABLED:
/* Reset the htssIndiciation flag */
htssIndication = false;
break;
/* This event is received when measurement interval is updated by
* the central */
case CYBLE_EVT_HTSS_CHAR_WRITE:
/* Retrive interval value */
interval = ((CYBLE_HTS_CHAR_VALUE_T *)eventParam);
htssInterval = interval->value->val[1];
/* Update htssInterval with the updated value */
htssInterval = (htssInterval << 8) | interval->value->val[0];
break;
default:
/* Error handling */
break;
}
}
void EnableBLE (void)
{
/* Enable BLE block and register the callback function for common events */
CyBle_Start(GenericEventHandler);
/* Regsiters the callback function for heart rate service specific events */
CyBle_HtsRegisterAttrCallback(HtssEventHandler);
}
void InitializeSystem (void)
{
/* Clear wakeup pin interrupt */
//SW_ClearInterrupt();
/* Enable BLE and related resouces */
EnableBLE();
}
void PrepareForDeepSleep (void)
{
}
void WakeupFromDeepSleep (void)
{
}
void ProcessBLE (uint32 temperature)
{
/* Temporary array to hold Health Thermometer characteristic information */
uint8 valueArray[HTSS_TEMPERATURE_MEASURE_SIZE];
/* Check if indications are enabled and measurement interval has elapsed */
// if((true == htssIndication) && (SystemFlag & MEASUREMENT_INTERVAL))
if((true == htssIndication) && (MEASUREMENT_INTERVAL))
{
/* Clear measurement interval flag */
SystemFlag &= ~MEASUREMENT_INTERVAL;
/* Read Health Thermometer Characteristic from GATT DB */
if(CYBLE_ERROR_OK == CyBle_HtssGetCharacteristicValue(CYBLE_HTS_TEMP_MEASURE, HTSS_TEMPERATURE_MEASURE_SIZE, valueArray))
{
/* Update temperature in the characteristic */
valueArray[1] = LO8(LO16(temperature));
valueArray[2] = HI8(LO16(temperature));
valueArray[3] = LO8(HI16(temperature));
valueArray[4] = HI8(HI16(temperature));
/* Send indication to the central */
CyBle_HtssSendIndication(connectionHandle, CYBLE_HTS_TEMP_MEASURE, HTSS_TEMPERATURE_MEASURE_SIZE, valueArray);
}
}
}
uint32_t l_temp = 0;
/* clock and interrupt rates, in Hz */
#define SYS_CLOCK_FREQ 12000000u // clock frequency
#define ENABLE_BLE
int main(void)
{
CYBLE_API_RESULT_T apiResult;
/* Powerstate indicators of BLESS */
CYBLE_LP_MODE_T lpMode = CYBLE_BLESS_DEEPSLEEP;
CYBLE_BLESS_STATE_T blessState = CYBLE_BLESS_STATE_DEEPSLEEP;
CyIntSetSysVector(15,(cyisraddress)SysTick_Handler);
SysTick_Config(SYS_CLOCK_FREQ/1000);
//PWM_BLUE_Start();
CyGlobalIntEnable; /* Enable global interrupts. */
I2CDev_initialize();
//Clock_1_Start();
PWM_BLUE_Start();
EnLEDBlue(true);
// Delay(5000);
#ifdef ENABLE_BLE
// Start BLE
apiResult = CyBle_Start(GenericEventHandler);
if (apiResult != CYBLE_ERROR_OK)
{
CYASSERT(0);
} else {
Status_Init();
}
InitializeSystem();
#endif
#ifdef TMP006_EXISTS
// set configuration register
// I2CDev_writeWord(TMP006_ADDRESS, 0x02, 0x7980);
#endif
for(;;)
{
#ifdef ENABLE_BLE
CyBle_ProcessEvents();
if(CyBle_GetState() == CYBLE_STATE_CONNECTED)
{
// Process all pending BLE events in the stack
CyBle_ProcessEvents();
ProcessBLE(l_temp);
}
#endif
#ifdef TMP006_EXISTS
// I2CDev_readWord(TMP006_ADDRESS, 0x02, &w_temperature, 0);
// if (w_temperature & 0x0080)
{
I2CDev_readWord(TMP006_ADDRESS, 0x01, &w_temperature, 0);
int temperature_flag;
temperature_flag = 0;
if (w_temperature & 0x8000)
{
temperature_flag = 1; // minus
}
f_temperature = (float)(w_temperature >> 2);
if (temperature_flag) {
f_temperature *= -1.0;
}
f_temperature *= 0.0315;
if (f_temperature > (prev_f_temperature + 30))
{
f_temperature = prev_f_temperature + 1;
}
else if(f_temperature < (prev_f_temperature - 30))
{
f_temperature = prev_f_temperature -1;
}
prev_f_temperature = f_temperature;
l_temp = (int)(f_temperature);
}
#endif
}
}
/* [] END OF FILE */