Published May 31, 2019 © MIT

Cloud-Based Ambient Light Data Logger

Log data to an online server (ThingSpeak.com) with a TIVA-C (TMC4123GXL) microcontroller, an ESP8266, and a TSL2591.

IntermediateShowcase (no instructions)5 hours1,664

Things used in this project

Hardware components

Texas Instruments EK-TM4C123GXL TM4C Tiva LaunchPad

NodeMCU ESP8266 Breakout Board

Adafruit TSL2591

Software apps and online services

Texas Instruments Code Composer Studio

Story

So I was digging around some projects from the old academia days and came across this midterm project for a class. It's not the best written code (almost non-existent error handling, header files not utilized, etc.), but it's functional. It's also not that practical either since you can just attach the light sensor directly into the ESP8266 and leave out the TIVA-C; it's an academic exercise so it's okay I guess. Anyways, I thought it would be useful for other people to see an example of I2C and UART communication implemented on C/C++.

System Overview

System Block Diagram

The goal of the project is to integrate a light sensor, TSL2591, and a WIFI module, ESP8266, to a microcontroller., TM4C123GXL. The microcontroller should be able to read the data coming from the light sensor then push the data to the WIFI module. The module then transfers the data either to a server or to the cloud. Basically it needs to do the following:

Establish communication between the light sensor (TSL2591) and the microcontroller (TM4C123GXL)
Establish communication between microcontroller (TM4C123GXL) and the WIFI module (ESP8266)
Send data collected from the light sensor (TSL2591) to a cloud server (ThingSpeak.com)

Implementation Details

The first part of the implementation is to define and set the variables for the TSL2591 and the ESP8266. Then subroutines are declared for each device to be used for the main function. The main function starts off with declaring TaskStatus boolean variable to be used as a check if the subroutine is still running. Next is declaring the clock and speed. For this project, the main oscillator 16MHz oscillator is used.

Up next is the initialization of he pins and routines. First, the LEDs are initialized by enabling the GPIOF and setting the PORT 1, 2, and 3 as output pins. The LED color dictates the state of the microcontroller:

RED = initializing
GREEN = ready to send
BLUE = send success.

Second, initialize the timer function found in DelayTimer.c, which allows the use of delay DelayTimer.c uses TIMER5 to create a time delay in micro or milliseconds. This delay function is to be used throughout the main function.

To communicate with the light sensor, the TM4C123GXL I2C1 peripheral is enabled. This includes pin MUXing and the GPIO port A for the SCL and SDA pins to be used as shown in the schematic. The data rate is then set to 100kbps. Next is to access the device address, 0x29.

TSL2591 Datasheet - Slave Address

After finding the address to be accessed, the device ID register is checked and verified to make sure we're communicating properly:

1 / 2 • TSL2591 Datasheet -

In order to do this, I2C1_write is used where the command bit is given along with TSL2591 register to be accessed. Then I2C1_read is used to retrieve the data from device register into an array, temp_data. The device can then enabled by using the same function used in I2C1_write, I2CMasterSlaveAddrSet. This command is set to false in order tell the microcontroller which register data to use to write into the slave address. I2CMasterDataPut then puts the command bits into the register. I2CMasterControl, finally, sends the data.

TSL2591 Datasheet - Data Registers

The data is stored as two 16-bit values, one for each channel as shown in the table above. It is recommended that all four bytes are to be extracted in sequence to minimize error or skew between CH0 and CH1 data. This is used for the getLuminosity function where I2CMasterSlaveAddrSet again is used, except set to true, to read the TSL2591 data registers and placed into a 32-bit register named x and y. CH1 is first read then is shifted by 16 bits. CH0 is then read and placed into the register using the bitwise OR operation. The data within the register can be processed using the equations found in the TSL2561 (chip equivalent to TSL2591) data sheet. The raw data can finally be converted to full-spectrum, infrared, and visible data.

The second task is to establish communication with the WIFI module (ESP8266) using the UART serial communication. As usual, peripherals need to be enabled such as the GPIOs and UARTs.

