Electronic Experiments

The Wall

2021-12-25T15:11:00.002+02:00

PCF8574 [I2C Module] & LCD Display

On today article i will show how to set up a I2C communication to manipulate an LCD display.

DHT22 & LCD Shield

In this article i will describe to you, how to develop a home weather station using the DHT22 temperature/humidity sensor.
The development board used for this experiment will be the Arduino UNO and the measured values will be displayed on LCD Shield board.

Please Enjoy !

Experiment nr.02 - GSM Click (Warning Action via SMS)

This is an Warning Action via SMS project who are able to send a warning message for a given situation.
In this experiment "the given situation" is one button set on RD7.
You must to configure the phone number on which the SMS warning will be sent.

Experiment nr.01 - GSM Click (Temperature & Controll via SMS)

Program uses GSM module GL865 for sending and receiving SMS.
The scenario of this experiment is as follows:
User can interrogate the EasyPIC v7 development board via SMS, and receive
the status situation of the motherboard.
Port RD0 and RD1 are used to control two Fans and port RA0 is used to
measure the temperature of LM35 sensor.

Real Time Clock [DS1307 with Set Functions] & DS18B20

In this article we will talk about DS1307, created by the Maxim company. This IC (Integrated Circuit) could help as, when we want to know what time is it. Interesting fact is that we have added a set functions to this clock. At the core of this experiment, will be the PIC16F876A.

Distance Sensor Sharp 2YOA21 & LCD

In the current article I intend to display the measured distance, between sensor and some object, on the LCD with 2x16 characters.
If I succeeded or not, you will find only if you will hit the above link in this section.

Dot Matrix Led 8x8 & MAX 7219

In this article we will discuss about functions of MAX 7219, created by the Maxim company. This IC (Integrated Circuit) could help as, when we whant to work with digits and LEDs. At the core of this experiment, will be the PIC16F876A.

NUCLEO-F767ZI

2021-12-18T14:52:00.001+02:00

555 Timer - Turn off delay circuit

2021-12-11T14:38:00.001+02:00

555 Timer - Turn on delay circuit

2021-12-04T13:00:00.001+02:00

ESP8266 (ESP-12E)

2020-12-27T03:31:00.000+02:00

...stay tuned.

Multi-function Shield

2019-01-13T02:02:00.000+02:00

The Multi-function Shield (HCARDU0085) designed for Arduino Uno / Leonardo board has a large range of features which makes it ideal for experiments, learning and advanced projects development.

Besides the feature rich range of components fitted to the shield, there are also a range of expansion headers for convenient interfacing of external modules and components. The shield includes R3 type headers for easy connection to Arduino boards.

Note:

This shield includes a header for attaching an IR reciver (U4-IR-2). The pinout order is not suitable for directly connecting a SFH506-38. However the order is compatible with 1838B Infrared IR receiver (HCSENS0014).

Please always check the schematic before connecting external components.

Features

An LED display module (four-digit, seven-segment)
Two serial LED display driver ICs(74HC595)
Four LEDs
A multi-turn trimpot (10KOhm)
Three pushbuttons
A piezo-buzzer
A port for DS18B20 temperature sensor
A port for TSOP1838 infrared receiver module
A APC220 wireless module interface (serial/UART interface)
A reset button

Pin Layout

Serial LED display driver (74HC595) - Latch 4, Clock 7, Data 8
Four LEDs - Pin 10,11,12,13
Trimpot (10KOhm)-Pin A0
Three pushbuttons - Pin A1,A2,A3
Piezo-buzzer - Pin 3 (digital on/off)
DS18B20/LM35 temperature sensor - Pin A4
Infrared receiver module (remote control) - Pin 2
Header for APC220 shield - Gnd, 5V , 0, 1 (rx/tx)
Reset pushbutton - Gnd
Free pins header (PWM) - 5, 6, 9, A5

Circuit diagram

Looking at the schematic, it looks like using the DS18B20 temperature sensor (and the infrared receiver module) requires a bit of research. As indicated in the top silkscreen layout, the flat (labeled) side of the temperature sensor must face the bottom side of the Multi-function shield fronting the three pushbuttons. Also, the legend “U5-18b20-LM35-A4” has an arrow pointing up toward the middle pin (A4) of the temperature sensor header (GND on the left, DQ in the middle, and 5 V on the right). The jumper J1 feeds 5 V to the middle pin DQ through a 10K resistor (pull-up configuration). Similarly, pin notation for the infrared receiver module is OUT (D2) - GND - 5V.

Some Pictures:

The Multifunction Shield Library

http://files.cohesivecomputing.co.uk/MultiFuncShield-Library.zip

Code examples from the source

http://arduinolearning.com/code/multi-function-shield-examples.php

PCF8574 [I2C Module] & LCD Display

2018-12-31T02:39:00.000+02:00

Overview

The PCF8574 is a silicon CMOS circuit. It provides general purpose remote I/O expansion for most microcontroller families by way of the I2C interface [serial clock (SCL), serial data (SDA)].

The device features an 8-bit quasi-bidirectional I/O port (P0–P7), including latched outputs with high-current drive capability for directly driving LEDs. Each quasi-bidirectional I/O can be used as an input or output without the use of a data-direction control signal. At power on, the I/Os are high. In this mode, only a current source to VCC is active.

This 8-bit input/output (I/O) expander for the two-line bidirectional bus (I2C) is designed for 2.5-V to 6-V VCC operation.

Features

Low Standby-Current Consumption of 10 µA Max
I2C to Parallel-Port Expander
Open-Drain Interrupt Output
Compatible With Most Microcontrollers
Latched Outputs With High-Current Drive
Capability for Directly Driving LEDs
Latch-Up Performance Exceeds 100 mA
Per JESD 78, Class II
Package: DIP16, SO16 and SSOP20.

Applications

Telecom Shelters: Filter Units
Servers
Routers (Telecom Switching Equipment)
Personal Computers
Personal Electronics
Industrial Automation
Products with GPIO-Limited Processors

Diagram

Pinning

Functional Description

Addressing

We have to pay real attention on this section if we want to communicate with the chip without spending a lot of time to understand why it doesn't work.

In my particular case the chip address, generated by Arduino I2C Scanner, was 111111 = 0x3F and it works well with Arduino Uno board.
The things got messy when I had tried to use the chip with a PIC controller on the regular hardware. I had dug into the issue and I've discovered that string address wasn't complete because it doesn't contained the last state bit (R/W function), which in my case was 0 logic. So the complete string become 1111110 = 0x7E, and the module has revived.

Interrupt output

Interrupts are used when we want to use more than one device via I2C bus.

Application Example

I2C Module for LCD 1602, 1604, 2004 Displays.

Test Example

I have a very good confident into PicKit2 Programmer, that's why often it will be seen into my photos.

Code Example

Written in MikroC Pro for PIC v7.2.0


/************************************************************************
*  Project name: I2C(PCF8574) & LCD1602
*  Description: Communication test
*    Hardware configuration is:
*             IC PCF8574 is connected with our microcontroller by RC3=SCL,
*             RC4=SDA (I2C Connections), +5vdc and circuit ground
*             Message example written on 16x02 LCD characters:
*             ------------------
*             |I2C LCD 16x2    |
*             |PIC16F876A 8 MHz|
*             ------------------
*  Adapted by:
*    Aureliu Raducu Macovei, 2018.
*  Test configuration:
*    MCU:                        PIC16F876A;
*    Test.Board:                 WB-106 Breadboard 2420 dots;
*    SW:                         MikroC PRO for PIC 2018 (version v7.2.0);
*  Configuration Word:
*    Oscillator:                 HS (8Mhz)on pins 9 and 10;
*    Watchdog Timer:             OFF;
*    Power up Timer:             OFF;
*    Browun Out Detect:          ON;
*    Low Voltage Program:        Disabled;
*    Data EE Read Protect:       OFF;
*    Flash Program Write:        Write Protection OFF;
*    Background Debug:           Disabled;
*    Code Protect:               OFF
************************************************************************/
#define _LCD_FIRST_ROW          0x80     //Move cursor to the 1st row
#define _LCD_SECOND_ROW         0xC0     //Move cursor to the 2nd row
#define _LCD_THIRD_ROW          0x94     //Move cursor to the 3rd row
#define _LCD_FOURTH_ROW         0xD4     //Move cursor to the 4th row
#define _LCD_CLEAR              0x01     //Clear display
#define _LCD_RETURN_HOME        0x02     //Return cursor to home position, returns a shifted display to
                                         //its original position. Display data RAM is unaffected.
#define _LCD_CURSOR_OFF         0x0C     //Turn off cursor
#define _LCD_UNDERLINE_ON       0x0E     //Underline cursor on
#define _LCD_BLINK_CURSOR_ON    0x0F     //Blink cursor on
#define _LCD_MOVE_CURSOR_LEFT   0x10     //Move cursor left without changing display data RAM
#define _LCD_MOVE_CURSOR_RIGHT  0x14     //Move cursor right without changing display data RAM
#define _LCD_TURN_ON            0x0C     //Turn Lcd display on
#define _LCD_TURN_OFF           0x08     //Turn Lcd display off
#define _LCD_SHIFT_LEFT         0x18     //Shift display left without changing display data RAM
#define _LCD_SHIFT_RIGHT        0x1E     //Shift display right without changing display data RAM

// LCD Definitions
#define LCD_ADDR 0x7E                    // This is PCF8574 adress. On mine pcb "MH" series the adress is 0x3F or 0x7E

// Lcd constants
char txt1[] = "I2C LCD 16x2";
char txt2[] = "PIC16F876A 8 MHz";

void I2C_LCD_Cmd(char out_char) {

    char hi_n, lo_n;
    char rs = 0x00;

    hi_n = out_char & 0xF0;
    lo_n = (out_char << 4) & 0xF0;

    I2C1_Start();
    I2C1_Is_Idle();
    I2C1_Wr(LCD_ADDR);
    I2C1_Is_Idle();
    I2C1_Wr(hi_n | rs | 0x04 | 0x08);
    I2C1_Is_Idle();
    Delay_us(50);
    I2C1_Wr(hi_n | rs | 0x00 | 0x08);
    I2C1_Is_Idle();
    Delay_us(100);
    I2C1_Wr(lo_n | rs | 0x04 | 0x08);
    I2C1_Is_Idle();
    Delay_us(50);
    I2C1_Wr(lo_n | rs | 0x00 | 0x08);
    I2C1_Is_Idle();
    I2C1_stop();

    if(out_char == 0x01)Delay_ms(2);
}

void I2C_LCD_Chr(char row, char column, char out_char) {

    char hi_n, lo_n;
    char rs = 0x01;

    switch(row){

        case 1:
        I2C_LCD_Cmd(0x80 + (column - 1));
        break;
        case 2:
        I2C_LCD_Cmd(0xC0 + (column - 1));
        break;
        case 3:
        I2C_LCD_Cmd(0x94 + (column - 1));
        break;
        case 4:
        I2C_LCD_Cmd(0xD4 + (column - 1));
        break;
    };

    hi_n = out_char & 0xF0;
    lo_n = (out_char << 4) & 0xF0;

    I2C1_Start();
    I2C1_Is_Idle();
    I2C1_Wr(LCD_ADDR);
    I2C1_Is_Idle();
    I2C1_Wr(hi_n | rs | 0x04 | 0x08);
    I2C1_Is_Idle();
    Delay_us(50);
    I2C1_Wr(hi_n | rs | 0x00 | 0x08);
    I2C1_Is_Idle();
    Delay_us(100);
    I2C1_Wr(lo_n | rs | 0x04 | 0x08);
    I2C1_Is_Idle();
    Delay_us(50);
    I2C1_Wr(lo_n | rs | 0x00 | 0x08);
    I2C1_Is_Idle();
    I2C1_stop();
}

void I2C_LCD_Chr_Cp(char out_char) {

    char hi_n, lo_n;
    char rs = 0x01;

    hi_n = out_char & 0xF0;
    lo_n = (out_char << 4) & 0xF0;

    I2C1_Start();
    I2C1_Is_Idle();
    I2C1_Wr(LCD_ADDR);
    I2C1_Is_Idle();
    I2C1_Wr(hi_n | rs | 0x04 | 0x08);
    I2C1_Is_Idle();
    Delay_us(50);
    I2C1_Wr(hi_n | rs | 0x00 | 0x08);
    I2C1_Is_Idle();
    Delay_us(100);
    I2C1_Wr(lo_n | rs | 0x04 | 0x08);
    I2C1_Is_Idle();
    Delay_us(50);
    I2C1_Wr(lo_n | rs | 0x00 | 0x08);
    I2C1_Is_Idle();
    I2C1_stop();
}

void I2C_LCD_Init() {

    char rs = 0x00;

    I2C1_Start();
    I2C1_Is_Idle();
    I2C1_Wr(LCD_ADDR);
    I2C1_Is_Idle();

    Delay_ms(30);

    I2C1_Wr(0x30 | rs | 0x04 | 0x08);
    I2C1_Is_Idle();
    Delay_us(50);
    I2C1_Wr(0x30 | rs | 0x00 | 0x08);
    I2C1_Is_Idle();

    Delay_ms(10);

    I2C1_Wr(0x30 | rs | 0x04 | 0x08);
    I2C1_Is_Idle();
    Delay_us(50);
    I2C1_Wr(0x30 | rs | 0x00 | 0x08);
    I2C1_Is_Idle();

    Delay_ms(10);

    I2C1_Wr(0x30 | rs | 0x04 | 0x08);
    I2C1_Is_Idle();
    Delay_us(50);
    I2C1_Wr(0x30 | rs | 0x00 | 0x08);
    I2C1_Is_Idle();

    Delay_ms(10);

    I2C1_Wr(0x20 | rs | 0x04 | 0x08);
    I2C1_Is_Idle();
    Delay_us(50);
    I2C1_Wr(0x20 | rs | 0x00 | 0x08);
    I2C1_Is_Idle();
    I2C1_Stop();

    Delay_ms(10);

    I2C_LCD_Cmd(0x28);
    I2C_LCD_Cmd(0x06);
}

void I2C_LCD_Out(char row, char col, char *text) {
    while(*text)
    I2C_LCD_Chr(row, col++, *text++);
}

void I2C_LCD_Out_Cp(char *text) {
    while(*text)
    I2C_LCD_Chr_Cp(*text++);
}