This includes configuring the pins, clock, and baud rate to match both devices. Once the connection is initialized and established, it will then be possible for the microcontroller (TM4C123GXL) to send and receive commands to the WIFI module (ESP8266) using AT commands. Each command is set into subroutine to easily be called and verified. The following are AT functions are called: ATesp, RSTesp, CWMODEesp, CWJAPesp, CIPMUXesp, CWQAPesp, CIPSTARTesp, and CIPCLOSEesp. These subroutines are used to get the microcontroller to connect to the wireless network. Each subroutine is labeled in the code and can be referenced as needed.

Now with the system set up, we can push the data from the light sensor to the WIFI module and into the ThingSpeak server IP and port. This is handled by ProcessRoutine function. Here the data collected from the light sensor is printed to the command line screen every second as shown below.

Terminal Output

Even though ThingSpeak can only receive data every 15 seconds, it is best to acquire data in between upload times to prevent fluctuating errors from drastic change in lighting. Collecting data while moving a light source in and out will show the graphs below.

ThingSpeak Graph (Note: It's not exactly luminosity past-self)

The Thing-in-Action

Here's a demo video of the logger:

Video demo

It basically shows the terminal output as it reads the TSL2591 light data and sends it to ThingSpeak. The data points on the graphs increases and decreases (as expected) as I move my lamp.

Troubleshooting

Troubleshooting with dog.

Looking back, finishing this midterm in time was frustrating and nerve-wracking. Things didn't really work, but one technique pulled me through: the Rubber Ducky Debugging method. This where you try to explain to a rubber duck your code and process, but I'm talking to my dog in my case. I'm sure he didn't understand anything but he helped a lot. Anyways, hopefully this write-up helps the same way. :]

Code

IOT_TSL2591_DataLogger.c

#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include "inc/hw_gpio.h"
#include "inc/hw_types.h"
#include "inc/hw_memmap.h"
#include "inc/hw_ints.h"
#include "driverlib/fpu.h"
#include "driverlib/debug.h"
#include "driverlib/sysctl.h"
#include "driverlib/pin_map.h"
#include "driverlib/gpio.h"
#include "driverlib/pwm.h"
#include "driverlib/timer.h"
#include "driverlib/adc.h"
#include "driverlib/rom.h"
#include "driverlib/uart.h"
#include "driverlib/interrupt.h"
#include "driverlib/i2c.h"
#include "utils/uartstdio.h"
#include "DelayTimer.h"
//------------------------------------------------------------------------------
// DEFINE VARIABLES
//------------------------------------------------------------------------------

//
// Define TSL2591 Register Values
//
#define TSL2591_VISIBLE 2 //channel 0 - channel 1
#define TSL2591_INFRARED 1
#define TSL2591_FULLSPECTRUM 0
#define TSL2591_ADDR 0x29
#define TSL2591_READBIT 0x01
#define TSL2591_COMMAND_BIT 0xA0
#define TSL2591_CLEAR_INT 0xE7
#define TSL2591_TEST_INT 0xE4
#define TSL2591_WORD_BIT 0x20
#define TSL2591_BLOCK_BIT 0x10
#define TSL2591_ENABLE_POWEROFF 0x00
#define TSL2591_ENABLE_POWERON 0x01
#define TSL2591_ENABLE_AEN 0x02
#define TSL2591_ENABLE_AIEN 0x10
#define TSL2591_ENABLE_NPIEN 0x80
#define TSL2591_LUX_DF 408.0F
#define TSL2591_LUX_COEFB 1.64F
#define TSL2591_LUX_COEFC 0.59F
#define TSL2591_LUX_COEFD 0.86F