void main() {

    TRISA = 0x00;
    PORTA = 0x00;

    I2C1_Init(100000);

    I2C_LCD_Init();
    I2C_LCD_Cmd(_LCD_CURSOR_OFF);
    I2C_LCD_Cmd(_LCD_CLEAR);
    I2C_Lcd_Out(1,1,txt1);                 // Write text in first row
    I2C_Lcd_Out(2,1,txt2);                 // Write text in second row

    while(1) {

    }
}

DHT22 & LCD Shield

2018-11-17T20:38:00.001+02:00

In this article I will describe to you, how to develop a home weather station using the DHT22 temperature/humidity sensor.

TECHNICAL DETAILS

Model: Power supply:	DHT22 3.3-6V DC (2.5mA max current use during conversion (while requesting data))
Output signal:	Digital signal via single-bus
Sensing element:	Polymer capacitor
Operating range:	Humidity: 0-100%RH; Temperature: -40~80Celsius
Accuracy:	Humidity +-2%RH(Max +-5%RH); Temperature <+-0.5 Celsius
Resolution or sensitivity:	Humidity 0.1%RH; Temperature 0.1Celsius
Repeatability:	Humidity +-1%RH; Temperature+-0.2Celsius
Humidity hysteresis:	+-0.3%RH
Long-term Stability:	+-0.5%RH/year
Sensing period:	Average: 2s
Interchangeability:	fully interchangeable
Dimensions:	Small size 14185.5mm; Big size 22285mm
Weight (just the DHT22):	2.4g

Hardware setup:

The development board used for this experiment will be the Arduino UNO and the measured values will be displayed on 1602 LCD Keypad Shield board.

DHT22 is a low-cost digital temperature and humidity sensor. It uses a capacitive humidity sensor and a thermistor to measure the surrounding air, and generate out a digital signal on the data pin (which means no analog input pins needed). It's fairly simple to use, but requires careful timing to collect data. The only real downside of this sensor is you can only get new data from it once every 2 seconds, so when using DHT22 library, sensor readings can be up to 2 seconds old.

Simply connect the first pin on the left to 3-5V power, the second pin to your data input pin and the rightmost pin to ground. Although it uses a single-wire to send data it is not Dallas One Wire compatible! If you want multiple sensors, each one must have its own data pin.

In my particular case 1602 LCD Keypad Shield ICSP connector (VCC, D11, GND) was the easiest way to connect my DHT22 sensor. Keypad functionality wouldn’t be used on this article.

Some pictures from the surgery.

On below video we can see the Arduino UNO board in action.

Software:

The program is written in Arduino IDE software (version v1.8.7).

Libraries used:

DHT 22 library

LiquidCrystal build in library

Below is presented the software approach for this project:


/*
'*******************************************************************************
'  Project name: DHT22 & LCD Shield
'  Description:
'   In this experiment i will describe to you, how to develop a home weather 
'   station using the DHT22 temperature/humidity sensor.       
'   Temperature will be displayed in Celsius Degree and the Umidity in percent
'   The delay between two consecutive reads is set to about 2.1 seconds.
'          Ex. of viewing display: 
'               ________________                         
'              |TEMP.: 24.60 C  |     
'              |Humy.: 54.40 %__|
'
'   Hardware configuration is:
'             DHS22 is connected to 1602 LCD Keypad Shield ICSP connector (vdc, d11,gnd).
'             The 1602 LCD Keypad Shield board is inserted into Arduino UNO standard connectors.
'
'  Written by:
'          Aureliu Raducu Macovei, 2018 (www.electronicexperiments.blogspot.com).
'
'  Test configuration:
'    MCU:                        ATmega328P;
'    Test.Board:                 Arduino UNO;
'    SW:                         Arduino IDE software (version v1.8.7);
'                                DHT Library from Arduino official website:
'                                https://playground.arduino.cc/Main/DHTLib
'*******************************************************************************
 */
 
#include LiquidCrystal.h // includes the LiquidCrystal Library
#include DHT22.h         // includes the DHT22 Library

#define DHT22_PIN 11

// Setup a DHT22 instance
DHT22 myDHT22(DHT22_PIN);

// initialize the library by associating any needed LCD interface pin
// with the arduino pin number it is connected to
const int rs = 8, en = 9, d4 = 4, d5 = 5, d6 = 6, d7 = 7;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  lcd.setCursor(0,0);
  lcd.print("    -DHT22 &-   ");
  lcd.setCursor(0,1);
  lcd.print("  --LCD 2x16--  ");
  delay(5000);
  lcd.setCursor(0,0);
  lcd.print("                ");
  delay(100);
  lcd.setCursor(0,1);
  lcd.print("                ");
  delay(500);
}

void loop(void)
{ 
  DHT22_ERROR_t errorCode;
  // The sensor can only be read from every 1-2s, and requires a minimum
  // 2s warm-up after power-on.
  delay(2100);

  errorCode = myDHT22.readData();
  switch(errorCode)
  {
    case DHT_ERROR_NONE:
      lcd.setCursor(0,0);     // Set the first row (location at which subsequent text written to the LCD will be displayed)
      lcd.print("Temp.: ");   // Print "Temp.:" on the LCD
      lcd.print(myDHT22.getTemperatureC());     // Print string temperature
      lcd.print(" C");                          // Prints "C" on the LCD
      lcd.setCursor(0,1);     // Set the second row (location at which subsequent text written to the LCD will be displayed)
      lcd.print("Humi.: ");   // Print "Humi.:" on the LCD
      lcd.print(myDHT22.getHumidity());         // Print string humidity
      lcd.print(" %");        // Prints "%" on the LCD
      break;
    case DHT_ERROR_CHECKSUM:
      lcd.print("check sum error ");
      lcd.print(myDHT22.getTemperatureC());
      lcd.print("C ");
      lcd.print(myDHT22.getHumidity());
       lcd.println("%");
      break;
    case DHT_BUS_HUNG:
      lcd.println("BUS Hung ");
      break;
    case DHT_ERROR_NOT_PRESENT:
      lcd.println("Not Present ");
      break;
    case DHT_ERROR_ACK_TOO_LONG:
      lcd.println("ACK time out ");
      break;
    case DHT_ERROR_SYNC_TIMEOUT:
      lcd.println("Sync Timeout ");
      break;
    case DHT_ERROR_DATA_TIMEOUT:
      lcd.println("Data Timeout ");
      break;
    case DHT_ERROR_TOOQUICK:
      lcd.println("Polled to quick ");
      break;
  }
}

Arduino Uno (Rev.3) Development Board

2018-11-17T16:53:00.000+02:00

Arduino Uno is a development board based on the ATmega328P microcontroller. It has 14 digital input/output pins (of which 6 can be used as PWM outputs), 6 analog inputs, a 16 MHz quartz crystal, a USB connection, a power jack, an ICSP header and a reset button. It contains everything needed to support the microcontroller; simply connect it to a computer with a USB cable or power it with a AC-to-DC adapter or battery to get started.

You can tinker with your UNO without worrying too much about doing something wrong, in worst case scenario you can replace the chip for a few dollars and start over again.

"Uno" means one in Italian and was chosen to mark the release of Arduino Software (IDE) 1.0. The

Uno board and version 1.0 of Arduino Software (IDE) were the reference versions of Arduino, now evolved to newer releases. The Uno board is the first in a series of USB Arduino boards, and the reference model for the Arduino platform; for an extensive list of current, past or outdated boards see the Arduino index of boards.

Tech Specs:

Microcontroller	ATmega328P
Operating Voltage	5V
Input Voltage (recommended)	7-12V
Input Voltage (limit)	6-20V
Digital I/O Pins	14 (of which 6 provide PWM output)
PWM Digital I/O Pins	6
Analog Input Pins	6
DC Current per I/O Pin	20 mA
DC Current for 3.3V Pin	50 mA
Flash Memory	32 KB (ATmega328P) of which 0.5 KB used by bootloader
SRAM	2 KB (ATmega328P)
EEPROM	1 KB (ATmega328P)
Clock Speed	16 MHz
LED_BUILTIN	13
Length	68.6 mm
Width	53.4 mm
Weight	25 g

Schematics:

Eagle Files.zip

Schematics.pdf

For more details please visit the Arduino website.

Arduino

2018-11-14T23:09:00.002+02:00

Arduino is an Italian open source electronic platform. The keystone of this amazing platform is the easiest way of using the hardware and the software tools (libraries, etc.).

Basically you can create everything you purpose, by sending a set of instructions to the microcontroller on the board. To be able to achieve that, you must use Arduino programming language (based on Wiring), and the Arduino Software (IDE), based on Processing.

Over the years Arduino has proved to be an excellent core for thousands of projects, from everyday objects to complex scientific instruments.

A worldwide community of enthusiasts - students, hobbyists, artists, programmers, and professionals has gathered around this open-source platform, their contributions have addedof accessible knowledge that can be of great help to novices up to an incredible amount and experts alike.

Arduino was born at the Ivrea Interaction Design Institute as an easy tool for fast prototyping, aimed at students without a background in electronics and programming. As soon as it reached a wider community, the Arduino board started changing to adapt to new needs and challenges, differentiating its offer from simple 8-bit boards to products for IoT applications, wearable, 3D printing, and embedded environments.

All Arduino boards are completely open-source, empowering users to build them independently and eventually adapt them to their particular needs. The software, too, is open-source, and it is growing through the contributions of users worldwide.

Arduino also simplifies the process of working with microcontrollers by offering some advantage for teachers, students, and interested amateurs over other systems:

Inexpensive Arduino boards are relatively inexpensive compared to other microcontroller platforms. The least expensive version of the Arduino module can be assembled by hand, and even the pre-assembled Arduino modules cost less than 40€.
Cross-platform The Arduino Software (IDE) runs on Windows, Macintosh OSX, and Linux operating systems. Most microcontroller systems are limited to Windows.
Simple, clear programming environment - The Arduino Software (IDE) is easy-to-use for beginners, yet flexible enough for advanced users to take advantage of as well. For teachers, it's conveniently based on the Processing programming environment, so students learning to program in that environment will be familiar with how the Arduino IDE works.
Open source and extensible software The Arduino software is published as open source tools, available for extension by experienced programmers. The language can be expanded through C++ libraries, and people wanting to understand the technical details can make the leap from Arduino to the AVR C programming language on which it's based. Similarly, you can add AVR-C code directly into your Arduino programs if you want to.
Open source and extensible hardware - The plans of the Arduino boards are published under a Creative Commons license, so experienced circuit designers can make their own version of the module, extending it and improving it. Even relatively inexperienced users can build the breadboard version of the module in order to understand how it works and save money.

How to start with Arduino ?!

See the getting started guide.

If you are looking for inspiration you can find a great variety of Tutorials on Arduino Project Hub.

Enjoy !!!

Ohm's Law

2018-11-07T01:15:00.001+02:00

Ohm's law

ICL7107

2017-12-31T12:21:00.004+02:00

test

TEST 2

ICL7106

2017-12-31T12:21:00.002+02:00

Adjustable Linear DC Bench Power Supply 0-40V/0-5A

2017-12-31T12:04:00.000+02:00

Measuring the DC current with a Microcontroller

2016-12-30T17:31:00.003+02:00

Basically the microcontrollers doesn’t have specific ports for measuring “dc” current or “ac” current, but they do have ADC (Analog to Digital Converter) and we can take advantage from this point of view so we can measure analog voltages of a certain range (usually 0-5vcc). The way of doing this is to place a resistance in series with the current path and measure the voltage drop across it. For this trick we need to use a resistor with a very low value just to not affect the original current of the load.

Resistors with a value less than 1 ohm are necessary and can be found in electronic stores. For a proper resistor placed into the circuit we have to pay attention for maximum current used. So, let’s say that you pick 0,47Ohm and the maximum current in the circuit is about 5 A, then the resistor should have the capacity of dissipation equal with: I²xR => 25 x 0,47 = 12 Watts of heat.

The appropriate design for the resistor is to create by yourself a coil from an Cu wire. For this test I have create one from 1,5 meter Ø 1,3 mm with enameled insulation on outer side, as shown below.

Coil

Now let’s measure its resistance, for example directly with an multimeter. My digital multimeter shows a value equal with 0,4 Ohm. Of course this measurement can have uncertainty, because of very small value which we measure and we don’t had to forget the fact that usually the digital multimeters does not show values beyond 1 decimal digit. Our resistance can be measured respecting the ohm’s law. We can connect in series with the coil resistance (Rs), a known resistor for example 47 ohm and supply a 5vcc as shown below. Next, measure the voltage across Rs and current through it separately using the multimeter. In the current case, I foud the measured voltage and current values to be 25.6mV and 88.6mA. This gives the resistance of the coil equal with 0.289 Ohm. (Rs = V/I).

Now, suppose that the range of current to be measured using this coil resistance is from 0-5A. Then the voltage drop across the coil resistance will be somewhere from 0 – 1.44 V. Because of its low range, this voltage signal may not be accurately measured with a microcontroller’s ADC module. In this case we will use an operational amplifier circuit for a voltage scaling mode. The entire schematic for this design is shown below.

As a description: in the above circuit Rs represent the low value current sensing resistor (our coil resistor) which is connected in series with the consumer (load resistor). Our purpose is to derive the load current (I). The low voltage drop across Rs is amplified by the non-inverting amplifier with 3.5. This is enough to linearly scale Vs (0 – 1.44 V) to Vo (0-5vcc).

At this point we have 0-5vcc signal that corresponds to 0-5A current through Rs. This voltage signal is now more appropriate for ADC conversion with Vref = 5vcc.

Vo= 3.5 x I x RS = 1I (Rs=0,289) => I = Vo/1.

For 10-bit ADC with Vref = 5vcc:

· Our resolution will be equal with: resolution = 5/1024 = 0.0049 (5mA).

· For input signal Vo, the ADC O/P will be Vo x 0,0049,

· Then I = ADC O/P x 0,0049/1 = ADC O/P x 0.0049.

Practical pictures with the experiments.

Logic Gates

2016-12-30T17:30:00.001+02:00

In this article I will put on the paper some theoretical knowledge about the Logic Gates.

I will discuss about:

· Logic Gates

· Truth Table

· Logic circuits/network

I will explain how logic gates are used and how truth tables are used to check if combinations of logic gates carry out the required functions.

Logic Gates

A large number of electronic circuits (in computers, control units, embedded systems etc.) are made up of logic gates. These process signals are represented by true or false flag. Signals can be represented as ON or OFF, 1 or 0 as well.

The most common symbols used to represent logic gates are shown below. For sure there are many different logic gates but we will concentrate on these.

Truth Table

Truth tables are used to show logic gate functions. The NOT gate has only one input, but all the others have two inputs.

When constructing a truth table, the binary values 1 and 0 are used. Every possible combination, depending on number of inputs, is produced. Basically, the number of possible combinations of 1s and 0s is 2n where n

= number of inputs. For example, 2 inputs have combinations, 3 inputs have combinations and so on. The next section shows how these truth tables are used.

Description of the logic gates

NOT gate

The output (X) is true (1 or ON) if:

Input A is NOT TRUE (0 or OFF)

Truth table for: X = NOT A

AND gate

The output (X) is true (1 or ON) if:

INPUT A AND INPUT B are BOTH

TRUE (1 or ON).

Truth table for: X = A AND B

OR gate

The output (X) is true (1 or ON) if:

INPUT A OR INPUT B is

TRUE (1 or ON).

Truth table for: X = A OR B

NAND gate

The output (X) is true (1 or ON) if:

INPUT A AND INPUT B are

NOT BOTH TRUE (1 or ON)

Truth table for: X = NOT A AND B

NOR gate

The output (X) is true (1 or ON) if:

INPUT A OR INPUT B are

NOT BOTH TRUE (1 or ON)

Truth table for: X = NOT A OR B

XOR gate

The output (X) is true (1 or ON) if:

INPUT A OR (NOT INPUT B)

OR (NOT INPUT A) OR INPUT B

is TRUE (1 or ON)

Truth table for:

X = A OR (NOT B) OR (NOT A) OR B

Logic circuits/network

Logic gates can be combined together to produce more complex logic circuits (networks).

The output from a logic circuit (network) is checked by producing a truth table.

Two different types of problem are considered here:

· drawing the truth table from a given logic circuit (network)

· designing a logic circuit (network) from a given problem and testing it by also drawing a truth table.

Example:

Produce a truth table from the following logic circuit (network).

Note:

To show how this works, we will split

the logic circuit into two parts (shown by

the dotted line).

First part

There are 3 inputs; thus we must have (8) possible combinations of 1s and 0s.

To find the values (outputs) at points P and Q, it is necessary to consider the truth tables for the NOR gate (output P) and the AND gate (output Q).

P = A NOR B

Q = B AND C

We get:

Second part

There are 8 values from P and Q which form the inputs to the last OR gate.

Hence we get X = P OR Q which gives the following truth table:

Which now gives us the final truth table for the logic circuit given at the start of the example:

So as you can see the possibilities are unlimited. You can design which circuit you like. Good luck.

Linear vs. Switch-Mode Power Supplies

2016-12-30T17:28:00.004+02:00

Intro

Linear power supplies were the mainstay of power conversion until the late 1970’s when the first

commercial switch-mode became available. Now apart from very low power wall mount linear power

supplies used for powering consumer items like cell phones and toys, switch-mode power supplies are

dominant.

So what is the difference in how they work?

Linear power supplies have a bulky steel or iron laminated transformer. This transformer has two purposes

- It provides a safety barrier for the low voltage output from the AC input and reduces and the input from

typically 115V or 230VAC to a much lower voltage around say 30VAC.

The low voltage AC output from the transformer is then rectified by two or four diodes and smoothed into

low voltage DC by large electrolytic capacitors.

That low voltage DC is then regulated into the output voltage of choice by a dropping the difference in

voltage across transistor or IC (the shunt regulator).

Switch-mode supplies are a lot more complicated. The 115V or 230VAC voltage is rectified and smoothed

by diodes and capacitors resulting in a high voltage DC. That DC is then converted into a safe, low

voltage, high frequency (typically switching at 100kHz to 500kHz) voltage using a much smaller ferrite

transformer and FETs or transistors. That voltage is then converted into the DC output voltage of choice by

another set of diodes, capacitors and inductors. Corrections to the output voltage due to load or input

changes are achieved by adjusting the pulse width of the high frequency waveform.

Sounds complicated? Yes, but the payoff is worth it!

The advantages and drawbacks of both technologies

Size: - A 50W linear power supply is typically 3 x 5 x 5.5”, whereas a 50W switch-mode can be as small as

3 x 5 x 1”. That’s a size reduction of 80%.

Weight: - A 50W linear weighs 4lbs, a corresponding switcher is 0.75lb. As the power level increases, so

does the weight. I personally remember a two-man lift needed for a 1000W linear. Today I carry a 2000W

in my carry-on luggage when I fly!

Input Voltage Range: - A linear has a very limited input range requiring that the transformer taps be

changed between different countries. Normally on the specification you will see

100/120/220/230/240VAC. This is because when input voltage drops more than 10%, the DC voltage to

the shunt regulator drops too low & the power supply cannot deliver the required output voltage. At input

voltages greater than 10%, too much voltage is delivered to the regulator resulting in overheating.

If a piece of equipment is tested in the US and shipped to Europe, or even to Mexico in some cases, the

transformer “taps” have to be manually changed. Forget to set the taps? The power supply will most

certainly blow the fuse, or may well be damaged.

Most switch-mode supplies will operate anywhere in the world (85 to 264VAC), from industrial areas in

Japan to the outback of Australia without any adjustment.

The switch-mode supply will also be able to withstand small losses of AC power in the range of 10-20ms

without affecting the outputs. A linear will not. No one will care if the AC goes missing for 1/100th of a

second when charging your phone, it will take 100 of these interruptions to delay the charge by one second!

Having a piece of equipment reboot 100 times a day will cause some heartbreak!

Efficiency: - A linear power supply because of its design will normally operate at around 60% efficiency

for 24V outputs, whereas a switch-mode is normally 80% or more. Efficiency is a measure of how much

energy the power supply wastes. This has to be removed with fans or heat sinks from the system.

For a 100W output linear, that waste would be 67W. A 100W switch-mode would be just 25W.

67W – 25W = 42W is the extra power lost

Doesn’t sound much, but don’t try touching a 40W light bulb! If the equipment were running 24 hours a

day, then the extra losses would be 367kW hours, even at $0.1 per kW hour, that’s an extra $37 a year for a

power supply that costs around $80.

As a quick note, in Europe, they are trying to limit those losses of all power supplies used by consumers

particularly when operating off load (as many products are left plugged in 24 hours a day). Imagine 250

million power supplies eating up a couple Watts. That equates to the output of a whole power station!

Reliability: - If reliability is calculated using a part count method, then the linear power supply will win.

With the design & quality improvements made in the last few years with switch-mode parts & technology,

in reality this advantage has been negated. I have demonstrated life testing data showing no failures after

over 1,000,000 hours on some Lambda products.

Electrical Ripple and Noise: - This is where the linear really scores!

5v Linear 5v Switch-mode

The linear obviously is a lot “quieter”, by up to a 10,000 times. The topology of the switch-mode supply

with its high frequency switching technology had to have a downside right? So if the noise is 10,000 times

worse, how can anyone use it? Sounds so bad.

In truth, there are some applications (studio mixers and very sensitive test equipment) where low electrical

noise is critical. The others? One of my first sales calls in the USA was to a manufacturer who built

semiconductor fabrication equipment. They used 8 really big linear units in a large box measuring 2x3x4

feet, it was heavy & actually being dictating the size of their end equipment. I told the engineer that I could

replace all eight units with two modular products measuring 5x5x10”. He laughed and said the noise

would be too great. I sent him samples and went to visit three weeks later. He was delighted with the

performance and has been a long term Lambda customer ever since.

Transient Response:

Transient response is how a power supply reacts to a (fast) change in load.

If the output load quickly changes from say full load to half load, the output voltage of the power supply

will rise (overshoot) before the internal control circuit has time to compensate, and then undershoot a little

less as the circuit over compensates. The length of time is takes from the instant of the load change to the

time the output voltage settles back into the load regulation limits can be critical to some loads. Here the

linear again outperforms the switch-mode.

For a 50% change in load the switch-mode will often take 3000us to recover. A linear supply will recover

in 50us.

Is this critical for all applications? There are a few specialized technologies where this is important and

most engineers will advise you if this is critical. For the other instances on board capacitors at the end load

& the inductance of cables is enough to reduce overshoot down ten-fold to where it no longer is a concern.

Low leakage currents and Conducted EMI:

A widely used technique in the design of switch-mode power supplies is to connect special capacitors from

the AC input terminals to Earth. This is a cost effective method to reduce noise from being fed back

through the input wires and potentially affecting other equipment.

These capacitors have a side effect of allowing a “leakage current” to be passed through the Earth or

ground cable. Many safety specifications have limits on the amount of this current that is allowed.

UL1950 allows 3mA, medical industrials less than a tenth of that. The gaming industry is even tighter.

As linear power supplies are “quieter” and do not need these capacitors, they simplify the system filtering,

and allow more of the system leakage current “budget” to be used for other parts like monitors. The overall

size of the system filter can also be reduced. How much that impacts cost & performance varies from

customer to customer.

Some switch-mode power supplies (like Lambda’s Vega series) are now available with increased internal

filtering that allows for low leakage versions to be offered to meet medical specifications.

In Summary:

	Linear	Switch-mode	Comments
Size	x	OK	Typically, 80% smaller
Weight	x	OK	Typically, 80% lighter
Input Voltage Range	x	OK	10% vs. up to 300% range
Efficiency	x	OK	Calculate it long term!
Reliability	OK	x / OK	Component count method, demonstrated probably equal
Ripple & Noise	OK	x / OK	Up to 10,000 times - often possible to overcome though
Transient Response	OK	x	Up to 100 times - necessary in specialized areas
Low leakage Current	OK	x / OK	Often used in medical systems, switch-mode gaining share

Hope that is useful all those aspects presented here.

As reference for the entire document, you can take a look on https://us.tdk-lambda.com

In this section, below I will share all tests and additional research made so far.

Quad 405-2

2016-12-30T17:27:00.004+02:00

With this article I intend to open the discussion about audio power amplifiers. My last passion about the world of microcontroller makes me to let a little bit behind the old and forever passion, probably for most of you, for audio amplifiers.

Theory about this sector can be found in all the internet corners, so here I will put into discussion a couple of schematics and designs which impressed me so far. If some of you come with something new or if it's seen from other angles, let me know, I’m open for discussions and if I will consider the information as valuable one, I'll put it here.

Quad 405-2 a piece of art.

For those who doesn't have any idea about what does it mean quad or 405, I will initiate whit a little introduction:

The company called Quad Electroacoustic founded by Peter J. Walker in 1936 in London is a British manufacturer of hi-fi equipment, based in Huntingdon, England.

The company initially produced only public address equipment but after the war they began to produce equipment designed for use in the home as a result of the rising demand for high quality domestic sound reproduction.

The name "QUAD" is an acronym for "Quality Unit Amplifier Domestic", used to describe the QUAD amplifier. In 1983, when having become known for their QUAD range of products, the Acoustical Manufacturing Co. Ltd changed its name to QUAD Electroacoustic Ltd.

The famous Quad “Current Dumping” amplifier launched in the mid 1970’s, and featured feed forward error correction that effectively removed the class B cross over distortion that plagues this type of output circuit structure.

The design caused a stir in the audio industry at the time of its release, and was the subject of a patent and a paper at an AES convention a year earlier. Although the 0.005% midband distortion placed it firmly in the upper echelons of measured performance in the industry at the time, some reviewers failed to warm to the sound. Nevertheless, this was a landmark design that creatively solved the cross over distortion problem.

Productions:

Current Dumping Power Amplifiers

Quad 405 – 1975 to 1982 – 64,000 units

Quad 405–2 1982 to 1993 – 100,000 units

Quad 405-2 is one of the most known audio power amplifier for its audio performance.

Quad 405-2 Front/Rear

Quad 405-2 Inside view

Quad405-2 PCB-Channel

Technical Specifications

Power output: 100 watts per channel into 8Ω (stereo)

Frequency response:

1. 1dB at 20Hz

2. 0.5dB at 20kHz

3. 3dB at 50kHz

Total harmonic distortion: < 0.01%

Hum and Noise:

‘A’ weighted -96dB ref full power

Unweighted -93dB ref full power (15.7kHz measurement bandwidth)

Left/Right Channel Crosstalk:

1. 80dB @ 100Hz

2. 70dB @ 1kHz

3. 60dB @10kHz

Input sensitivity: 0.5V for 100 watts into 8 ohm load

Speaker load: 4 to 16 ohms (nominal)

Signal to noise ratio: 95dB

Speaker load impedance: 4Ω to 16Ω

Dimensions: 115 x 340.5 x 195mm

Weight: 9kg

MODIFICATIONS

Throughout time a lot of electronic engineers and hi-fi audio hobbyist around the world, start to modify this audio power amplifier from redesigning the electronic schematic, paying attention from quality of components and in/out connectors to the percentage of Ag consistency from the soldering material, at the end to succeed improvements of sound response.

Below I will post a series of electronic schematics starting with the original one and ending with those who has the most significant modifications. All of them are fully functional.

Switch mode power supply (S.M.P.S.)

2015-12-31T17:47:00.002+02:00

Theory about what is and what does the Switch mode power supply (S.M.P.S.).

clicker 2 PIC18FJ

2015-12-31T17:23:00.001+02:00

I will start this conversation saying that this second little development board called Clicker 2 is just awesome. Created by those from Mikroelektronika, support two mikroBUS™ sockets which gives you a huge potential of click boards, the constantly expanding range of over 193 add-on boards. With A different design put together it came up with new and original inventions.

mikroBUS™ is specially designed pinout standard with SPI, I2C, Analog, UART, Interrupt, PWM, Reset and Power supply pins.

Clicker 2 for PIC18FJ is powered by Microchip’s 8-bit PIC18F87J50 MCU. It has up to 12 MIPS of operation, 128KB of program memory and 3.904 bytes of RAM.

The onboard LTC®3586-2 IC will provide 3.3V or 5V to the clicks. It also turns the USB port into a battery charger. For convenience, clicker 2 for PIC18FJ features a reset button and an ON/OFF switch (you can also connect an external ON/OFF switch).

Clicker 2 has the same pocket-size form factor and the same pair of 1x26 connection pads as mikromedia boards. This makes it compatible with mikromedia shields letting you expand your device when you want.

To make your prototyping experience as convenient as possible, clicker 2 for PIC18FJ is preprogrammed with a USB-HID bootloader, you just have to download the mikroBootloader application and uploaded into the microcontroller.

For detailed information please view the Clicker 2 PIC18FJ manual.