uint8_t
TSL2591_REGISTER_ENABLE = 0x00,
TSL2591_REGISTER_CONTROL = 0x01,
TSL2591_REGISTER_THRESHOLD_AILTL = 0x04,
TSL2591_REGISTER_THRESHOLD_AILTH = 0x05,
TSL2591_REGISTER_THRESHOLD_AIHTL = 0x06,
TSL2591_REGISTER_THRESHOLD_AIHTH = 0x07,
TSL2591_REGISTER_THRESHOLD_NPAILTL = 0x08,
TSL2591_REGISTER_THRESHOLD_NPAILTH = 0x09,
TSL2591_REGISTER_THRESHOLD_NPAIHTL = 0x0A,
TSL2591_REGISTER_THRESHOLD_NPAIHTH = 0x0B,
TSL2591_REGISTER_PERSIST_FILTER = 0x0C,
TSL2591_REGISTER_PACKAGE_PID = 0x11,
TSL2591_REGISTER_DEVICE_ID = 0x12,
TSL2591_REGISTER_DEVICE_STATUS = 0x13,
TSL2591_REGISTER_CHAN0_LOW = 0x14,
TSL2591_REGISTER_CHAN0_HIGH = 0x15,
TSL2591_REGISTER_CHAN1_LOW = 0x16,
TSL2591_REGISTER_CHAN1_HIGH = 0x17,
TSL2591_INTEGRATIONTIME_100MS = 0x00,
TSL2591_INTEGRATIONTIME_200MS = 0x01,
TSL2591_INTEGRATIONTIME_300MS = 0x02,
TSL2591_INTEGRATIONTIME_400MS = 0x03,
TSL2591_INTEGRATIONTIME_500MS = 0x04,
TSL2591_INTEGRATIONTIME_600MS = 0x05,
// bit 7:4:0
TSL2591_PERSIST_EVERY = 0x00,
TSL2591_PERSIST_ANY = 0x01,
TSL2591_PERSIST_2 = 0x02,
TSL2591_PERSIST_3 = 0x03,
TSL2591_PERSIST_5 = 0x04,
TSL2591_PERSIST_10 = 0x05,
TSL2591_PERSIST_15 = 0x06,
TSL2591_PERSIST_20 = 0x07,
TSL2591_PERSIST_25 = 0x08,
TSL2591_PERSIST_30 = 0x09,
TSL2591_PERSIST_35 = 0x0A,
TSL2591_PERSIST_40 = 0x0B,
TSL2591_PERSIST_45 = 0x0C,
TSL2591_PERSIST_50 = 0x0D,
TSL2591_PERSIST_55 = 0x0E,
TSL2591_PERSIST_60 = 0x0F,
TSL2591_GAIN_LOW = 0x00,
TSL2591_GAIN_MED = 0x10,
TSL2591_GAIN_HIGH = 0x20,
TSL2591_GAIN_MAX = 0x30;
uint8_t DevID;

//
// Define ESP8266 variables
// 
static char ReceivedData[512];
static char str[128];
bool ProcessRoutine();
char *Substring(char *src, char *dst, int start, int stop);
int SearchIndexOf(char src[], char str[]);
char* itoa(int i, char b[]);
#define Period 320000 //(16000000/50) 50Hz
#define IP "184.106.153.149" // IP address for thingspeak.com
#define PORT "80" // IP Address access port

//------------------------------------------------------------------------------
// TSL2591 FUNCTIONS
//------------------------------------------------------------------------------

//
// Initialize I2C for TSL2591
//
void InitI2C1()
{
  //Enable I2C module 1
  SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C1);
  //Reset module
  SysCtlPeripheralReset(SYSCTL_PERIPH_I2C1);
  // Enable GPIO peripheral that contains I2C 1
  SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
  // Configure the pin muxing for I2C1 functions on port PA6 and PA7.
  GPIOPinConfigure(GPIO_PA6_I2C1SCL);
  GPIOPinConfigure(GPIO_PA7_I2C1SDA);
  // Select the I2C function for these pins.
  GPIOPinTypeI2CSCL(GPIO_PORTA_BASE, GPIO_PIN_6);
  GPIOPinTypeI2C(GPIO_PORTA_BASE, GPIO_PIN_7);
  // Enable and initialize the I2C1 master module. Use the system clock for
  // the I2C1 module. The last parameter sets the I2C data transfer rate.
  // If false the data rate is set to 100kbps and if true the data rate will
  // be set to 400kbps.
  I2CMasterInitExpClk(I2C1_BASE, SysCtlClockGet(), false);
}

//
// I2C1 Write function
//
void I2C1_write(uint8_t slave_addr, uint8_t slave_reg)
{
  // Set address to be used by the master module when writing to the slave
  I2CMasterSlaveAddrSet(I2C1_BASE, slave_addr, false);
  while (I2CMasterBusy(I2C1_BASE));
  // Place command to be sent to the data register
  I2CMasterDataPut(I2C1_BASE, slave_reg);
  // Send data to slave register
  I2CMasterControl(I2C1_BASE, I2C_MASTER_CMD_SINGLE_SEND);
  while (I2CMasterBusy(I2C1_BASE));
}