At the bottom of this section i will add all projects devepoled with this awesome development board.

PIC clicker

2015-12-31T17:23:00.000+02:00

PIC clicker

here i will ad detailed information about this nice pcb board.

DS1307 [ RTC with Set Functions] & DS18B20 & MAX7219 [8 Digits]

2014-11-11T02:39:00.000+02:00

Today I will show you how to display the values of RTC DS1307 and DS18B20 on six digits with seven segments driven by MAX7219. Obviously I designed a sort of menu (helped by three buttons) to be able to change the values on IC DS1307.
We have already explained, in previous projects, how works and communicate the IC DS1307 and MAX7219, so we will proceed further by developing electronic schematic and the software model.

Hardware setup:
I intend to display the clock and room temperature, on six digits with seven segment. The time will be displayed on digits for 5 seconds then for another 5 second it will be displayed the temperature and so on.
In my case, the clock and max7219 circuit are mounted separately on pcb.
Clock circuit is designed separately by me, but max7219 circuit is acquired from Mikroelektronika.
Electrical schematic is designed to include the complete circuit.
Physical realization is carried out on the breadboard with 2420 dots.

Video:

Circuit Diagram:
This schematic has a low difficulty level. Microcontroller used is PIC16F876A.
S1 is the master reset button, R1 is the resistor of pull-up button.
Crystal quartz used has 8Mhz.
ICSP connector is used to program the microcontroller (I use PICKIT2).
R1, R3, R5, R10 are pull-up resistors.
Diode D1 has a protective role.
All three buttons are part of: incrementing hour, incrementing minute and enter.
Communication between DS1307 and circuit board "breadboard" is established by five pins as follow (GND, SQW, SCL, SDA, 5VDC). SQW pin is not used in this project.
We used a battery of 3vcc to ensure the functioning of the internal clock of DS1307 IC's, even if it is disconnected from 5 VDC.
Communication between max7219 circuit and microcontroller is set by pins RC0 (CS), RC1 (CLK) and RC2 (MOSI) used for software SPI protocol.
IF you are planning to use the "Serial 7-Seg 8-Digit Board" from mikroelektronika, it is necessary to set the appropriate switches on the DIP switch SW1 to the ON position:

Switch 1- MOSI
Switch 4 - SCK
Switch 7 - CS

Port RC7 ensure communication with DS18B20 sensor.
The capacitors C8-C11 serve as power filtering. Preferably is that the capacitors filters to be as near by ICs.

Electronic schematic is built in Eagle Cad, free version.

Software:
The program is written in mikroC Pro for PIC (version v6.4.0).
Below is my software version:

/*
'*******************************************************************************
'  Project name: Real Time Clock [DS1307 with Set Functions] & DS18B20 & max7219
'  Description:
'          With this experiment we wish to succed the next task:
'          Display on 6 digits with 7 segment leds, the clock and the room 
'          temperature (in Celsius Degree).
'          Setting the time helped by three buttons: hours, minutes and enter.
'
'          The sign "-" to the negative temperature and the hundreds for the
'          temperature value are displayed just if are used.
'          The time is displayed 5 second then he display the temperature value 
'          in Celsius Degrees for other 5 seconds and the loop goes to infinite.
'          Our clock, displays as shown below(but just in display time,
'          not in set mode).
'          Ex. of viewing in 7 segment display,6 digits :
'          Display time, mode:             Display temperature mode:
'               __________                         _________
'              |__24.59.59|     ~5 sec delay      |____23.6C|
'
'          Hardware configuration is:
'             IC ds1307 is connected with our microcontroller trough RC3=SCL,
'             RC4=SDA (I2C Connections), 
'             max7219 as follow:(CS at RC0, CLK at RC1 and MOSI(SDO) at RC2)
'             DS18B20 is assigned to RC7,
'             RB0,RB1 and RB3 are assigned to the buttons
'             Buttons Menu: RB0= Enter,  (It goes to set functions or exit from set functions)
'                           RB1= Minutes,
'                           RB2= Hours,
'
'  Written by:
'          Aureliu Raducu Macovei, 2014.
'  Test configuration:
'    MCU:                        PIC16F876A;
'    Test.Board:                 WB-106 Breadboard 2420 dots;
'    SW:                         MikroC PRO for PIC 2013 (version v6.4.0);
'  Configuration Word:
'    Oscillator:                 HS (8Mhz)on pins 9 and 10;
'    Watchdog Timer:             OFF;
'    Power up Timer:             OFF;
'    Browun Out Detect:          ON;
'    Low Voltage Program:        Disabled;
'    Data EE Read Protect:       OFF;
'    Flash Program Write:        Write Protection OFF;
'    Background Debug:           Disabled;
'    Code Protect:               OFF
'*******************************************************************************
*/

// Software SPI module connections for max7219
sbit SoftSpi_SDI at RC6_bit;
sbit SoftSpi_SDO at RC2_bit;                   // MOSI
sbit SoftSpi_CLK at RC1_bit;
sbit Chip_Select at RC0_bit;

sbit SoftSpi_SDI_Direction at TRISC6_bit;
sbit SoftSpi_SDO_Direction at TRISC2_bit;
sbit SoftSpi_CLK_Direction at TRISC1_bit;
sbit Chip_Select_Direction at TrisC0_bit;
// End Software SPI module connections for max7219

const unsigned short TEMP_RESOLUTION = 12;     //This is resolution for ds18b20
unsigned temp;

unsigned sec, min1, hr, week_day, day, mn, year;
unsigned short mask(unsigned short num)
{
 switch (num)               // Define switch cases
 {
  case  0 : return 0x7E;    // 0 for those values please study the datasheet max7219
  case  1 : return 0x30;    // 1
  case  2 : return 0x6D;    // 2
  case  3 : return 0x79;    // 3
  case  4 : return 0x33;    // 4
  case  5 : return 0x5B;    // 5
  case  6 : return 0x5F;    // 6
  case  7 : return 0x70;    // 7
  case  8 : return 0x7F;    // 8
  case  9 : return 0x7B;    // 9
  case 10 : return 0x01;    // Symbol '-'
  case 11 : return 0x00;    // Blank
  case 12 : return 0x80;    // Comma "," symbol
  case 13 : return 0x43;    // C
  } //case end
}

void max7219_init()
{
 Chip_Select = 0;           // SELECT MAX
 Soft_Spi_write(0x09);      // Decode-Mode Register
 Soft_Spi_write(0x00);      // No decode for digits 7–0
 Chip_Select = 1;           // DESELECT MAX
 
 Chip_Select = 0;           // SELECT MAX
 Soft_Spi_write(0x0A);      // Intensity Register Format
 Soft_Spi_write(0x01);      // Segment luminosity intensity set to 3/32
 Chip_Select = 1;           // DESELECT MAX

 Chip_Select = 0;           // SELECT MAX
 Soft_Spi_write(0x0B);      // Scan-Limit Register Format
 Soft_Spi_write(0x05);      // Display digits 0 1 2 3 4 5
 Chip_Select = 1;           // DESELECT MAX

 Chip_Select = 0;           // SELECT MAX
 Soft_Spi_write(0x0C);      // Shutdown Register Format
 Soft_Spi_write(0x01);      // Normal Operation
 Chip_Select = 1;           // DESELECT MAX

 Chip_Select = 0;           // SELECT MAX
 Soft_Spi_write(0x00);      // No-Op
 Soft_Spi_write(0xFF);      // No test
 Chip_Select = 1;           // DESELECT MAX
}

char minute2,hour2;
void max7219_display_set_mode(unsigned minute2, unsigned hour2)
{
 Chip_Select = 0;                                // select max7219
 Soft_Spi_write(6);                              // digit 6
 Soft_Spi_write(mask((hour2/10)%10));            // assign tens of hours
 Chip_Select = 1;                                // deselect max7219

 Chip_Select = 0;                                // select max7219
 Soft_Spi_write(5);                              // digit 5
 Soft_Spi_write ((mask(hour2%10))+ mask(12));    // assign units of hours
 Chip_Select = 1;                                // deselect max7219

 Chip_Select = 0;                                // select max7219
 Soft_Spi_write(4);                              // digit 4
 Soft_Spi_write(mask((minute2/10)%10));          // assign tens of minutes
 Chip_Select = 1;                                // deselect max7219

 Chip_Select = 0;                                // select max7219
 Soft_Spi_write(3);                              // digit 3
 Soft_Spi_write((mask(minute2%10))+mask(12));    // assign units of minutes
 Chip_Select = 1;                                // deselect max7219

 Chip_Select = 0;           // select max7219
 Soft_Spi_write(2);         // digit 2
 Soft_Spi_write (0);        // set as blank
 Chip_Select = 1;           // deselect max7219

 Chip_Select = 0;           // select max7219
 Soft_Spi_write(1);         // digit 1
 Soft_Spi_write (0);        // set as blank
 Chip_Select = 1;           // deselect max7219
}

void max7219_display (unsigned sec, unsigned min, unsigned hr)
{
 Chip_Select = 0;                                // select max7219
 Soft_Spi_write(6);                              // digit 6
 Soft_Spi_write(mask((hr/10)%10));               // assign tens of hours
 Chip_Select = 1;                                // deselect max7219

 Chip_Select = 0;                                // select max7219
 Soft_Spi_write(5);                              // digit 5
 Soft_Spi_write ((mask(hr%10))+ mask(12));       // assign units of hours
 Chip_Select = 1;                                // deselect max7219

 Chip_Select = 0;                                // select max7219
 Soft_Spi_write(4);                              // digit 4
 Soft_Spi_write(mask((min/10)%10));              // assign tens of minutes
 Chip_Select = 1;                                // deselect max7219

 Chip_Select = 0;                                // select max7219
 Soft_Spi_write(3);                              // digit 3
 Soft_Spi_write((mask(min%10))+mask(12));        // assign units of minutes
 Chip_Select = 1;                                // deselect max7219

 Chip_Select = 0;                                // select max7219
 Soft_Spi_write(2);                              // digit 2
 Soft_Spi_write (mask((sec/10)%10));             // assign tens of seconds
 Chip_Select = 1;                                // deselect max7219

 Chip_Select = 0;                                // select max7219
 Soft_Spi_write(1);                              // digit 1
 Soft_Spi_write (mask(sec%10));                  // assign units of seconds
 Chip_Select = 1;                                // deselect max7219
}

//-----Reads time and date information from RTC (DS1307)
void Read_Time(unsigned *sec, unsigned *min, unsigned *hr, unsigned *week_day, 
               unsigned *day, unsigned *mn, unsigned *year)
{
 I2C1_Start();
 I2C1_Wr(0xD0);
 I2C1_Wr(0);
 I2C1_Repeated_Start();
 I2C1_Wr(0xD1);
 *sec =I2C1_Rd(1);
 *min =I2C1_Rd(1);
 *hr =I2C1_Rd(1);
 *week_day =I2C1_Rd(1);
 *day =I2C1_Rd(1);
 *mn =I2C1_Rd(1);
 *year =I2C1_Rd(0);
 I2C1_Stop();
}//~

//-----------------start write time routine------------------
void Write_Time(unsigned minute, unsigned hour)
{
 unsigned tmp1, tmp2;
 
 tmp1 = minute / 10;           // assign values from variables
 tmp2 = minute % 10;           // assign values from variables
 minute = tmp1 * 16 + tmp2;    // assign values from variables

 tmp1 = hour / 10;             // assign values from variables
 tmp2 = hour % 10;             // assign values from variables
 hour = tmp1 * 16 + tmp2;      // assign values from variables

 I2C1_Start();          // issue start signal
 I2C1_Wr(0xD0);         // address DS1307
 I2C1_Wr(0);            // start from word at address (REG0)
 I2C1_Wr(0x80);         // write $80 to REG0. (pause counter + 0 sec)
 I2C1_Wr(minute);       // write minutes word to (REG1)
 I2C1_Wr(hour);         // write hours word (24-hours mode)(REG2)
 I2C1_Wr(0x00);         // write 6 - Saturday (REG3)
 I2C1_Wr(0x00);         // write 14 to date word (REG4)
 I2C1_Wr(0x00);         // write 5 (May) to month word (REG5)
 I2C1_Wr(0x00);         // write 01 to year word (REG6)
 I2C1_Wr(0x80);         // write SQW/Out value (REG7)
 I2C1_Stop();           // issue stop signal

 I2C1_Start();          // issue start signal
 I2C1_Wr(0xD0);         // address DS1307
 I2C1_Wr(0);            // start from word at address 0
 I2C1_Wr(0);            // write 0 to REG0 (enable counting + 0 sec)
 I2C1_Stop();           // issue stop signal
}
//-----------------end write time routine------------------

//-------------------- Formats date and time
void Transform_Time(unsigned *sec, unsigned *min, unsigned *hr, 
                    unsigned *week_day, unsigned *day, unsigned *mn, unsigned *year)
{
 *sec  =  ((*sec & 0x70) >> 4)*10 + (*sec & 0x0F);
 *min  =  ((*min & 0xF0) >> 4)*10 + (*min & 0x0F);
 *hr   =  ((*hr & 0x30) >> 4)*10 + (*hr & 0x0F);
 *week_day =(*week_day & 0x07);
 *day  =  ((*day & 0xF0) >> 4)*10 + (*day & 0x0F);
 *mn   =  ((*mn & 0x10) >> 4)*10 + (*mn & 0x0F);
 *year =  ((*year & 0xF0)>>4)*10+(*year & 0x0F);
}//~

void blink_min()
{
 Chip_Select = 0;               // select max7219
 Soft_Spi_write(4);             // digit 4
 Soft_Spi_write(0);             // set as blank
 Chip_Select = 1;               // deselect max7219

 Chip_Select = 0;               // select max7219
 Soft_Spi_write(3);             // digit 3
 Soft_Spi_write(0);             // set as blank
 Chip_Select = 1;

 delay_ms(50);                               // 50ms delay
 max7219_display_set_mode(minute2,hour2);    // display those values
 delay_ms(50);                               // 50ms delay
}
void blink_hr()
{
 Chip_Select = 0;               // select max7219
 Soft_Spi_write(6);             // digit 6
 Soft_Spi_write(0);             // set as blank
 Chip_Select = 1;               // deselect max7219

 Chip_Select = 0;               // select max7219
 Soft_Spi_write(5);             // digit 5
 Soft_Spi_write(0);             // set as blank
 Chip_Select = 1;               // deselect max7219

 delay_ms(50);                               // 50ms delay
 max7219_display_set_mode(minute2,hour2);    // display those values
 delay_ms(50);                               // 50ms delay
}

char setuptime=0;
unsigned count=0;
void Press_Switch()
{
 if(button(&portb,0,1,0))        // check if button RB0 is pressed
 {
  Delay_ms(200);
  setuptime = !setuptime;        // switch that value;

  if(setuptime)
  {
  hour2=hr;
  minute2=min1;
  max7219_display_set_mode(minute2,hour2);   // display those values
  }
  else
  {
   hr=hour2;
   min1=minute2;
   Write_Time(min1,hr);
   max7219_display_set_mode(minute2,hour2);
  }
 }
 
 if(Setuptime)
 {
  if(button(&portb,1,1,0))
  {
   Delay_ms(150);
   minute2++;
   if(minute2 > 59)
   minute2=0;
   blink_min();
   }
  if(button(&portb,2,1,0))
  {
   Delay_ms(150);
   hour2++;
   if(hour2 > 23)
   hour2=0;
   blink_hr();
   }
  }
}

// Starts ds18b20 declarations
void ds18b20(unsigned int temp2write)
{
 const unsigned short RES_SHIFT = TEMP_RESOLUTION - 8;
 unsigned temp_whole;
 unsigned int temp_fraction;
 unsigned short isNegative = 0x00;
 // Check if temperature is negative
 if (temp2write & 0x8000)
 {
  temp2write = ~temp2write + 1;
  isNegative = 1;
  }
 // Extract temp_whole
 temp_whole = temp2write >> RES_SHIFT ;

 // Extract temp_fraction and convert it to unsigned int
 temp_fraction  = temp2write << (4-RES_SHIFT);
 temp_fraction &= 0x000F;
 temp_fraction *= 625;          // 625 for ds18b20 and 5000 for ds1820;

 Chip_Select = 0;               // select max7219
 Soft_Spi_write(1);             // digit 1
 Soft_Spi_write(mask(13));      // write C symbol
 Chip_Select = 1;               // deselect max7219

 Chip_Select = 0;                                // select max7219
 Soft_Spi_write(2);                              // Set digit number 3
 Soft_Spi_write(mask(temp_fraction /1000));      // assigne as fraction
 Chip_Select = 1;                                // deselect max7219

 Chip_Select = 0;                                // select max7219
 Soft_Spi_write(3);                              // Set digit number 3
 Soft_Spi_write((mask(temp_whole%10))+mask(12)); // Assigne as ones
 Chip_Select = 1;                                // deselect max7219

 Chip_Select = 0;                                // select max7219
 Soft_Spi_write(4);                              // Set digit number 4
 Soft_Spi_write (mask((temp_whole/10)%10));      // Assigne as tens
 Chip_Select = 1;                                // deselect max7219
  
 if (isNegative == 1)
 {
  Chip_Select = 0;               // select max7219
  Soft_Spi_write(5);             // Set digit number 5
  Soft_Spi_write(mask(10));      // Assigne as symbol "-"
  Chip_Select = 1;               // deselect max7219
  }
 else
 {
  if(isNegative ==0 && temp_whole/100==0)
  {
   Chip_Select = 0;               // select max7219
   Soft_Spi_write(5);             // Set digit number 5
   Soft_Spi_write(mask(11));      // Assign as blank
   Chip_Select = 1;               // deselect max7219
   }
  else
  {
   Chip_Select = 0;                         // select max7219
   Soft_Spi_write(5);                       // Set digit number 5
   Soft_Spi_write(mask(temp_whole/100));    // Assign the hundreds
   Chip_Select = 1;                         // deselect max7219
   }
  }
  
 Chip_Select = 0;                 // select max7219
 Soft_Spi_write(6);               // Set digit number 6
 Soft_Spi_write(0);               // Assign value 0
 Chip_Select = 1;                 // deselect max7219
}// End ds18b20 declarations

void interrupt()
{
 if(setuptime)
 count=0;
 else
 count++;                  // Interrupt causes count to be incremented by 1
 TMR0 = 0;                 // Timer TMR0 is returned its initial value
 INTCON = 0x20;            // Bit T0IE is set, bit T0IF is cleared
}

void main() 
{
 CMCON  |= 7;                  // Disable Comparators
 OPTION_REG = 0x84;            // Prescaler Rate Selected at 1:32;
 TMR0 = 0;                     // Reset timer;
 INTCON = 0xA0;                // Disable interrupt PEIE,INTE,RBIE,T0IE

 Chip_Select_Direction = 0;    // Set RC0 pin as output
 Soft_Spi_init();              // Initialize software SPI module
 max7219_init();               // initialize  max7219
 I2C1_Init(100000);            // initialize I2C

 while (1)                     // and here, our while loope
 {
  Press_Switch();
     
  if(!setuptime)
  {
   if(count<=1400)                    // ~ 5 seconds
   {
    Read_Time(&sec,&min1,&hr,&week_day,&day,&mn,&year);      // read time from RTC(DS1307)
    Transform_Time(&sec,&min1,&hr,&week_day,&day,&mn,&year); // format date and time
    max7219_display(sec,min1, hr);
    }
   else
   {
    if(count>1400)                     // ~ 5 seconds
    {
     //Perform temperature reading
     Ow_Reset(&PORTC, 7);          // Onewire reset signal
     Ow_Write(&PORTC, 7, 0xCC);    // Issue command SKIP_ROM
     Ow_Write(&PORTC, 7, 0x44);    // Issue command CONVERT_T
     
     Ow_Reset(&PORTC, 7);
     Ow_Write(&PORTC, 7, 0xCC);    // Issue command SKIP_ROM
     Ow_Write(&PORTC, 7, 0xBE);    // Issue command READ_SCRATCHPAD

     temp =  Ow_Read(&PORTC, 7);   // Next Read Temperature and Read Byte 0 from Scratchpad
     // Then read Byte 1 from Scratchpad and shift 8 bit left and add the Byte 0
     temp = (Ow_Read(&PORTC, 7) << 8) + temp;
     ds18b20(temp);                  //Format and display result on digits.
     }
    }
   if(count>2800)
   count = 0;
   }
  }
}

GSM Click (Warning Action via SMS)

2014-07-23T19:41:00.001+03:00

OK Folks, we will continue our experiments with this GSM module, and we will show how we can send an warning message. Obviously we will create the warning situation trough a button, but of course it can be changed with everything else for example a couple of movement sensors, etc.

Hardware setup:
After we spoke "the given situation" is set by a button set on RD7. The info led set on RB7 show the situation as follow:

After initialize, it flash for 2 seconds.
After the message is sent, it flashing ten times.

Some adjustments are needed on Easypic v7 motherboard to establish our connections. The adjustments are as follow:

Turn on portB LEDs on SW3 (SW3.2).
Place GSM click board into mikroBUS socket 1.
Place power selection jumper (J5) into 3.3V position.

Video:

For hardware details, please study the EasyPic v7 and Telit GL865 datasheets.

Software:
The program is written in mikroC Pro for PIC (version v6.4.0).
Below is my software version:

warning action.c

/*
 * Project name:
     Warning Action via SMS.
 * Copyright:
     (c) Macovei Aureliu Raducu, 2014.
 * Revision History:
     1.1
 * Description:
     This is an Warning Action via SMS project who are able to send a 
     warning message for a given situation.
     In this experiment "the given situation" is one button set on RD7.
     The info led set on RB7 show the situation as follow:
         - After initialize, it flash for 2 seconds.
         - After the message is sent, it flashing ten times.
 * Test configuration:
     MCU:             PIC18F45k22
                      http://ww1.microchip.com/downloads/en/DeviceDoc/41412F.pdf
     Ddev.board:       EasyPIC7
                      http://www.mikroe.com/easypic/
     Oscillator:      HS-PLL 32.0000 MHz, 8.0000 MHz Crystal
     Ext. Modules:    GSM click
                      http://www.mikroe.com/click/gsm/
     SW:              mikroC PRO for PIC
                      http://www.mikroe.com/mikroc/pic/
 * NOTES:
     Adjust the number to which the SMS will be sent and recompile the project
     now have HEX file ready for programming.
*/
// Configure phone number on which the SMS warning will be sent
// Use international code + your phone number
char phoneNumber1[] = "your number1";    // This is the first number
char phoneNumber2[] = "your number2";    // This is the second number

#include "Telit_GL865.h"

// Pin definitions
sbit LD1 at LATB7_bit;                    // Set LED1 at port RB7
sbit LD1_Direction at TRISB7_bit;         // Set LED1 at port RB7

sbit T1 at RD7_bit;                       // Set Button at port RD7.
sbit T1_Direction at TRISD7_bit;          // Set Button at port RD7
// Pin definitions

void Delay_LD(){
  Delay_ms(100);                          // Led Delay 100ms
}

// Simple LED action indicating a button press
void Blink(){
  LD1 = 1;
  Delay_LD();
  LD1 = 0;
  Delay_LD();
  LD1 = 1;
  Delay_LD();
  LD1 = 0;
}

void check_status(){
 LD1 = 1;
 delay_ms(2000);           // Add 2s delay
 LD1 = 0;
}

void MCU_Init()
{
  ANSELA = 0;              // Set all ports as digital
  ANSELB = 0;
  ANSELC = 0;
  ANSELD = 0;
  ANSELE = 0;              // Set all ports as digital

  // GSM definitions
  PWRMON_Direction = 1;
  RST = 0;
  RST_Direction = 0;
  // GSM definitions

  // Button on RD7;
  T1_Direction = 1;             // Button pins are set as input
  // Button on RD7;

  // Led Indicator set on RB7
  LD1 = 0;                      // Turn OFF the LED
  LD1_Direction = 0;            // Set direction for LEDS
  // Led Indicator set on RB7

  UART1_Init(9600);       // Using default baud rate 9600
  Delay_ms(200);          // Wait a while till the GSM network is configured
}

// main function
void main() {
  MCU_Init();                   // Initialize MCU pins and modules
  if (GSM_Init() == 0)          // Initialize GSM module, if AT is received LED1 is ON
  check_status();               // Shown by LD1

  while(1){                     // Endless loop
  if (T1 == 1){                 // With Button1 we activate "the given situation"
    SendSMS(phoneNumber1);      // First things first, send the SMS
    delay_ms(3500);
    SendSMS(phoneNumber2);
    Blink();Blink();            // Blink ten times, after message sent
    Blink();Blink();
    Blink();
    }
  }
}

telite_GL865.c

#include "Telit_GL865.h"

void GSMcmd(char *ch)                 // GSM commands
{
 while(*ch)
 if(UART1_Tx_Idle() == 1)
 UART1_Write(*ch++);
 UART1_Write(0x0D);                  // Send CR - command terminate character
}

char GSM_Init(){
  char cmdTO = 0, readTO = 0;         // TimeOut counters
  char gsmRes[26]={0}, resCnt = 0;    // Response from GSM module
  while(PWRMON != 0){};               // Wait for POWER to be generated by the GSM module
  Delay_ms(3500);
  while(cmdTO++ < 5){                 // Check the communication by sending AT command for few times
    UART1_Read();
    GSMcmd("AT");                     // AT commamd.
    while(readTO++ < 10){
      Delay_us(300);                  // 1/9600 * 3 = 312.5us takse a UART HW buffer to fill up.
      while(UART1_Data_Ready()){      // Place the received bytes to buffer array(gsamRes[])
        readTO = 0;
        gsmRes[resCnt++] = UART1_Read();
        gsmRes[resCnt] = 0;
        if (resCnt == 25){
         resCnt = 0;
        }
      }
    }
    readTO = 0;
    if (strstr(gsmRes,"AT\r\r\nOK\r\n")){   // Check for occurrence of expected string
      GSMcmd("ATE1");                       // Few more GSM module configuration commands.
      GSMcmd("AT+CMGF=1");                  // Select Text Mode.
      GSMcmd("AT#GPIO=5,0,2");              // Set GPIO5 pin as RFTXMON OUTPUT
      return 0;
    }
  }
  return 1;
}

void SMSbegin(char *phoneNo){               // Sending an SMS requires three easy steps
                                            // 1. Begin with SMS command  +CMGS
  UART1_Write_Text("AT+CMGS=\"");           // AT+CMGS="+39xxxxxxxxxx"[CR]
  UART1_Write_Text(phoneNo);
  GSMcmd("\"");
}

void SMSwrite(char *text){
  UART1_Write_Text(text);                   // 2. After SMS command, SMS text is expected
}

void SMSsend(){
  GSMcmd("\x1A");     // 3. At the end CTRL + Z is sent as terminating character
}
// Function sends an SMS to predefined number with predefined text(warning)
void SendSMS(char *phone){
  SMSbegin(phone);
  Delay_ms(100);
  SMSwrite("WARNING!!\r\n");                            // This is our message line1
  SMSwrite("We have a situation here!\r\n");            // This is our message line2
  SMSwrite("(someone somehow has press the button)");   // This is our message line3
  SMSsend();
}

telite_GL865.h

// GSM definitions
sbit PWRMON           at PORTA.B2;
sbit PWRMON_Direction at TRISA2_bit;
sbit RST              at LATE1_bit;
sbit RST_Direction    at TRISE1_bit;
// GSM definitions

char GSM_Init();
void SendSMS(char *phone);

GSM Click (Temperature & Controll via SMS)

2014-07-21T21:01:00.003+03:00

Today I will share with you an experiment made with the module Telit GL856-Quad wich is mounted on a pcb board called "GSM Click Board" designed by Mikroelektronika. The GSM click board is attached to the EasyPIC v7 motherboard trough mikroBUS™ host connector, making our hardware platform.

Telit GL865 Module.

Features:

The Telit GL865-Quad module family can be controlled via the serial interface using the standard AT commands.
Ultra Compact; GPRS Class 10; LCC Package
Quad Band GSM/GPRS 850/900/1800/1900MHz
Embedded TCP/IP Stack
Supply voltage range: 3.22 - 4.5V DC (3.8V DC recommended)
Power consumption (typical values): Power off: <5 uA
Idle (registered, power saving): 1.5 mA @ DRX=9
Dedicated mode: 230mA @ max power level
GPRS class 10: 360 mA @ max power level
Sensitivity: 108 dBm (typ.) @ 850/900MHz; 106 dBm (typ.) @ 1800/1900MHz.

As can be seen from it's datasheet, the communications are achieved in UART mode (TX,RX), with a Baud rate from 300 to 115,200bps.