//
// I2C1 Read function
//
void I2C1_read(uint8_t slave_addr, uint8_t *RxData, uint8_t N)
{
  uint8_t i; //Set local variable for loop function
  // Set address to be read
  I2CMasterSlaveAddrSet(I2C1_BASE, slave_addr, true);
  if (N==1)
  {
    // Read 8-bit data
    I2CMasterControl(I2C1_BASE, I2C_MASTER_CMD_SINGLE_RECEIVE);
    while (I2CMasterBusy(I2C1_BASE));
    // Place data into Rx array
    RxData[0]=I2CMasterDataGet(I2C1_BASE);
    while (I2CMasterBusy(I2C1_BASE));
  }
  else
  {
    // Start reading bursts of data
    I2CMasterControl(I2C1_BASE, I2C_MASTER_CMD_BURST_RECEIVE_START);
    while (I2CMasterBusy(I2C1_BASE));
    // Place data into RxData array
    RxData[0]=I2CMasterDataGet(I2C1_BASE);
    while (I2CMasterBusy(I2C1_BASE));
    
    // Continue reading data until N-1
    for (i=1;i<(N-1);i++)
    {
      I2CMasterControl(I2C1_BASE, I2C_MASTER_CMD_BURST_RECEIVE_CONT);
      while (I2CMasterBusy(I2C1_BASE));
      RxData[i]=I2CMasterDataGet(I2C1_BASE);
      while (I2CMasterBusy(I2C1_BASE));
    }
    
  // Read final data
  I2CMasterControl(I2C1_BASE, I2C_MASTER_CMD_BURST_RECEIVE_FINISH);

  while (I2CMasterBusy(I2C1_BASE));
  // Place last piece of data into RxData array
  RxData[N-1]=I2CMasterDataGet(I2C1_BASE);
  while (I2CMasterBusy(I2C1_BASE));
  }
}

void TSL2591_disable(void)
{
  I2C1_write(TSL2591_ADDR, TSL2591_COMMAND_BIT|TSL2591_REGISTER_ENABLE|TSL2591_ENABLE_POWEROFF);
}

void TSL2591_enable(void)
{
  //
  // Set integration time and sensor gain
  //
  // Specify that we want to communicate to device address with an intended write to bus
  I2CMasterSlaveAddrSet(I2C1_BASE, TSL2591_ADDR, false);
  // Place command in the register
  I2CMasterDataPut(I2C1_BASE, TSL2591_COMMAND_BIT|TSL2591_INTEGRATIONTIME_100MS);
  // Send control byte and register address byte to slave device
  I2CMasterControl(I2C1_BASE, I2C_MASTER_CMD_BURST_SEND_START);
  while (I2CMasterBusy(I2C1_BASE));
  I2CMasterDataPut(I2C1_BASE, TSL2591_GAIN_MED);
  I2CMasterControl(I2C1_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);
  while (I2CMasterBusy(I2C1_BASE));
  //
  // Power ON, and enable ALS, ALS Interrupts, and No Persist Interrupts
  //
  // Specify that we want to communicate to device address with an intended
  // write to bus
  I2CMasterSlaveAddrSet(I2C1_BASE, TSL2591_ADDR, false);
  // Place command in the register
  I2CMasterDataPut(I2C1_BASE, TSL2591_COMMAND_BIT|TSL2591_REGISTER_ENABLE);
  // Send control byte and register address byte to slave device
  I2CMasterControl(I2C1_BASE, I2C_MASTER_CMD_BURST_SEND_START);
  while (I2CMasterBusy(I2C1_BASE));
  I2CMasterDataPut(I2C1_BASE,TSL2591_ENABLE_POWERON|TSL2591_ENABLE_AEN|
  TSL2591_ENABLE _AIEN|TSL2591_ENABLE_NPIEN);
  I2CMasterControl(I2C1_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);
  while (I2CMasterBusy(I2C1_BASE));
}