Hardware setup:
In example, "FAN1ON" command turns ON the output on RD0, "FAN2OFF" turns OFF the output on RD1. In this experiment we used two leds instead fans (just to prove the output commands.)
PORT RD0 and RD1 leads two digital output and RA0 one analog input.
Some adjustments are needed on Easypic v7 motherboard to establish our connections:
The adjustments are as follow:

Turn on portD LEDs on SW3 (SW3.4).
Place GSM click board into mikroBUS socket 1.
Place power selection jumper (J5) into 3.3V position.

Video:

Pin Configurations.

For hardware details, please study the EasyPic v7 and Telit GL865 datasheets.

Software:
The program is written in mikroC Pro for PIC (version v6.0.0).
Below is my software version:

/*
 * Project name:
    GSM Click (Temperature & Controll via SMS).
 * Copyright:
     Macovei Aureliu Raducu, 2014.
 * Description:
     Program uses GSM module GL865 for sending and receiving SMS.
     The scenario of this experiment is as follows:
     User can interrogate the EasyPIC v7 development board via SMS, and receive
     the status situation of the motherboard.
     Port RD0 and RD1 are used to control two Fans and port RA0 is used to 
     measure the temperature of LM35 sensor.
     As a bonus the temperature is displayed in both format, Celsius and Fahrenheit.
 * Test configuration:
     MCU:             PIC18F45K22
                      http://ww1.microchip.com/downloads/en/DeviceDoc/41412F.pdf
     dev.board:       EasyPIC7
                      http://www.mikroe.com/easypic/
     Oscillator:      HS-PLL 32.0000 MHz, 8.0000 MHz Crystal
     ext. modules:    gsm click : 
                      http://www.mikroe.com/click/gsm/
                      Telit GL865-QUAD
                      http://www.telit.com/en/products.php?p_id=3&p_ac=show&p=110
                      LM35 (Analog temperature sensor)
                      http://www.ti.com/lit/ds/symlink/lm35.pdf
     SW:              mikroC PRO for PIC
                      http://www.mikroe.com/mikroc/pic/
 * NOTES:
     - Due different mobile operators some adjustments may be required, please consult Telit AT commands
       reference guide at http://www.telit.com/module/infopool/download.php?id=542
     - The SMS messages (which GL865 receives) contain commands: "FAN1ON" or "FAN1OFF", "FAN2ON" or "FAN2OFF"
       and "Status?" (it is case sensitive and without quotes).
       In example, "FAN1ON"  command turns ON the output on RD0, "FAN2OFF" turns OFF the output on RD1.
       In this experiment we used two leds instead fans (just to prove the output commands.)
       You can send only the "Status?" inquiry via your SMS (or add it to the SMS containg relay commands) 
       and then you'll receive an info about the state of EasyPic7 motherboard.
       PORT RD0 and RD1 leads two digital output and RA0 one analog input.
       An example of one control message is below:
       "FAN1ON FAN2OFF Status?"  (Note that there is no need for separation chars (spaces in this case)).
       Valid message is also: "FAN2OFFFAN1ONStatus?"; just be careful about the case of letters.

     - Turn on portD LEDs on SW3 (SW3.4).
     - Place GSM click board into mikroBUS socket 1.
     - Place power selection jumper (J5) into 3.3V position.
 */

//  Set VREF according to the voltage reference for LM35:
//  5.00 - power supply jumper set to 5V position (reference = 5V)
//  3.30 - power supply jumper set to 3.3V position (reference = 3.3V)
const unsigned short VREF = 3.30;

// Set of basic AT commands
const char atc0[] = "AT";                        // Every AT command starts with "AT"
const char atc1[] = "ATE0";                      // Disable command echo
const char atc2[] = "AT+CMGF=1";                 // TXT messages
      char atc3[] = "AT+CMGS=\"";                // sends SMS to desired number
const char atc4[] = "AT+CMGR=1";                 // Command for reading message from location 1 from inbox
const char atc5[] = "AT+CMGD=1,4";               // Erasing all messages from inbox
const char atc6[] = "AT+CMGL=\"ALL\"";           // Check status of received SMS
const char atc7[] = "AT#SLED=2";                 // Activate STAT_LED pin
const char atc8[] = "AT#SLEDSAV";                // Save previous command
const char atc9[] = "AT#GPIO=5,0,2";             // Set GPIO5 pin as RFTXMON OUTPUT (the GPIO5 pin is set
                                                 // in output direction; the setting is saved at module power off.)

// Responses to parse
const GSM_OK                       = 0;
const GSM_Ready_To_Receive_Message = 1;
const GSM_ERROR                    = 2;
const GSM_UNREAD                   = 3;
//

// Telit GL865 Module settings
sbit PWRMON at PORTA.B2;
sbit PWRMON_Direction at TRISA2_bit;

sbit RTS at LATE0_bit;
sbit RTS_Direction at TRISE0_bit;

sbit GL865_ON_OFF at LATE1_bit;
sbit GL865_ON_OFF_Direction at TRISE1_bit;
//

//Fan Connections
sbit FAN1 at LATD0_bit;
sbit FAN2 at LATD1_bit;

sbit FAN1_Direction at TRISD0_bit;
sbit FAN2_Direction at TRISD1_bit;
//

// Temperature sensor connections
sbit LM35 at PORTA.B0;
sbit LM35_Direction at TRISA0_bit;
//

// SMS Message string
char SMS_Message[300];

// LM35 data string
char LM35_dataC[15];
char LM35_dataF[15];
//
// phone number string
char phone_number[20];

// State machine control variables
char gsm_state = 0;
char response_rcvd = 0;
short responseID = -1, response = -1;
char gsm_number = 0;
char Unread_flag;
char status_req = 0; // Status request variable

// Send command or data to the Telit GL865 Module - (const)
void GL865_Send(const char *s)
{
// Send command or data string
   while(*s) {
    UART1_Write(*s++);
   }
// Terminatation by CR
   UART_Wr_Ptr(0x0D);
}

// Send command or data to the Telit GL865 Module - (RAM)
void GL865_Send_Ram(char *s1)   //
{
// Send command or data string
   while(*s1) {
    UART_Wr_Ptr(*s1++);
   }
// Terminatation by CR
   UART_Wr_Ptr(0x0D);
}

// Get GSM response, if there is any
short Get_response() {
    if (response_rcvd) {
      response_rcvd = 0;
      return responseID;
    }
    else
      return -1;
}

// Wait for GSM response (infinite loop)
void Wait_response(char rspns) {
char test = 1;

  while (test){
  test = Get_response();
  if ((test == rspns) || (test == GSM_ERROR))
    test = 0;
  else
    test = 1;
  }
}

// Compose Status SMS
unsigned ComposeMessage(char* Message);

// Send Status SMS
void Send_Msg(char* Msg){
  char atc[33];

  atc[0] = 0;                        // clear atc string
  strcat(atc, atc3);                 // atc3 command for sending messages
  strcat(atc, phone_number);         // add phone number
  strcat(atc, "\"");                 // complete AT command
  GL865_Send_Ram(atc);               // send AT command for SMS sending
  Wait_response(GSM_Ready_To_Receive_Message); // Wait for appropriate ready signal

  GL865_Send_Ram(Msg);               // Send message content
  UART_Wr_Ptr(0x1A);                 // Send CTRL + Z as end character
  UART_Wr_Ptr(0x0D);                 // Send CR
  Wait_response(GSM_OK);             // Wait OK as confirmation that the message was sent
}

// Send status SMS to the cell phone number defined by the atc3 const string
void Send_Status(){
 ComposeMessage(SMS_Message);
 Send_Msg(SMS_Message);
}

// 5sec pause
void Wait(){
   Delay_ms(5000);
}

// Main
void main(){
  ANSELA = 0;             // Set all ports as digital
  ANSELB = 0;
  ANSELC = 0;
  ANSELD = 0;
  ANSELE = 0;

  SLRCON = 0;             // Set output slew rate on all ports at standard rate

  ANSELA |= 0x01;         // Configure RA0 pins as analog
  LM35_Direction = 1;     // Configure RA0 pin as input

  //Initialy, FAN's are turned off
  FAN1=0;
  FAN2=0;
  
  FAN1_Direction=0;
  FAN2_Direction=0;
  //

// Setup interrupts
  RC1IE_bit = 1;          // Enable Rx1 intterupts
  PEIE_bit = 1;           // Enable peripheral interrupts
  GIE_bit  = 1;           // Enable global interrupts
//

  // Initial state of Telit GL865 Module pins
  PWRMON_Direction = 1;   // Make PWRMON(RA2) as input

  RTS = 0;                //  Set RTS pin to zero (we will use only RX and TX)
  RTS_Direction  = 0;

  GL865_ON_OFF = 0;
  GL865_ON_OFF_Direction = 0;
  //
  
// Turn on the GM865 module
  GL865_ON_OFF = 1;       // hardware reset
  Delay_ms(2500);         // hold it at least for two seconds
  GL865_ON_OFF = 0;
//

  UART1_Init(9600);
  ADC_Init();

  Wait();                 // Wait a while till the GSM network is configured

// Negotiate baud rate
  while(1) {
    GL865_Send(atc0);                 // Send "AT" string until GSM862 sets up its baud rade
    Delay_ms(100);                    // and gets it correctly
    if (Get_response() == GSM_OK)     // If GSM862 says "OK" on our baud rate we program can continue
      break;
  }

 GL865_Send(atc1);                    // Disable command echo
 Wait_response(GSM_OK);

 GL865_Send(atc2);                    // Set message type as TXT
 Wait_response(GSM_OK);
 
 GL865_Send(atc7);                    // Activate STAT_LED pin
 Wait_response(GSM_OK);
 
 GL865_Send(atc8);                    // Then save it
 Wait_response(GSM_OK);
 
 GL865_Send(atc9);                    // Set GPIO5 pin as RFTXMON OUTPUT
 Wait_response(GSM_OK);

 while(1){
   GL865_Send(atc5);             // Delete all messages (if any)
   if (get_response() == GSM_OK) // If messages are deleted
     break;                      // break from while
   Delay_ms(500);
 }
  // infinite loop
  while(1) {
    GL865_Send(atc6);        // Read status of the messages and read message it self
    Delay_ms(100);           // Wait until the message is read

    while(1) {
      GL865_Send(atc0);      // Wait until the module is ready
      Delay_ms(50);
      if (Get_response() == GSM_OK)
        break;
    }
    
    if (Unread_flag){
      while(1) {
        GL865_Send(atc0);    // Wait until the module is ready
        Delay_ms(50);
        if (Get_response() == GSM_OK)
          break;
      }

      if (status_req){       // Send status SMS if it's been requested
        status_req = 0;
        Send_Status();
      }

      Unread_flag = 0;
    }

    while(1){
      GL865_Send(atc5);  // Delete all messages (if any)
      Delay_ms(50);
      if (get_response() == GSM_OK) // If messages are deleted
        break;           // break from while
      Delay_ms(50);
      if (Unread_flag){  // if we have received message in mean time
        Unread_flag = 0;
        break;           // break from while
      }
    }
    Wait();
  }
}

/******************************************************************************/

// Compose Status SMS
unsigned ComposeMessage(char* Message){
  unsigned int adc_value1 = 0;
  float Celsius_format, Fahrenheit_format;
 
  RC1IE_bit = 0;                // Disable Rx1 intterupts

  Message[0] = '\0';
//================================================================
  // SMS header
  strcat(Message, "EasyPIC7 Info:");
  strcat(Message, "\r\n");              // Add new line (CR + LF)
  //
  if(FAN1)
     strcat(Message, "FAN1: ON");
  else
     strcat(Message, "FAN1: OFF");
  strcat(Message, "\r\n");              // Add new line (CR + LF)
  
  if(FAN2)
     strcat(Message, "FAN2: ON");
  else
     strcat(Message, "FAN2: OFF");
  strcat(Message, "\r\n");              // Add new line (CR + LF)
//================================================================

  // Adding Temperature values to the SMS
  adc_value1 = ADC_Get_Sample(0);                 // RA0
  Celsius_format = (adc_value1 * VREF)/10.240;    // Calculate temperature in Celsuis
  FloatToStr(Celsius_format, LM35_dataC);
  LM35_dataC[4] =0;                               // Use just four string value

  strcat(Message, "TEMP: +");
  strcat(Message, LM35_dataC);
  strcat(Message, "'C");                          // Celsius degree symbol
  strcat(Message, " / +");                        // Delimitation and + symbol
  
  Fahrenheit_format = (Celsius_format *9/5)+32;   // °F =°C*9/5 + 32 transformation formula
  FloatToStr(Fahrenheit_format, LM35_dataF);
  LM35_dataF[4] =0;                               // Use just four string value
  strcat(Message, LM35_dataF);
  strcat(Message, "'F");
  strcat(Message, "\r\n");                        // Add new line (CR + LF)
  // SMS footer
  strcat(Message, "End.");
  strcat(Message, "\r\n");                        // Add new line (CR + LF)
  //
  RC1IE_bit = 1;                                  // Enable Rx1 intterupts

  return strlen(Message);
}