//
// Initialize Light Sensor
//
void InitTSL2591()
{
  uint8_t temp_data[0];
  I2C1_write(TSL2591_ADDR, TSL2591_COMMAND_BIT|TSL2591_REGISTER_DEVICE_ID);
  I2C1_read(TSL2591_ADDR, temp_data, 1);
  DevID = temp_data[0];
  if (DevID == 0x50)
  {
    UARTprintf("Device Found...");
  }
  else
  {
    UARTprintf("\n Device Not Found");
  }
  TSL2591_enable(); //turn on light sensor
}

//
// Calculate for Luminosity (refer to TSL2561 datasheet)
//
uint32_t getLuminosity (uint8_t channel)
{
  float atime = 100.0F, again=25.0F; //for 100ms integration time and medium
//gain
  float cpl, lux1, lux2, lux;
  uint16_t ch0, ch1;
  uint16_t temp_data1[2], temp_data2[2];
  //Get full luminosity
  uint32_t x, y;
  I2C1_write(TSL2591_ADDR, TSL2591_COMMAND_BIT | TSL2591_REGISTER_CHAN1_LOW);
  I2C1_read(TSL2591_ADDR, temp_data1, 2);
  ch1 = temp_data1[0];
  x = ch1;
  y = x << 16; //bitshift left 16bits
  I2C1_write(TSL2591_ADDR, TSL2591_COMMAND_BIT | TSL2591_REGISTER_CHAN0_LOW);
  I2C1_read(TSL2591_ADDR, temp_data2, 2);
  ch0 = temp_data2[0];
  y |= ch0; //bitwise OR => shortcut for adding ch0 to y
  cpl = (atime * again) / TSL2591_LUX_DF;
  lux1 = ((float)ch0 - (TSL2591_LUX_COEFB * (float)ch1)) / cpl;
  lux2 = ((TSL2591_LUX_COEFC * (float)ch0) - (TSL2591_LUX_COEFD * (float)ch1))
/ cpl;
  lux = lux1 > lux2 ? lux1 : lux2; //if lux1 greater than lux2 then lux == lux1
  //else lux2
  
  return y;
}

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
// ESP8266 FUNCTIONS
//------------------------------------------------------------------------------

//
// Initialize UART for ESP8266 use
//
void InitESPUART(void)
{
  // Enable the GPIO Peripheral port B
  SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
  // Enable UART port 1
  SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);
  // Configure the pin muxing for I2C1 functions on port PB0 and PB1.
  GPIOPinConfigure(GPIO_PB0_U1RX);
  GPIOPinConfigure(GPIO_PB1_U1TX);
  GPIOPinTypeUART(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
  // Use the internal 16MHz oscillator as the UART clock source.
  UARTClockSourceSet(UART1_BASE, UART_CLOCK_PIOSC);
  // Enable and initialize the UART1 master module. Use the system clock for
  // the UART1 module.
  UARTConfigSetExpClk(UART1_BASE, 16000000, 115200, (UART_CONFIG_WLEN_8 |
  UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
  // Enable UART1
  UARTEnable(UART1_BASE);
}

//
// Send a direct AT command line to ESP8266
//
void SendATCommand(char *cmd)
{
  while(UARTBusy(UART1_BASE));
  while(*cmd != '\0')
  {
    UARTCharPut(UART1_BASE, *cmd++);
  }
  UARTCharPut(UART1_BASE, '\r'); //CR
  UARTCharPut(UART1_BASE, '\n'); //LF
}

int recvString(char *target, char *data, int timeout, bool check)
{
  int i=0;
  char a;
  unsigned long start = millis();
  while (millis() - start < timeout)
  {
    while(UARTCharsAvail(UART1_BASE))
    {
      a = UARTCharGet(UART1_BASE);
      if(a == '\0') continue;
      data[i]= a;
      i++;
    }
    if(check)
    {
      if (SearchIndexOf(data, target) != -1)
      {
        break;
      }
    }
  }
  
  return 0;
}

bool recvFind(char *target, int timeout,bool check)
{ 
  recvString(target, ReceivedData, timeout, check);
  if (SearchIndexOf(ReceivedData, target) != -1)
  {
    return true;
  }
  
  return false;
}

bool recvFindAndFilter(char *target, char *begin, char* end, char *data, int timeout)
{ 
  recvString(target, ReceivedData, timeout, true);
  if (SearchIndexOf(ReceivedData, target) != -1)
  { 
    int index1 = SearchIndexOf(ReceivedData, begin); int index2 = SearchIndexOf(ReceivedData, end);
    if (index1 != -1 && index2 != -1)
    {
      index1 += strlen(begin); Substring(ReceivedData,data,index1, index2);
      return true;
    }
  }
  data = "";
  
  return false;
}

// General test command
bool ATesp(void)
{ 
  memset(ReceivedData, 0, sizeof(ReceivedData));
  SendATCommand("AT");
  
  return recvFind("OK",5000, true);
}

// Restart module command
bool RSTesp(void)
{ 
  memset(ReceivedData, 0, sizeof(ReceivedData));
  SendATCommand("AT+RST");
  
  return recvFind("OK",5000, false);
}

// WIFI mode command
bool CWMODEesp(void)
{ 
  memset(ReceivedData, 0, sizeof(ReceivedData));
  SendATCommand("AT+CWMODE=1"); //Station Mode (client)
  //SendATCommand("AT+CWMODE=2"); //AP Mode (host)
  //SendATCommand("AT+CWMODE=3"); //AP + Station Mode
  
  return recvFind("OK",5000, true);
}

// Join the AP command
bool CWJAPesp(void)
{ 
  memset(ReceivedData, 0, sizeof(ReceivedData));
  SendATCommand("AT+CWJAP=\"ENTERYOURSSIDHERE\",\"ENTERYOURPASSWDHERE\""); //Your Wifi: NetworkName, Password
  
  return recvFind("OK",10000, true);
}

// Quit the AP command
bool CWQAPesp(void)
{ 
  memset(ReceivedData, 0, sizeof(ReceivedData));
  SendATCommand("AT+CWQAP");
  
  return recvFind("OK",10000, true);
}

// Set multiple connection command
bool CIPMUXesp(void)
{ 
  memset(ReceivedData, 0, sizeof(ReceivedData));
  SendATCommand("AT+CIPMUX=0"); //single connection
  SendATCommand("AT+CIPMUX=1"); 
  
  return recvFind("OK",5000, true);
}

// Check firmware version command
bool ATGMResp(char *version)
{ 
  memset(ReceivedData, 0, sizeof(ReceivedData));
  SendATCommand("AT+GMR");
  
  return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", version,10000);
}

// List the AP command
bool aCWLAPesp(char *list)
{ 
  memset(ReceivedData, 0, sizeof(ReceivedData));
  SendATCommand("AT+CWLAP");
  
  return recvFindAndFilter("OK","\r\r\n", "\r\n\r\nOK", list,15000);
}

// Get IP address command
bool aCIFSResp(char *list)
{ 
  memset(ReceivedData, 0, sizeof(ReceivedData));
  SendATCommand("AT+CIFSR");
  
  return recvFindAndFilter("OK","\r\r\n", "\r\n\r\nOK", list,15000);
}

// Set the server timeout command
bool CIPSTOesp(void)
{ 
  memset(ReceivedData, 0, sizeof(ReceivedData));
  SendATCommand("AT+CIPSTO=10000");
  
  return recvFind("OK",2000, true);
}

// Set up TCP or UDP connection command
bool CIPSTARTesp(void)
{ 
  memset(ReceivedData, 0, sizeof(ReceivedData));
  SendATCommand("AT+CIPSTART=\"TCP\",\""IP"\","PORT""); //Server IP and Port: such as 192.255.0.100, 9999
  
  return recvFind("OK",2000, true);
}

// Close TCP or UDP connection command
bool CIPCLOSEesp(void)
{ 
  memset(ReceivedData, 0, sizeof(ReceivedData));
  SendATCommand("AT+CIPCLOSE");
  
  return recvFind("OK",5000, true);
}

// Send data command
bool CIPSENDesp(char *text)
{
  int len = strlen(text)+2; //find text length plus 2 to include "\r" and "\n"
  itoa(len,str); //converts int len into string str
  char* AT_CMD_SEND = "AT+CIPSEND=";
  char CMD_TEXT[128];
  strcpy(CMD_TEXT,AT_CMD_SEND); //copies string pointed to by CMD_SEND to
  //CMD_TEXT
  strcat(CMD_TEXT,str); //appends string point to by str to the end of the
  //string pointed to by CMD_TEXT

  memset(ReceivedData, 0, sizeof(ReceivedData));
  SendATCommand(CMD_TEXT); //sends "AT+CIPSEND=" + str (which is the text
//length)
  delay(5); //wait for AT pointer
  SendATCommand(text);
  
  return recvFind("SEND OK",2000, true);
}

// Reset hardware pins
void HardwareReset()
{
  GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_0); //Output
  GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_4, 0x00); //LOW ->Reset to ESP8266
  delay(50);
  GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_0); //Output ->// Open drain;
  //reset -> GND
  delay(10);
  GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_0); //Input ->// Back to high-
  //impedance pin state
  delay(3000);
}
//------------------------------------------------------------------------------