// state machine
// Reading the data from UART in the interuppt routine
void interrupt(){
char tmp,i;

  if (RCIF_bit == 1) {                           // Do we have uart rx interrupt request?
    tmp = UART_Rd_Ptr();                         // Get received byte

// Process reception through state machine
// We are parsing only "OK" and "> " responses
    switch (gsm_state) {
      case  0: {
                response = -1;                   // Clear response
                if (tmp == 'O')                  // We have 'O', it could be "OK"
                  gsm_state = 1;                 // Expecting 'K'
                if (tmp == '>')                  // We have '>', it could be "> "
                  gsm_state = 10;                // Expecting ' '
                if (tmp == 'E')                  // We have 'E', it could be "> "
                  gsm_state = 30;                // Expecting 'R'
                if (tmp == 'S')                  // We have 'S', it could be "Status?"
                  gsm_state = 40;                // Expecting 't'
                if (tmp == 'F')                  // We have 'F', it could be "FANxON or FANxOFF"
                  gsm_state = 50;                // Expecting A
                if (tmp == 'U')                  // We have 'U', it could be "UNREAD"
                  gsm_state = 70;                // Expecting 'N'
                break;
               }
      case  1: {
                if (tmp == 'K') {                // We have 'K' ->
                  response = GSM_OK;             // We have "OK" response
                  gsm_state = 20;                // Expecting CR+LF
                }
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }
      case 10: {
                if (tmp == ' ') {
                  response_rcvd = 1;             // We have "> " response
                  response = GSM_Ready_To_Receive_Message; // Set reception flag
                  responseID = response;         // Set response ID
                }
                gsm_state = 0;                   // Reset state machine
                break;
                }

      case 20: {
                if (tmp == 13)                   // We have 13, it could be CR+LF
                  gsm_state = 21;                // Expecting LF
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }
      case 21: {
                if (tmp == 10) {                 // We have LF, response is complete
                  response_rcvd = 1;             // Set reception flag
                  responseID = response;         // Set response ID
                }
                gsm_state = 0;                   // Reset state machine
                break;
               }

      case 30: {
                if (tmp == 'R')                  // We have 'R', it could be "ERROR"
                  gsm_state = 31;                // Expecting 'R'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }
      case 31: {
                if (tmp == 'R')                  // We have 'R', it could be "ERROR"
                  gsm_state = 32;                // Expecting 'O'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }
      case 32: {
                if (tmp == 'O')                  // We have 'O', it could be "ERROR"
                  gsm_state = 33;                // Expecting 'R'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }
      case 33: {
                if (tmp == 'R'){                 // We have 'R'
                  response_rcvd = 1;             // We have "ERROR" response
                  response = GSM_ERROR;          // Set reception flag
                  responseID = response;         // Set response ID
                }
                gsm_state = 0;                   // Reset state machine
                break;
                }
      case 40: {
                if (tmp == 't')                  // We have 't', it could be "Status?"
                  gsm_state = 41;                // Expecting 'a'
                else
                  gsm_state = 0;               // Reset state machine
                break;
                }
      case 41: {
                if (tmp == 'a')                  // We have 'a', it could be "Status?"
                  gsm_state = 42;                // Expecting 't'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }
      case 42: {
                if (tmp == 't')                  // We have 't', it could be "Status?"
                  gsm_state = 43;                // Expecting 'u'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }

      case 43: {
                if (tmp == 'u')                  // We have 'u', it could be "Status?"
                  gsm_state = 44;                // Expecting 's'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }

      case 44: {
                if (tmp == 's')                  // We have 's', it could be "Status?"
                  gsm_state = 45;                // Expecting '?'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }

      case 45: {
                if (tmp == '?'){                 // We have '?'
                  status_req = 1;                // Status has been requested!
                }
                gsm_state = 0;                   // Reset state machine
                break;
                }

      case 50: {
                if (tmp == 'A')                  // We have 'A', it could be "FANx"
                  gsm_state = 51;                // Expecting 'N'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }

      case 51: {
                if (tmp == 'N')                  // We have 'N', it could be "FANx"
                  gsm_state = 52;                // Expecting number
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }

      case 52: {
                if (tmp == '1')
                   gsm_state = 53;
                else
                if (tmp == '2')
                   gsm_state = 60;
                else
                   gsm_state = 0;
                break;
                }
                
      case 53: {
                if (tmp == 'O')
                gsm_state = 54;
                else
                gsm_state = 0;
                break;
               }
               
      case 54: {
                if (tmp == 'N'){
                   FAN1 = 1;
                   gsm_state = 0;}
                else
                if (tmp == 'F')
                   gsm_state = 55;
                else
                   gsm_state = 0;
                break;
               }
      case 55: {
                if (tmp == 'F'){
                   FAN1 = 0;
                   gsm_state = 0;}
                else
                   gsm_state = 0;
                break;
                }
      case 60: {
                if (tmp == 'O')
                   gsm_state = 61;
                else
                   gsm_state = 0;
                break;
                }
      case 61: {
                if (tmp == 'N'){
                   FAN2 = 1;
                   gsm_state = 0;}
                else
                   if (tmp = 'F')
                   gsm_state = 62;
                else
                   gsm_state = 0;
                break;
                }
      case 62: {
                if (tmp == 'F'){
                   FAN2 = 0;
                   gsm_state = 0;}
                else
                   gsm_state = 0;
                break;
                }
      case 70: {
                if (tmp == 'N')
                   gsm_state = 71;
                else
                   gsm_state = 0;
                break;
                }
      case 71: {
                if (tmp == 'R')
                   gsm_state = 72;
                else
                   gsm_state = 0;
                break;
                }
      case 72: {
                if (tmp == 'E')
                   gsm_state = 73;
                else
                   gsm_state = 0;
                break;
                }
      case 73: {
                if (tmp == 'A')
                   gsm_state = 74;
                else
                   gsm_state = 0;
                break;
                }
      case 74: {
                if (tmp == 'D'){
                   response_rcvd = 1;             // We have "ERROR" response
                   response = GSM_UNREAD;         // Set reception flag
                   responseID = response;         // Set response ID
                   Unread_flag = 1;
                   }
                gsm_state = 0;
                break;
                }
      default: {                                 // Unwanted character
                gsm_state = 0;                   // Reset state machine
               }
    }
    // parse phone number on which we should reply
    switch (gsm_number) {
      case 0 :{
               if (tmp == '"'){
                 gsm_number = 1;
                 i = 0;
               }
              }; break;
      case 1 :{
               if (tmp == '+'){
                 phone_number[i] = tmp;
                 i ++;
                 gsm_number = 2;
               }
               else{
                 gsm_number = 0;
                 i = 0;
               }
              }; break;
      case 2 :{
               if (tmp >= '0' && tmp <= '9'){
                 phone_number[i] = tmp;
                 i ++;
               }
               else
                 if (tmp == '"'){
                   phone_number[i] = 0;
                   i = 0;
                   gsm_number = 0;
                 }
                 else{
                   phone_number[0] = 0;
                   i = 0;
                   gsm_number = 0;
                 }
              }; break;
      default : {
                 phone_number[0] = 0;
                 i = 0;
                 gsm_number = 0;
                }
    }
 }
}
/******************************************************************************/

Real Time Clock [DS1307 with Set Functions] & DS18B20

2014-03-29T22:09:00.000+02:00

Hello dear fellows, today I will share with you this amazing project which will highlights what can be done with DS1307.
The Real Time Clock (RTC) chip produced by Maxim is a popular and relatively low cost solution for creating a room clock.

Features:

Real-Time Clock (RTC) Counts Seconds, Minutes, Hours, Date of the Month, Month, Day of the week, and Year with Leap-Year Compensation Valid Up to 2100.
56-Byte, Battery-Backed, General-Purpose RAM with Unlimited Writes.
I2C Serial Interface.
Programmable Square-Wave Output Signal.
Automatic Power-Fail Detect and Switch Circuitry.
Consumes Less than 500nA in Battery-Backup Mode with Oscillator Running.
Operating temperature range for commercial use only: 0°C to +70°C.
Optional Industrial Temperature Range: -40°C to +85°C.
Available in 8-Pin Plastic DIP or SO.

As can be seen from it's datasheet, the communications are achieved via I2C (designed by Philips) protocol.

Hardware setup:

In the current article I intend to display the clock information and room temperature, on the LCD with 2x16 characters. Also trough four buttons, I will try to be able to set all the times variable, stored, in DS1307 chip.

Physical realization is carried out on the breadboard with 2420 dots.

Trough this video I would like to let you know precisely, how are things going.

Below I present the timing diagram for I2C signal transmitted on pins 5-6 of the DS1307.

Data Transfer on I2C Serial Bus.

Pin Configurations.

The diagram block.

For more details, please study the DS1307 datasheet.

Circuit Diagram:
Difficulty level of the electronic scheme, is low. The microcontroller used is PIC16F876A.

S1 is the master reset button, R1 is the resistor of pull-up button.

Cristal quartz by 8 MHz, is used.

ICSP connector is used to program the microcontroller.

Trough R7 we can adjust the contrast for LCD with 2x16 characters.

R6 adjusts the current through the LED LCD (light intensity of it).
R2-R5, R8-R10 are resistors for pull-up.

I personally designed the physical pcb circuit for DS1307, through the five pins, pcb communicate with the breadboard in this way (GND, SQW, SCL, SDA, 5VDC). In this project i didn't use SQW pin.

The electronic scheme is built in Eagle Cad , free version.

Software:

The program is written in mikroC Pro for PIC 2013 (version v6.0.0).

Below is my software version:

/*
'*******************************************************************************
'  Project name: Real Time Clock [DS1307 with Set Functions] & DS18B20
'  Description:
'          Trough the current experiment we wish to succed the next task:
'          Display on LCD 2x16 character the clock and room temperature.
'          Setting trough four buttons: the minutes, hours, date of the month,
'          month, day of the week, and year.
'
'          Our clock displays as shown below(but just in display time,
'          not in set mode).
'          Ex. of viewing on 2x16 LCD characters:
'          Display time, mode:             Set time, mode (cursor on):
'          ------------------              ------------------
'          |Sat, 03 Dec 2011|              |Sat, 03 12  2011|
'          |21:32:03 +26,1*C|              |21:32:03        |
'          ------------------              ------------------
'
'          Hardware configuration is:
'             IC ds1307 is connected with our microcontroller trough RC3=SCL,
'             RC4=SDA (I2C Connections), RB0,RB1,RB4-RB7 are assigned to LCD (2x16)
'             DS18B20 is assigned to RC7,
'             Buttons Menu: RC0= Increment value,
'                           RC1= Decrement value,
'                           RC2= Change cursor position,
'                           RC5= Enter.(It goes to set functions or exit from set
'                                functions)
'  Written by:
'          Aureliu Raducu Macovei, 2014.
'  Test configuration:
'    MCU:                        PIC16F876A;
'    Test.Board:                 WB-106 Breadboard 2420 dots;
'    SW:                         MikroC PRO for PIC 2013 (version v6.0.0);
'  Configuration Word:
'    Oscillator:                 HS (8Mhz)on pins 9 and 10;
'    Watchdog Timer:             OFF;
'    Power up Timer:             OFF;
'    Browun Out Detect:          ON;
'    Low Voltage Program:        Disabled;
'    Data EE Read Protect:       OFF;
'    Flash Program Write:        Write Protection OFF;
'    Background Debug:           Disabled;
'    Code Protect:               OFF
'*******************************************************************************
*/

// LCD module connections
sbit LCD_RS at RB0_bit;                 // LCD_RS assigned to PORT RB0;
sbit LCD_EN at RB1_bit;                 // LCD_EN assigned to PORT RB1;
sbit LCD_D4 at RB4_bit;                 // LCD_D4 assigned to PORT RB4;
sbit LCD_D5 at RB5_bit;                 // LCD_D5 assigned to PORT RB5;
sbit LCD_D6 at RB6_bit;                 // LCD_D6 assigned to PORT RB6;
sbit LCD_D7 at RB7_bit;                 // LCD_D7 assigned to PORT RB7;

sbit LCD_RS_Direction at TRISB0_bit;    // LCD_RS assigned to TRIS B0;
sbit LCD_EN_Direction at TRISB1_bit;    // LCD_EN assigned to TRIS B1;
sbit LCD_D4_Direction at TRISB4_bit;    // LCD_D4 assigned to TRIS B4;
sbit LCD_D5_Direction at TRISB5_bit;    // LCD_D5 assigned to TRIS B5;
sbit LCD_D6_Direction at TRISB6_bit;    // LCD_D6 assigned to TRIS B6;
sbit LCD_D7_Direction at TRISB7_bit;    // LCD_D7 assigned to TRIS B7;
// End LCD module connections

unsigned char sec,min1,hr,week_day,day,mn,year;
//--------------------- Reads time and date information from RTC (DS1307)
void Read_Time(char *sec, char *min, char *hr, char *week_day, char *day, char *mn, char *year)
{
 I2C1_Start();                    // Issue start signal
 I2C1_Wr(0xD0);                   // Address DS1307, see DS1307 datasheet
 I2C1_Wr(0);                      // Start from address 0
 I2C1_Repeated_Start();           // Issue repeated start signal
 I2C1_Wr(0xD1);                   // Address DS1307 for reading R/W=1
 *sec =I2C1_Rd(1);                // Read seconds byte
 *min =I2C1_Rd(1);                // Read minutes byte
 *hr =I2C1_Rd(1);                 // Read hours byte
 *week_day =I2C1_Rd(1);           // Read week day byte
 *day =I2C1_Rd(1);                // Read day byte
 *mn =I2C1_Rd(1);                 // Read mn byte
 *year =I2C1_Rd(0);               // Read Year byte
 I2C1_Stop();                     // Issue stop signal
}
//-----------------write time routine------------------
void Write_Time(char minute, char hour ,char weekday,char day,char month,char year)
{
 char tmp1, tmp2;

 tmp1 = minute / 10;               //Write tens of minute
 tmp2 = minute % 10;               //Write unit of minute
 minute = tmp1 * 16 + tmp2;        //Includes all value

 tmp1 = hour / 10;                 //Write tens of hour
 tmp2 = hour % 10;                 //Write unit of hour
 hour = tmp1 * 16 + tmp2;          //Includes all value

 tmp1 = weekday / 10;              //Write tens of weekday
 tmp2 =  weekday % 10;             //Write unit of weekday
 weekday = tmp1 *16 +tmp2;         //Includes all value

 tmp1 = day / 10;                  //Write tens of day
 tmp2 =  day % 10;                 //Write unit of day
 day = tmp1 *16 +tmp2;             //Includes all value

 tmp1 = month / 10;                //Write tens of month
 tmp2 =  month % 10;               //Write unit of month
 month = tmp1 *16 +tmp2;           //Includes all value

 tmp1 = year / 10;                 //Write tens of year
 tmp2 =  year % 10;                //Write unit of year
 year = tmp1 *16 +tmp2;            //Includes all value

 I2C1_Start();          // issue start signal
 I2C1_Wr(0xD0);         // address DS1307
 I2C1_Wr(0);            // start from word at address (REG0)
 I2C1_Wr(0x80);         // write $80 to REG0. (pause counter + 0 sec)
 I2C1_Wr(minute);       // write minutes word to (REG1)
 I2C1_Wr(hour);         // write hours word (24-hours mode)(REG2)
 I2C1_Wr(weekday);      // write 6 - Saturday (REG3)
 I2C1_Wr(day);          // write 14 to date word (REG4)
 I2C1_Wr(month);        // write 5 (May) to month word (REG5)
 I2C1_Wr(year);         // write 01 to year word (REG6)
 I2C1_Wr(0x80);         // write SQW/Out value (REG7)
 I2C1_Stop();           // issue stop signal

 I2C1_Start();          // issue start signal
 I2C1_Wr(0xD0);         // address DS1307
 I2C1_Wr(0);            // start from word at address 0
 I2C1_Wr(0);            // write 0 to REG0 (enable counting + 0 sec)
 I2C1_Stop();           // issue stop signal
}
//-------------------- Formats date and time---------------------
void Transform_Time(char  *sec, char *min, char *hr, char *week_day, char *day, char *mn, char *year)
{
  *sec  =  ((*sec & 0x70) >> 4)*10 + (*sec & 0x0F);
  *min  =  ((*min & 0xF0) >> 4)*10 + (*min & 0x0F);
  *hr   =  ((*hr & 0x30) >> 4)*10 + (*hr & 0x0F);
  *week_day =(*week_day & 0x07);
  *day  =  ((*day & 0xF0) >> 4)*10 + (*day & 0x0F);
  *mn   =  ((*mn & 0x10) >> 4)*10 + (*mn & 0x0F);
  *year =  ((*year & 0xF0)>>4)*10+(*year & 0x0F);
 }
//------------------------Display time---------------------------
char *txt,*mny;
void Display_Time(char sec, char min, char hr, char week_day, char day, char mn, char year)
{
 switch(week_day)
 {
  case 1: txt="Mon"; break;       // Monday;
  case 2: txt="Tue"; break;       // Tuesday;
  case 3: txt="Wed"; break;       // Wednesday;
  case 4: txt="Thu"; break;       // Thursday;
  case 5: txt="Fri"; break;       // Friday;
  case 6: txt="Sat"; break;       // Saturday;
  case 7: txt="Sun"; break;       // Sunday;
  }

 LCD_Out(1, 1,txt);
 LCD_chr(1, 4,',');

 switch(mn)
 {
  case  1: mny="Jan"; break;
  case  2: mny="Feb"; break;
  case  3: mny="Mar"; break;
  case  4: mny="Apr"; break;
  case  5: mny="May"; break;
  case  6: mny="Jun"; break;
  case  7: mny="Jul"; break;
  case  8: mny="Aug"; break;
  case  9: mny="Sep"; break;
  case 10: mny="Oct"; break;
  case 11: mny="Nov"; break;
  case 12: mny="Dec"; break;
  }

 Lcd_Chr(1, 6, (day / 10) + 48);    // Print tens digit of day variable
 Lcd_Chr(1, 7, (day % 10) + 48);    // Print oness digit of day variable
 Lcd_Out(1, 9,mny);
 Lcd_out(1,13,"20");
 Lcd_Chr(1,15, (year / 10)  + 48);  // we can set year 00-99 [tens]
 Lcd_Chr(1,16, (year % 10)  + 48);  // we can set year 00-99 [ones]
 Lcd_Chr(2, 1, (hr / 10)  + 48);
 Lcd_Chr(2, 2, (hr % 10)  + 48);
 Lcd_Chr(2, 3,':');
 Lcd_Chr(2, 4, (min / 10) + 48);
 Lcd_Chr(2, 5, (min % 10) + 48);
 Lcd_Chr(2, 6,':');
 Lcd_Chr(2, 7, (sec / 10) + 48);
 Lcd_Chr(2, 8, (sec % 10) + 48);
 }
//-------------------Display Time in Set mode--------------------
char minute1,hour1,weekday1,month1;
char minute,hour,weekday,day1,month,year1;
void Display_Time_SetMode()
{
 switch(weekday1)
 {
  case 1: txt="Mon"; break;       // Monday;
  case 2: txt="Tue"; break;       // Tuesday;
  case 3: txt="Wed"; break;       // Wednesday;
  case 4: txt="Thu"; break;       // Thursday;
  case 5: txt="Fri"; break;       // Friday;
  case 6: txt="Sat"; break;       // Saturday;
  case 7: txt="Sun"; break;       // Sunday;
  }

 LCD_Out(1, 1,txt);
 LCD_chr(1, 4,',');

 Lcd_Chr(1, 6, (day1 / 10)   + 48);    // Print tens digit of day variable
 Lcd_Chr(1, 7, (day1 % 10)   + 48);    // Print oness digit of day variable
 Lcd_chr(1,10, (month1 / 10) + 48);    // Print tens digit of month variable
 Lcd_chr(1,11, (month1 % 10) + 48);    // Print oness digit of month variable
 Lcd_out(1,13,"20");
 Lcd_Chr(1,15, (year1 / 10)  + 48);    // Print tens digit of year variable
 Lcd_Chr(1,16, (year1 % 10)  + 48);    // Print oness digit of year variable
 Lcd_Chr(2, 1, (hour1 / 10)  + 48);    // Print tens digit of hour variable
 Lcd_Chr(2, 2, (hour1 % 10)  + 48);    // Print oness digit of hour variable
 Lcd_Chr(2, 3,':');
 Lcd_Chr(2, 4, (minute1 / 10) + 48);   // Print tens digit of minute variable
 Lcd_Chr(2, 5, (minute1 % 10) + 48);   // Print oness digit of minute variable
 Lcd_Chr(2, 6,':');
 Lcd_Chr(2, 7, (0 / 10) + 48);
 Lcd_Chr(2, 8, (0 % 10) + 48);
}

char SPos;
//----------------------Move cursor routine----------------------
char index;
void movecursor()
{
 char i,moveto;
 if(SPos==0)
 lcd_cmd(_lcd_first_row);  // set weekday;
 if(SPos==1)
 lcd_cmd(_lcd_first_row);  // set day;
 if(SPos==2)
 lcd_cmd(_lcd_first_row);  // set month;
 if(SPos==3)
 lcd_cmd(_lcd_first_row);  // set year;
 if(SPos==4)
 lcd_cmd(_lcd_second_row); // set hours;
 if(SPos==5)
 lcd_cmd(_lcd_second_row); // set minutes;

 moveto = 2;
 switch(index)
 {
  case 0: moveto = 2;break;
  case 1: moveto = 6;break;
  case 2: moveto =10;break;
  case 3: moveto =15;break;
  case 4: moveto = 1;break;
  case 5: moveto = 4;break;
  }
  for(i=1; i<= moveto; i++)
  lcd_cmd(_lcd_move_cursor_right);
}
//------------Start Buttons routine--------------;
char setuptime=0;
void Press_Switch()
{
 if(setuptime)
 {
  if(Button(&portc,2,1,0))         // If buttons at port c2 is pressed
  {
   delay_ms(200);
   SPos++;
   if(SPos>5)
   SPos=0;
   index++;
   if(index > 5)
   index=0;
   movecursor();
   }
  //-----------------------------case mode to set all values---------------------
  switch(SPos)
  {
   case 0: if(button(&portc,0,1,0))       // If buttons at port c0 is pressed
           {
            Delay_ms(200);
            weekday1++;
            if(weekday1 > 7)
            weekday1=1;
            Display_Time_SetMode();
            index=0;
            movecursor();
            }

           if(button(&portc,1,1,0))       // If buttons at port c1 is pressed
           {
            Delay_ms(200);
            weekday1--;
            if(weekday1 < 1)
            weekday1=7;
            Display_Time_SetMode();
            index=0;
            movecursor();
            }
           break;
   case 1: if(button(&portc,0,1,0))       // If buttons at port c0 is pressed
           {
            Delay_ms(200);
            day1++;
            if(day1 > 31)
            day1 = 1;
            Display_Time_SetMode();
            index=1;
            movecursor();
            }

           if(button(&portc,1,1,0))        // If buttons at port c1 is pressed
           {
            Delay_ms(200);
            day1--;
            if(day1 < 1)
            day1 = 31;
            Display_Time_SetMode();
            index=1;
            movecursor();
            }
           break;
   case 2: if(button(&portc,0,1,0))         // If buttons at port c0 is pressed
           {
            Delay_ms(200);
            month1++;
            if(month1 > 12)
            month1 = 1;
            Display_Time_SetMode();
            index=2;
            movecursor();
            }

           if(button(&portc,1,1,0))          // If buttons at port c1 is pressed
           {
            Delay_ms(200);
            month1--;
            if(month1 < 1)
            month1 = 12;
            Display_Time_SetMode();
            index=2;
            movecursor();
            }
           break;
   case 3: if(button(&portc,0,1,0))           // If buttons at port c0 is pressed
           {
            Delay_ms(200);
            year1++;
            if(year1 > 99)
            year1 = 1;
            Display_Time_SetMode();
            index=3;
            movecursor();
            }

           if(button(&portc,1,1,0))           // If buttons at port c1 is pressed
           {
            Delay_ms(200);
            year1--;
            if(year1 < 1)
            year1 = 99;
            Display_Time_SetMode();
            index=3;
            movecursor();
            }
           break;
   case 4: if(button(&portc,0,1,0))            // If buttons at port c0 is pressed
           {
            Delay_ms(200);
            hour1++;
            if(hour1 > 23)
            hour1 = 0;
            Display_Time_SetMode();
            index=4;
            movecursor();
            }

           if(button(&portc,1,1,0))            // If buttons at port c1 is pressed
           {
            Delay_ms(200);
            hour1--;
            if(hour1 > 23)
            hour1 = 0;
            Display_Time_SetMode();
            index=4;
            movecursor();
            }
           break;
   case 5: if(button(&portc,0,1,0))            // If buttons at port c0 is pressed
           {
            Delay_ms(200);
            minute1++;
            if(minute1 > 59)
            minute1 = 0;
            Display_Time_SetMode();
            index=5;
            movecursor();
            }

           if(button(&portc,1,1,0))             // If buttons at port c1 is pressed
           {
            Delay_ms(200);
            minute1--;
            if(minute1 > 59)
            minute1 = 0;
            Display_Time_SetMode();
            index=5;
            movecursor();
            }
           break;
   }                            // end "if is in switch mode"
  }                             // end "if is in setup"

 if(button(&portc,5,1,0))                      // If buttons at port c5 is pressed
 {
  Delay_ms(200);
  setuptime = !setuptime;
  if(SetupTime)
  {
   lcd_cmd(_lcd_clear);
   lcd_cmd(_lcd_blink_cursor_on);
   weekday1=week_day;
   hour1=hr;
   minute1=min1;
   day1=day;
   month1=mn;
   year1=year;
   Display_Time_SetMode();
   SPos=0;
   index=0;
   movecursor();
   }
   else
   {
   Lcd_Cmd(_Lcd_clear);
   lcd_cmd(_lcd_cursor_off);
   weekday=weekday1;
   hour=hour1;
   minute=minute1;
   day=day1;
   month=month1;
   year=year1;
   Write_time(minute,hour,weekday,day,month,year);
   }
  }
 }
//----------------------End Buttons Routine-------------------
//------------------Temperature sensor routines---------------
const unsigned short TEMP_RESOLUTION = 12;     // 9 for DS1820 and 12 for DS18B20
char *text = "000,0";
unsigned temp;
void Display_Temperature(unsigned int temp2write)
{
 const unsigned short RES_SHIFT = TEMP_RESOLUTION - 8;
 char temp_whole;
 unsigned int temp_fraction;
 unsigned short isNegative = 0x00;

 // Check if temperature is negative
 if (temp2write & 0x8000)
 {
  text[0] = '-';
  temp2write = ~temp2write + 1;
  isNegative = 1;
  }
  // Extract temp_whole
  temp_whole = temp2write >> RES_SHIFT ;
  // Convert temp_whole to characters
  if (!isNegative){
  if (temp_whole/100)
  text[0] = temp_whole/100  + 48;                // Extract hundreds digit
  else
  text[0] = '+';
  }
  text[1] = (temp_whole/10)%10 + 48;             // Extract tens digit
  text[2] =  temp_whole%10     + 48;             // Extract ones digit
  // Extract temp_fraction and convert it to unsigned int
  temp_fraction  = temp2write << (4-RES_SHIFT);
  temp_fraction &= 0x000F;
  temp_fraction *= 625;
  // Convert temp_fraction to characters
  text[4] =  temp_fraction/1000 + 48;         // Extract thousands digit
  // Print temperature on LCD
  Lcd_Out(2, 10,text);
  lcd_chr(2, 15,0xB2);                        // Ascii code for degrees symbol;
  Lcd_chr(2, 16,'C');                         // Show symbol "C" from Celsius
}
//----------------Read and display Temperature from DS18B20--------------
void Read18b20()
{
 //--- Perform temperature reading
 Ow_Reset(&PORTC, 7);                           // Onewire reset signal;
 Ow_Write(&PORTC, 7, 0xCC);                     // 0xCC Issue command SKIP_ROM;
 Ow_Write(&PORTC, 7, 0x44);                     // Issue command CONVERT_T;
 Delay_us(700);                                 // delay 0,7s (required for signal
                                                // processing);
 Ow_Reset(&PORTC, 7);                           // Onewire reset signal;
 Ow_Write(&PORTC, 7, 0xCC);                     // Issue command SKIP_ROM;
 Ow_Write(&PORTC, 7, 0xBE);                     // Issue command READ_SCRATCHPAD;

 temp = Ow_Read(&PORTC, 7);                     // Next Read Temperature, read Byte
                                                // 0 from Scratchpad;
 temp = (Ow_Read(&PORTC, 7) << 8) + temp;       // Then read Byte 1 from Scratchpad
                                                // and shift 8 bit left and add the Byte 0;
 //--- Format and display result on Lcd
 Display_Temperature(temp);                     // Call Display_Temperature;
 }
//------------------Temperature sensor routines---------------
void Init_Main()
{
 CMCON |=7;             //TURN OFF ANALOGUE COMPARATOR AND MAKE PORTA TO DIGITAL I/O;

 I2C1_Init(100000);         // initialize I2C
 Lcd_Init();                // Initialize LCD
 Lcd_Cmd(_LCD_CLEAR);       // Clear LCD display
 Lcd_Cmd(_LCD_CURSOR_OFF);  // Turn cursor off

 Display_Time(sec, min1, hr, week_day, day, mn, year);

 !setuptime=1;
 index=0;
 SPos=0;
 }
//-----------------Here we have the Main Routine----------------
void main()
{
 Init_Main();
 while (1)                                                 // While loop
 {
  Read_Time(&sec,&min1,&hr,&week_day,&day,&mn,&year);      // read time from RTC(DS1307)
  Transform_Time(&sec,&min1,&hr,&week_day,&day,&mn,&year); // Transform time
  Press_Switch();                                          // Check buttons;
  if(!setuptime)
  {
   Display_Time(sec, min1, hr, week_day, day, mn, year);
   Read18b20();
   }
  }
}