//
// Initialize UART for general purpose sending & receiving
//
void InitUART(void)
{
  // Enable the GPIO Peripheral port A
  SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
  // Enable UART port 0
  SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
  // Configure the pin muxing for for UART mode.
  GPIOPinConfigure(GPIO_PA0_U0RX);
  GPIOPinConfigure(GPIO_PA1_U0TX);
  GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
  // Use the internal 16MHz oscillator as the UART clock source.
  UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
  // Initialize the UART for console I/O.
  UARTStdioConfig(0, 115200, 16000000);
}

//
// Initialize GPIO port F pins for LED use
//
void InitLED(void)
{
  SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
  GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE,GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);
  GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0x00); //turn off LED
  GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0x00); //turn off LED
  GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0x00); //turn off LED
  SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
  GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_0);
  GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_0, 0x00);
  GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0x02); //turn on red LED
}

//------------------------------------------------------------------------------
// MAIN
//------------------------------------------------------------------------------
int main(void)
{
  // Set local variable
  bool TaskStatus;
  // Set the clocking to run directly from the external crystal/oscillator.
  SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
  InitLED(); //initialize LEDs
  timerInit(); //set timer clock and interrupt
  InitI2C1(); //initialize I2C
  InitUART(); //initialize UART
  HardwareReset(); //reset pins

  UARTprintf("Initializing TSL2591...");
  InitTSL2591(); //initialize light sensor
  UARTprintf("COMPLETE \n");
  UARTprintf("Initializing ESP8266...");
  InitESPUART();
  UARTprintf("COMPLETE \n");
  UARTprintf("Starting ESP8266...\n");
  delay(1000);
  TaskStatus = ATesp();
  if (TaskStatus)
  {
    UARTprintf("ATesp OK!\n");
  }
  else
  {
    UARTprintf("ATesp FAIL!\n");
  }

  TaskStatus = RSTesp();
  if (TaskStatus)
  {
    UARTprintf("RSTesp OK!\n");
  }
  else
  {
    UARTprintf("RSTesp FAIL!\n");
  }
  
  TaskStatus = CWMODEesp();
  if (TaskStatus)
  {
    UARTprintf("CWMODEesp OK!\n");
  }
  else
  {
    UARTprintf("CWMODEesp FAIL!\n");
    while(true)
    {
      UARTprintf("Trying to connect to WI-FI...");
      TaskStatus = CWJAPesp();
      if(TaskStatus)
      {
        UARTprintf("COMPLETE\n");
        break;
      }
      else
      {
        UARTprintf("FAILED\n");
      }
    }
    
  GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0x00); //turn off LED
  TaskStatus = CIPMUXesp();
  while(true)
  {
  TaskStatus = ProcessRoutine();
    if(TaskStatus)
    {
      CIPCLOSEesp();
      GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0x00); //turn off LED
      GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0x04); //turn on blue LED
      delay(1000); //wait for 1 second refresh
    }
    else
    {
      delay(10);
      CWQAPesp();

      GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0x00); //Turn off Blue
//Led
      GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0x02); //Turn on Red
//Led
    }
  }
}

//
// Process routine containing TSL2591 data and ESP8266 transfer
//
bool ProcessRoutine()
{
  // Set local variables
  bool status;
  uint32_t raw_data;
  uint16_t IR, FULL, VISIBLE;
  char UPDATE_str[128],
  str_raw_data[128],
  str_FULL[128],
  str_IR[128],
  str_VISIBLE[128];
  UARTprintf("Trying to connect to server...");
  while(true)
  {
    status = CIPSTARTesp(); //connect to IP address
    if(status)
    {
      UARTprintf("COMPLETE\n");
      break;
    }
  delay(50);
  }
  
  GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0x00);
  GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0x08); //turn on green LED -> READY
  // Get light data from TSL2591
  raw_data = getLuminosity(TSL2591_FULLSPECTRUM);
  itoa(raw_data, str_raw_data);
  FULL = raw_data & 0xFFFF;
  itoa(FULL, str_FULL);
  //FULL = getLuminosity(TSL2591_FULL);
  IR = raw_data >> 16;
  itoa(IR, str_IR);
  //IR = getLuminosity(TSL2591_INFRARED);
  VISIBLE = FULL - IR;
  itoa(VISIBLE,str_VISIBLE);
  //VISIBLE = getLuminosity(TSL2591_VISIBLE);
  TSL2591_disable(); //turn off light sensor

  // Display TSL2591 data
  UARTprintf("\n-------- TSL2591 DATA ----------");
  UARTprintf("\n Raw_data: %i", raw_data);
  UARTprintf("\n FULL: %i", FULL);
  UARTprintf("\n IR: %i", IR);
  UARTprintf("\n VISIBLE: %i", VISIBLE);
  UARTprintf("\n------------------------------------\n");
  memset(ReceivedData, 0, sizeof(ReceivedData)); //clear
  // Send data to thingspeak server to field 1-4
  UARTprintf("\nSending Data...");
  char *UPDATE_url =
"GEThttps://api.thingspeak.com/update?api_key=INSERTYOURTHINGSPEAKAPIKEYHERE";
  strcpy(UPDATE_str, UPDATE_url);
  strcat(UPDATE_str, "&field1="); //raw_data graph
  strcat(UPDATE_str, str_raw_data);
  strcat(UPDATE_str, "&field2="); //full-spectrum graph
  strcat(UPDATE_str, str_FULL);
  strcat(UPDATE_str, "&field3="); //infrared graph
  strcat(UPDATE_str, str_IR);
  strcat(UPDATE_str, "&field4="); //visible graph
  strcat(UPDATE_str, str_VISIBLE);
  CIPSENDesp(UPDATE_str);
  UARTprintf("Complete\n");
  
  return true;
}
//------------------------------------------------------------------------------

char *Substring(char *src, char *dst, int start, int stop)
{
  int len = stop - start;
  strncpy(dst, src + start, len);
  
  return dst;
}

int SearchIndexOf(char src[], char str[])
{
  int i, j, firstOcc;
  i = 0, j = 0;
  while (src[i] != '\0')
  {
    while (src[i] != str[0] && src[i] != '\0')
      i++;
      
    if (src[i] == '\0')
      return (-1);
      
    firstOcc = i;

    while (src[i] == str[j] && src[i] != '\0' && str[j] != '\0')
    {
      i++;
      j++;
    }
  
    if (str[j] == '\0')
      return (firstOcc);
    
    if (src[i] == '\0')
      return (-1);
    
    i = firstOcc + 1;
    j = 0;
  }
  
  return (-1);
}

//
// INT to String Function
//
char* itoa(int i, char b[])
{
  char const digit[] = "0123456789";
  char* p = b;
  if(i<0)
  {
    *p++ = '-';
    i *= -1;
  }
  
  int shifter = i;
  do
  {
    ++p;
    shifter = shifter/10;
  }while(shifter);
  
  *p = '\0';
  do
  {
    *--p = digit[i%10];
    i = i/10;
  }while(i);
  
  return b;
}

Credits

HyperChiicken

11 projects • 28 followers

I cobble things together :]

Cloud-Based Ambient Light Data Logger

Things used in this project

Hardware components

Software apps and online services

Story

System Overview

Implementation Details

The Thing-in-Action

Troubleshooting

Schematics

Schematic

Code

IOT_TSL2591_DataLogger.c

Credits

HyperChiicken

Comments

Embed the widget on your own site

Cloud-Based Ambient Light Data Logger

Cloud-Based Ambient Light Data Logger

Things used in this project

Hardware components

Software apps and online services

Story

System Overview

Implementation Details

The Thing-in-Action

Troubleshooting

Schematics

Schematic

Code

IOT_TSL2591_DataLogger.c

Credits

HyperChiicken

Comments

Related channels and tags