Silicon Laboratories (SiLabs) is an American semiconductor-manufacturing company, similar to Microchip and STMicroelectronics. They are renowned for producing a wide range of semiconductor components, including both 8 and 32-bit microcontrollers. Notably, SiLabs is highly regarded for its RF chips and USB-Serial converters such as CP2102.

In terms of their 8-bit MCU product line-up, SiLabs offers microcontrollers based on the well-established 8051 architecture. However, their MCUs go beyond being simple, traditional 8051 devices. Like other manufacturers like Nuvoton and STC, SiLabs enhances their MCUs with additional modern hardware components such as DACs and communication peripherals.

SiLabs C8051 microcontrollers are recognized for their good performance, reliability, and scalability. They cater to the evolving needs of the embedded systems industry, whether it’s in the realm of consumer electronics, industrial automation, or smart home applications. These microcontrollers serve as a solid foundation for various projects, providing developers with a dependable and flexible platform.

Here, I will share a method with which we can measure inductors and capacitors with some degree of accuracy. For the purpose, we can use a common 8-bit microcontroller. I have used a PIC18F452. Of course, any other microcontroller will be equally suitable for the purpose as long as the calculations and procedures are maintained. We will also need a small external analogue circuit based on LM393 dual analogue comparator. This circuit is a simple Hatley oscillator. The idea is to measure the frequency or time period of the oscillator. When a new component such an inductor introduced to the oscillator, its frequency and therefore time period changes. We can then back-calculate component value.  

PIC18F452 is an 8-bit PIC18F series microcontroller. In terms of hardware is much more capable than the popular PIC16F877A or PIC16F887. However, we do not need any other hardware apart from a capture compare module (CCP) and a timer. The main reason to use a PIC18F is its operating clock speed which is 40MHz.

Schematic

Components

As shown in the circuit diagram all the components would be needed. Components L2 to L6 and C4 to C8 are test components. These are present only in simulation and not physically. Rotary switches SW1 and SW2 are only use in simulation schematic and are physically not present. A 2×16 alphanumerical LCD is used for displaying info. And a button connected to pin C0 is used for mode selection.

Code

 #include <18F452.h>  
  
 #device *=16
  
                                                                        
 #fuses NOWDT, PUT, H4, BROWNOUT, BORV42
 #fuses NOLVP, NODEBUG, NOCPB, STVREN, CPD
 #fuses PROTECT, NOWRT, NOWRTB, NOWRTC
 #fuses NOWRTD, NOEBTR, NOEBTRB, NOOSCSEN
  
 #use delay(clock = 40M)    
  
                                                                       
 #include "lcd.c"    
  
                                         
 #define mode_button      input(pin_C0)   
                                               
 #define C_cal_in_nF         100.0 
 #define L_cal_in_uH         100.0              
 #define pi                            3.142                                                     
 #define cal_delay               1000   

 #define scaling_factor_c    ((10.0 / (4.0 * pi * pi * L_cal_in_uH)))    
 #define scaling_factor_l     ((10.0 / (4.0 * pi * pi * C_cal_in_nF)))          
                                                                
 unsigned int32 overflow_count = 0;                                                      
 unsigned int32 pulse_ticks = 0;                                                   
 unsigned int16 start_time = 0;  
 unsigned int16 end_time = 0;    
                             
                                                                                               
 void setup(void);                                                                             
  
 #int_TIMER1                                                                                             
 void TMR_ISR(void)                 
 {                                                                                         
    overflow_count++;      
 }              


 #int_CCP1                                                
                                                  
 void CCP_ISR(void)
 {
    end_time = CCP_1;                                                                                         
    pulse_ticks = ((65536 * overflow_count) + end_time - start_time);
    start_time = end_time; 
    overflow_count = 0;
 }
  
 void main(void)  
 {
     short calibration_done = 0;                                                                                           
     unsigned char mode = 0;        
     unsigned long t = 0;      
     double ref = 0.0; 
     double value = 0.0;
                 
     setup();                                                                              
     while(TRUE)                          
     {                                                                      
         t = (pulse_ticks);  
         value = ((double)t * (double)t);
          
         if(mode_button == FALSE)
         {
            delay_ms(60);                                             
            while(mode_button == FALSE);    
            calibration_done = 0; 
            mode++;
            
            if(mode > 1)
            {
                mode = 0;
            }
         }  
                              
         if(calibration_done == 0) 
         {
             lcd_putc("\f");               
             lcd_gotoxy(1, 1);
             lcd_putc("Calibrating....");                                                               
             lcd_gotoxy(1, 2);              
             lcd_putc("Place no part.");                                                                 
             delay_ms(cal_delay);        
             lcd_putc("\f");    
             
             if(mode == 0)
             {   
                 ref = (value * scaling_factor_c);   
                 lcd_gotoxy(1, 1);  
                 lcd_putc("C.ref/nF:");         
                 lcd_gotoxy(1, 2);
                 printf(lcd_putc, "%3.1g   ", ref);   
                   
             }
             
             if(mode == 1)            
             {                                             
                 ref = (value * scaling_factor_l);
                 lcd_gotoxy(1, 1);  
                 lcd_putc("L.ref/uH:");        
                 lcd_gotoxy(1, 2);
                 printf(lcd_putc, "%3.1g   ", ref);   
             }  
             
             delay_ms(cal_delay);        
             lcd_putc("\f");
                                                  
             calibration_done = 1;
         } 
         
         else
         {   
             lcd_gotoxy(1, 1);  
             
             switch(mode)
             {
                 case 1:
                 {
                     value = (value * scaling_factor_c);  
                     lcd_putc("Ind./uH:");       
                                                
                     break;
                 }   
                                          
                 default:
                 {   
                     value = (value * scaling_factor_l);   
                     lcd_putc("Cap./nF:");        
                               
                     break;
                 }
             }
             
             value -= ref;
                      
             if((value < 0) || (value > 1000))             
             {              
                value = 0;
             }  
                          
             lcd_gotoxy(1, 2);                               
             printf(lcd_putc, "%3.1g         ", value);   
         }
       
         delay_ms(100);                   
     }; 
 }
  
 void setup(void)                                      
 {                         
     setup_wdt(WDT_OFF);  
     setup_adc(ADC_OFF);
     setup_adc_ports(NO_ANALOGS);                                                                                     
     setup_spi(SPI_DISABLED);    
     setup_psp(PSP_DISABLED);                  
     setup_ccp1(CCP_CAPTURE_RE);
     setup_ccp2(CCP_OFF);
     setup_low_volt_detect(LVD_43);                                                
     setup_timer_0(T0_OFF | T0_8_BIT); 
     setup_timer_1(T1_INTERNAL);  
     setup_timer_2(T2_DISABLED, T2_DIV_BY_1, 16); 
     setup_timer_3(T3_DISABLED);  
     set_timer0(0);
     set_timer1(0);  
     set_timer2(0);                                            
     set_timer3(0);
     enable_interrupts(INT_CCP1);       
     enable_interrupts(INT_TIMER1);
     enable_interrupts(global);  
     lcd_init();
     lcd_putc("\f");                              
 }         

Theory

We know that:

For a known set of L and C the equation above becomes:

We also know that the inductance of inductors adds when connected in series:

Similarly, the total capacitance of capacitors sums up when connected in parallel:

The above equation can be rearranged as follows:

We also know that:

Thus, the above equation for unknown capacitor becomes:

The same is equation also holds true for unknown inductor too:

Thus, by knowing two different frequencies or time periods, the value of any unknown capacitor or inductor can be determined.

A PIC18F452’s CCP1 module along with Timer 1 is used to capture the oscillations coming out of a Hartley oscillator. With nothing unknown connected except the 100nF and 100µH reference capacitor and inductor respectively, the reference oscillation frequency is about 50kHz (about 20µs time period). Whenever a new component is added this frequency changes.

Explanation

Basing on the theory discussed, we would need PIC18’s high processing speed along with a timer and capture module. We would also need an LCD to display results. The setup function shown below highlights these modules and their settings.

 void setup(void)                                             
 {                         
 …
     setup_ccp1(CCP_CAPTURE_RE);
 …
     setup_timer_1(T1_INTERNAL);  
 …
     set_timer1(0);  
 …
     enable_interrupts(INT_CCP1);       
     enable_interrupts(INT_TIMER1);
     enable_interrupts(global);  
     lcd_init();
     lcd_putc("\f");      
 }                         

CCP1 module is set for rising edge capture. This means that CCP1 will capture Timer 1’s count whenever it senses rising edges. CCP modules in PIC microcontrollers usually work Timer 1 module and so its count is captured. Capturing two consecutive rising edges result in period measurement of incoming waveform. This is what we would need the most.

To further make thing work apparently in concurrent manner, interrupts are used. CCP1 interrupt is triggered when there is a rising edge capture and Timer 1 interrupt is used to keep track of timer overflows. The current and previous capture counts are stored while taking care of Timer 1 overflow. These would be used to determine time period. Timer 1 will rarely overflow because it would only overflow if the incoming waveform has very low frequency and this would literally never happen.  

 #int_TIMER1                                                                                                                               
 void TMR_ISR(void)                 
 {         
    overflow_count++;      
 }              
                                                                                                         
 
 #int_CCP1                                                
                                                  
 void CCP_ISR(void)
 {
    end_time = CCP_1;                                                                                         
    pulse_ticks = ((65536 * overflow_count) + end_time - start_time);
    start_time = end_time; 
    overflow_count = 0;
 } 

PIC18’s PLL is used to upscale an external 10 MHz crystal oscillator clock to 40 MHz. This is reflected in the fuse bit and clock settings.

 #fuses H4 ….
  
 #use delay(clock = 40M)     

However, PICs usually take 4 clock cycles per instruction and so the effective system clock frequency is 10 MHz.

Thus, one tick of Timer 1 is:

Thus, at the base frequency of 50 kHz (20 µs), Timer 1 would count:

Since the reference inductor and capacitor values are know the following equations simply as:

The same applies for inductor measurement too and the formula simplifies as shown below:

The fixed constants are defined in definitions on top of the code

 #define C_cal_in_nF         100.0 
 #define L_cal_in_uH         100.0              
 #define pi                  3.142                                                                                                                                              
 #define cal_delay           1000   
                                                                              
 #define scaling_factor_c    ((10.0 / (4.0 * pi * pi * L_cal_in_uH)))    
 #define scaling_factor_l    ((10.0 / (4.0 * pi * pi * C_cal_in_nF)))       

Now let’s say we want to measure 220nF. So, for this amount of capacitance, the oscillator frequency would be:

Timer 1 would count 355 counts while capturing this frequency from the oscillator.

Now if we back-calculate using the formulae shown previously, the capacitor is found to be:

Yes, the reading is a bit off from actual value but close enough to actual value. The error occurs because timer counts cannot be anything other than integers. This error can be smartly compensated in code.

The push button connected to pin C0 is used to select either inductance or capacitance measurement mode. Every time the mode is changed, calibration would be needed. The calibration procedure is simple. We just have to leave our meter with nothing connected except the reference capacitor and inductor as shown the following circuit diagram. This is the Hartley oscillator and the core part of the entire device.

During this time, the reference component value is measured and saved. This value would be deducted during unknown component measurement. During calibration, the meter’s display would show instruction for not placing any external component.

After the calibration is completed, unknown components can be placed and measured accordingly. These are all what the program’s main loop does.

     while(TRUE)                          
     {                                                                 
         t = (pulse_ticks);  
         value = ((double)t * (double)t);
          
         if(mode_button == FALSE)
         {
            delay_ms(60);                                             
            while(mode_button == FALSE);    
            calibration_done = 0; 
            mode++;
            
            if(mode > 1)
            {
                mode = 0;
            }
         }  
                              
         if(calibration_done == 0) 
         {
             lcd_putc("\f");               
             lcd_gotoxy(1, 1);
             lcd_putc("Calibrating....");                                                               
             lcd_gotoxy(1, 2);              
             lcd_putc("Place no part.");                                                                 
             delay_ms(cal_delay);        
             lcd_putc("\f");    
             
             if(mode == 0)
             {   
                 ref = (value * scaling_factor_c);   
                 lcd_gotoxy(1, 1);  
                 lcd_putc("C.ref/nF:");         
                 lcd_gotoxy(1, 2);
                 printf(lcd_putc, "%3.1g   ", ref);   
                   
             }
             
             if(mode == 1)            
             {                                             
                 ref = (value * scaling_factor_l);
                 lcd_gotoxy(1, 1);  
                 lcd_putc("L.ref/uH:");        
                 lcd_gotoxy(1, 2);
                 printf(lcd_putc, "%3.1g   ", ref);   
             }  
             
             delay_ms(cal_delay);        
             lcd_putc("\f");
                                                  
             calibration_done = 1;
         } 
         
         else
         {   
             lcd_gotoxy(1, 1);  
             
             switch(mode)
             {
                 case 1:
                 {
                     value = (value * scaling_factor_c);  
                     lcd_putc("Ind./uH:");       
                                                
                     break;
                 }   
                                          
                 default:
                 {   
                     value = (value * scaling_factor_l);   
                     lcd_putc("Cap./nF:");        
             
                     break;
                 }
             }
             
             value -= ref;
                      
             if((value < 0) || (value > 1000))             
             {              
                value = 0;
             }  
                          
             lcd_gotoxy(1, 2);                               
             printf(lcd_putc, "%3.1g         ", value);   
         }
       
         delay_ms(100);                   
     };  

Some time-proven good-old tricks have been applied in this code:

1. Instead of measuring frequency, time period is measured. This saved one calculation step because frequency is inverse of time period.

• Rather than using math library, some values that need to raised by some power, is simply repeated multiplied. For example, the time period needs to be squared but instead it is multiplied by itself.

• Definitions have been used in order to identify some important constant values and reduce calculation.

• The use of global variables has been kept to a minimum. Although the code is nothing compared to the memory resources of the PIC18 microcontroller.

• Interrupt methods have been employed to make the program efficient and as less blocking as possible.

• Unused hardware peripherals have been reinitialized to reduce power consumption and other issues.

Demo

All files related to this project can be found here.

Happy coding.

Author: Shawon M. Shahryiar

https://www.facebook.com/groups/microarena

https://www.facebook.com/MicroArena                                     

23.08.2022

Personally, I have a long professional career in the field of LED lighting, renewable energy (mainly solar), Lithium and industrial battery systems, electronics and embedded-systems. I have been at the core of designing, testing, commissioning and analyzing some of the largest solar power projects of my country – a privilege that only a few enjoyed. In many of my solar-energy endeavors, I encountered several occasions that required me to estimate solar isolation or solar irradiation. Such situations included testing solar PV module efficiencies, tracking solar system performance with seasons, weather, sky conditions, dust, Maximum Power Point Tracking (MPPT) algorithms of solar inverters, chargers, etc.

I wanted a simply way with which I can measure solar irradiance with some degree of accuracy. Having the advantage of working with raw solar cells, tools that test cells and complete PV modules combined with theoretical studies, I found out a rudimentary method of measuring solar irradiation.

In simple terms, solar insolation is defined as the amount of solar radiation incident on the surface of the earth in a day and is measured in kilowatt-hour per square meter per day (kWh/m²/day). Solar irradiation, on the other hand, is the power per unit area received from the Sun in the form of electromagnetic radiation as measured in the wavelength range of the measuring instrument. It is measured in watt per square meter (W/m²). The solar insolation is, therefore, an aggregate of solar irradiance over a day.   Sun energy collection by solar photovoltaic (PV) modules is depended on solar irradiance and this in turn has impact on devices using this energy. For example, in a cloudy day a solar battery charger may not be able to fully charge a battery attached to it. Likewise, in a sunny day the opposite may come true.

Solar PV Cells

For making a solar irradiation meter we would obviously need a solar cell. In terms of technology, there are three kinds of cells commonly available in the market and these are shown below.

Basic Solar Math

Typically, Earth-bound solar irradiation is about 1350 W/m². About 70 – 80% of this irradiation makes to Earth’s surface and rest is absorbed and reflected. Thus, the average irradiation at surface is about 1000 W/m². Typical cell surface area of a poly crystalline cell having dimensions 156 mm x 156 mm x 1mm is:

The theoretical or ideal wattage of such a cell should be:

However, the present-day cell power with current technology somewhere between 4 – 4.7 Wp. It is safe to assume an average wattage of a typical poly crystalline cell to be 4.3 Wp. Therefore, cell efficiency is calculated to be:

72 cells of 4.3 Wp capacity will form a complete solar PV module of 310Wp.

Likewise, the approximate area of a 310 Wp solar panel having dimensions (1960 mm x 991 mm x 40 mm) is:

The theoretical wattage that we should be getting with 1.942 m² area panel is found to be:

Therefore, module/panel efficiency is calculated to be:

Cell efficiency is always higher than module efficiency because in a complete PV module there are many areas where energy is not harvested. These areas include bus-bar links, cell-to-cell gaps, guard spaces, aluminum frame, etc. As technology improves, these efficiencies also improve.

Monocrystalline cells have same surface are but more wattage, typically between 5.0 to 5.5 Wp. We can assume an average cell wattage of 5.2 Wp.

Therefore, cell efficiency is calculated to be:

Typically, monocrystalline PV modules consist of 60 cells and so 60 such cells are arranged then the power of a complete PV module is calculated to be:

The area of that PV module having dimensions 1650 mm x 991 mm x 38 mm would be:

The theoretical wattage that we should be getting with 1.635 m² area panel is found to be:

Therefore, module/panel efficiency is calculated to be:

These calculations prove the following points:

• Monocrystalline PV modules can harvest the same amount of energy as their polycrystalline counterparts with lesser area.
• Monocrystalline cells are more efficient than poly crystalline cells.
• Monocrystalline PV modules are more efficient than polycrystalline PV modules.
• 156 mm x 156 mm cell dimension is typical but there are also cells of other dimensions like 125 mm x 125 mm x 1 mm.
• Though I compared monocrystalline and polycrystalline cells and modules here the same points are true for thin film or amorphous cells.
• Currently, there are more efficient cells and advanced technologies, and thus higher power PV modules with relatively smaller area. For instance, at present there are PV modules from Tier 1 manufacturers that have powers well above 600W but their physical dimensions are similar to 300Wp modules.

Solar PV modules can be generally categorized in four categories based on the number of solar cells in series and they usually have the following characteristics:

36 Cells

• 36 x 0.6 V = 21.6V (i.e., 12V Panel)
• VOC = 21.6V
• VMPP = 16 – 18V
• For modules from 10 – 120 Wp

60 Cells

• 60 x 0.6 V = 36V
• VOC = 36V
• VMPP = 25 – 29V
• For modules from 50 – 300+ Wp

72 Cells

• 72 x 0.6 V = 43.2V (i.e., 24V Panel)
• VOC = 43.2V
• VMPP = 34 – 38V
• For modules from 150 – 300+ Wp

96 Cells

• 96 x 0.6 V = 57.6V (i.e., 24V Panel)
• VOC = 57.6V
• VMPP = 42 – 48V
• For modules from 250 – 300+ Wp
• Rare

One cell may not be fully used and could be cut with laser scribing machines to meet voltage and power requirements. Usually, the above-mentioned series connections are chosen because they are the standard ones. Once a cell series arrangement is chosen, the cells are cut accordingly to match required power. A by-cut cell has lesser area and therefore lesser power. Cutting a cell reduces its current and not its voltage. Thus, power is reduced. 36 cell modules are also sometimes referred as 12V panels although there is no 12V rating in them and this is because such modules can directly charge a 12V lead-acid battery but cannot charge 24V battery systems without the aid of battery chargers. Similarly, 72 cell modules are often referred as 24V panels.

Important Parameters of a Panel/Cell

Open Circuit Voltage (Voc) –no load/open-circuit voltage of cell/panel. 

Short Circuit Current (Isc) – current that will flow when the panel/cell is shorted in full sunlight.

Maximum Power Point Voltage (VMPP) – output voltage of a panel at maximum power point or at rated power point of the cell’s/panel’s characteristics curve.

Maximum Power Point Current (IMPP) – output current of a panel at maximum power point or at rated power point of the cell’s/panel’s characteristics curve.

Peak Power (Pmax) – the product of VMPP and IMPP. It is the rated power of a cell’s/PV module at STC. Its unit is watt-peak (WP) and not watts because this is the maximum or peak power of a cell/module.

Power Tolerance – percentage deviation of power.

STC stands for Standard Temperature Condition or simply lab conditions (25°C).

AM stands for Air Mass – This can be used to help characterize the solar spectrum after solar radiation has traveled through the atmosphere.

E stands for Standard Irradiation of 1000 W/m².

Shown below is the technical specification sticker of a 320 Wp JA Solar PV Module:

According to the sticker the PV module has the following specs at STC and irradiation, E = 1000 W/m²:

VOC = 46.12 V

VMPP = 37.28 V

Isc = 9.09 A

IMPP = 8.58 A

Pmax = 320 WP

From these specs we can estimate and deduce the followings:

VMPP-by-VOC ratio:

This value is always between 76 – 86%.

Similarly, IMPP-by-ISC ratio:

This value is always between 90 – 96%.

The product of these ratios should be as high as possible. Typical values range between 0.74 – 0.79. This figure represents fill-factor (FF) of a PV module or a PV cell. 

An ideal PV cell/module should have a characteristics curve represented by the green line. However, the actual line is represented by the blue one. Fill-Factor is best described as the percentage of ideality. Thus, the greater it is or the closer it is to 100 % the better is the cell/module.  

In this case, the FF is calculated to be 0.94 x 0.81 = 0.76 or 76%.

Number of cells is calculated to be:

Therefore, each cell has an open circuit voltage (VOC) of:

IMPP is 8.58 A and ISC is 9.09 A.

Cell power is calculated as follows:

Efficiencies are deduced as follows:

The I-V curves of the PV module shown below show the effect of solar irradiation on performance. It is clear that with variations in solar irradiation power production varies. The same is shown by the power curve. Voltage and current characteristics follow a similar shape.

The I-V curve shown below demonstrates the effect of temperature on performance. We can see that power production performance deteriorates with rise in temperature.

The characteristics curves of the 320 Wp JA Solar PV module are shown above. From the curves above we can clearly see the following points:

• Current changes with irradiation but voltage changes slightly and so power generation depends on irradiation and current.
• Current changes slightly with temperature but voltage changes significantly. At high temperatures, PV voltage decreases and this leads to change in Maximum Power Point (MPP) point. Thus, at high temperatures power generation decreases and vice-versa.
• Vmpp-by-Voc ratio remains pretty much the same at all irradiation levels.
• The curves are similar to that of a silicon diode and this is so because a cell is essentially a light sensitive silicon diode.

Impacts of Environment on PV

Effect of Temperature

Let us now see how temperature affects solar module performance. Remember that a solar cell is just like a silicon diode and we know that a silicon diode’s voltage changes with temperature. This change is about -2 mV/°C. Thus, the formula below demonstrates the effect of temperature:

Suppose the ambient temperature is 35°C and let us consider the same 320 Wp PV module having:

VOC at STC = 46.12V

VMPP at STC = 37.28V

Therefore, the temperature difference from STC is:

Under such circumstance the VMPP should be about 35V but it gets decreased more and fill-factor is ultimately affected.

So clearly there is a shift in VMPP which ultimately affects output power. This is also shown in the following graph:

Effect of Shading, Pollution and Dust

Power generation is also affected by shades, i.e., obstruction of sunlight. Obstacles can be anything from a thin stick to a large tree. Dust and pollution also contribute to shading on microscopic level. However, broadly speaking, shading can be categorized in two basic categories – Uniform Shading and Non-uniform Shading.

Uniform shading is best described as complete shading of all PV modules or cells of a solar system. This form of shading is mainly caused by dust, clouds and pollution. In such shading conditions, PV current is affected proportionately with the amount of shading, yielding to decreased power collection. However, fill-factor and efficiencies are literally unaffected.

Non-uniform shading, as its name suggests, is partial shading of some PV modules or cells of a solar system. Causes of such shading include buildings, trees, electric poles, etc. Non-uniform shading must be avoided because cells that receive less radiation than the others behave like loads, leading to formation of hotspots in long-run. Shadings as such result in decreased efficiency, current and power generation because of multiple wrong MPP points.

Effect of Other Variables

There are several other variables that have effect on solar energy collection. Variables and weather conditions like rain, humidity, snow, clouds, etc. affect energy harvest while cool, windy and sunny conditions have positive impact on energy harvest. These factors are region and weather dependent and cannot be generalized.

Basic Solar Geometry

Some basics of solar geometry is needed to be realized to efficiently design solar systems and how sun rays are reach earth. Nature follows a mathematical pattern that it never suddenly or abruptly alters. The movement of the sun and its position on the sky at any instance can be described by some simple trigonometric functions. The Earth not just orbits the Sun but it tilts and revolves about its axis. The daily rotation of the Earth about the axis through its North and South poles (also known as celestial poles) is perpendicular to the equator point, however it is not perpendicular to the plane of the orbit of the Earth. In fact, the measure of tilt or obliquity of the axis of the Earth to a line perpendicular to the plane of its orbit is currently about 23.5°.

The plane of the Sun is the plane parallel to the Earth’s celestial equator and through the center of the sun. The Earth passes alternately above and below this plane making one complete elliptic cycle every year.

In summer solstice, the Sun shines down most directly on the Tropic of Cancer in the northern hemisphere, making an angle δ = 23.5° with the equatorial plane. Likewise, in winter solstice, it shines on the Tropic of Capricorn, making an angle δ = -23.5° with the equatorial plane. In equinoxes, this angle δ is 0°. Here δ is called the angle of declination. In simple terms the angle of declination represents the amount of Earth’s tilt or obliquity.

The angle of declination, δ, for Nth day of a year can be deduced using the following formula:

Here, N = 1 represents 1^st January.

The angle of declination has effect on day duration, sun travel path and thus it dictates how we should tilt PV modules with respect to ground with seasonal changes. 

The next most important thing to note is the geographical location in terms of GPS coordinates (longitude, λ East and latitude, ϕ North). This is because geo location also has impact on the aforementioned. Northern and Southern Hemispheres have several differences.

Shown below is a graphical representation of some other important solar angles. Here:

• The angle of solar elevation, ά, is the angular measure of the Sun’s rays above the horizon.

• The solar zenith angle, Z, is the angle between an imaginary point directly above a given location, on the imaginary celestial sphere. and the center of the Sun‘s disc. This is similar to tilt angle.

The azimuth angle, A, is a local angle between the direction of due North and that of the perpendicular projection of the Sun down onto the horizon line measured clockwise.

The angle of solar elevation, ά, at noon for location on Northern Hemisphere can be deduced as follows:

Similarly, for location on Southern Hemisphere, the angle of solar elevation at noon can be deduced as follows:

Here ϕ represents latitude and δ represents angle of declination. Zenith/Tilt angle is found to be:

Determining azimuth angle is not simple as additional info are needed. The first thing that we will need is to the sunrise equation. This is used to determine the local time of sunrise and sunset at a given latitude, ϕ at a given solar declination angle, δ. The sunrise equation is given by the formula below:

Here ω is the hour angle. ω is between -180° to 0° at sunrise and between 0° to 180° at sunset.

If [tan(ϕ).tan(δ)] ≥ 1, there is no sunset on that day. Likewise, if [tan(ϕ).tan(δ)] ≤ -1, there is no sunrise on that day.

The hour angle, ω is the angular distance between the meridian of the observer and the meridian whose

plane contains the sun. When the sun reaches its highest point in the sky at noon, the hour angle is zero. At this time the Sun is said to be ‘due south’ (or ‘due north’, in the Southern Hemisphere) since the meridian plane of the observer contains the Sun. On every hour the hour angle increases by 15°.

From hour angle, we can determine the local sunrise and sunset times as follows:

For a given location, hour angle and date the angle of solar elevation can be expressed as follows:

Since we have the hour angle info along with sunrise and sunset times, we can now determine the azimuth angle. It is expressed as follows:

Solving the above equation for A will yield in azimuth angle.

Knowing azimuth and solar elevation angles help us determine the length and location of the shadow of an object. These are important for solar installations.

The length of the shadow is as in the figure above is found to be:

From the geometric analysis, it can be shown that solar energy harvest will increase if PV modules can be arranged as such to follow the Sun. This is the concept of solar tracking system.

If the Sun can be tracked according to these math models, the maximum possible harvest can be obtained. However, some form of solar-tracking structures will be needed. An example of sun tracking system is shown above. This was designed by a friend of mine and myself back in 2012. He designed the mechanical section while I added the intelligence in form of embedded-system coding and tracking controller design.

Here’s a photo of the sun tracking controller that I designed. It used a sophisticate algorithm to track the sun.

Building the Device

In order to build the solar irradiance meter, we will need a solar cell or a PV module of known characteristics. Between a single cell and module, I would recommend for a cell because:

• Cells have lower power than complete modules.
• Cells have almost no framing structure.
• Cells are small and light-weight.
• Cells are individual and so there is no need to take account of series-parallel combination.

We would see why these are important as we move forward.

For the project, I used a cheap amorphous solar cell as shown in the photo below. It looks like a crystalline cell under my table lamp but actually it is an amorphous one. It can be purchased from AliExpress, Amazon or similar online platform.

With a cell test machine, it gave a characteristic curve and data as shown below:

From this I-V characteristics curve, we can see its electrical parameters. The cell has a physical dimension of 86mm x 56mm and so it has an area of 0.004816m².

From the calculation which I already discussed, irradiation measurement needs two known components – the total cell area and the maximum power it can generate. We know both of these data. Now we just have to formulate how we can use these data to measure irradiation.

Going back to a theory taught in the first year of electrical engineering, the maximum power transfer theorem, we know that to obtain maximum external power from a source with a finite internal resistance, the resistance of the load must equal the resistance of the source as viewed from its output terminals. This is the theory behind my irradiation measurement.

From the cell electrical characteristics data, we can find the ideal resistance that is needed to make this theory work.

It is important to note that we would just be focusing on maximum power point data only and that is because this is the maximum possible output that the cell will provide at the maximum irradiation level of 1000W/m². The ideal resistance is calculated as follows:

and so does the electric current. The voltage that would be induced across RMPP is proportional to this current because according to Ohms law:

The equivalent circuit is as shown below:

The boxed region is the electrical equivalent of a solar cell. At this point it may look complicated but we are not digging inside the box and so it can be considered as a mystery black box.

We know that:

We know the value of resistance and all we have to do is to measure the voltage (V) across the cell. We also know the area of the cell and so we can deduce the value of irradiation, E incident on the cell according to the formula:

Schematic

Code

#include "N76E003.h"
#include "SFR_Macro.h"
#include "Function_define.h"
#include "Common.h"
#include "Delay.h"
#include "soft_delay.h"
#include "LCD_2_Wire.h"

#define Vmpp                    5.162F
#define Impp                    0.056F
#define R_actual                (Vmpp / Impp)
#define R_fixed                 100.0F //    
#define R_Error                 (R_fixed / R_actual)
#define ADC_Max                 4095.0F
#define VDD                     3.3F
#define scale_factor            2.0F

#define cell_efficiency         0.065F // 6.5% (Typical Amorphous Cell Efficiency)
#define cell_length             0.0854F // 85.4mm as per inscription on the cell
#define cell_width              0.0563F // 56.3mm as per inscription on the cell
#define effective_area_factor   0.90F // Ignoring areas without cell, i.e. boundaries, frames, links, etc
#define cell_area               (cell_length * cell_width) // 0.004816 sq.m  
#define effective_cell_area     (cell_area * effective_area_factor * cell_efficiency) // 0.000281736 sq.m

void setup(void);
unsigned int ADC_read(void);
unsigned int ADC_average(void);
void lcd_print(unsigned char x_pos, unsigned char y_pos, unsigned int value);

void main(void)
{
  unsigned int ADC = 0;
  float v = 0;
  float V = 0;
  float P = 0;
  float E = 0;
  
  setup();
  
  while(1)
  {
      ADC = ADC_average();
      v = ((VDD * ADC) / ADC_Max);        
      V = (v * scale_factor);
      P = (((V * V) / R_fixed) * R_Error);
      E = (P / effective_cell_area);
        
      lcd_print(12, 0, (unsigned int)(P * 1000.0));
      lcd_print(12, 1, (unsigned int)E);
        
      delay_ms(100);
  };
}

void setup(void)
{ 
  LCD_init();
  LCD_clear_home(); 
  LCD_goto(0, 0); 
  LCD_putstr("PV PWR mW:");
  LCD_goto(0, 1); 
  LCD_putstr("E. W/sq.m:");
  
  Enable_ADC_AIN0;
}

unsigned int ADC_read(void)
{
  register unsigned int value = 0x0000;
  
  clr_ADCF;
  set_ADCS;                                 
  while(ADCF == 0);
  
  value = ADCRH;
  value <<= 4;
  value |= ADCRL;
  
  return value;
}

unsigned int ADC_average(void)
{
    signed char samples = 16;
    unsigned long value = 0;
    
    while(samples > 0)
    {
        value += ((unsigned long)ADC_read());
        samples--;
    };
    
    value >>= 4;
    
    return ((unsigned int)value);
}

void lcd_print(unsigned char x_pos, unsigned char y_pos, unsigned int value)
{  
  unsigned char ch = 0;

    if((value > 999) && (value <= 9999))
    {
        ch = (((value % 10000) / 1000) + 0x30);
        LCD_goto(x_pos, y_pos);
        LCD_putchar(ch);
        
        ch = (((value % 1000) / 100) + 0x30);
        LCD_goto((x_pos + 1), y_pos);
        LCD_putchar(ch);
        
        ch = (((value % 100) / 10) + 0x30);
        LCD_goto((x_pos + 2), y_pos);
        LCD_putchar(ch);
        
        ch = ((value % 10) + 0x30);
        LCD_goto((x_pos + 3), y_pos);
        LCD_putchar(ch);
    }
    
    else if((value > 99) && (value <= 999))
    {
        ch = 0x20;
        LCD_goto(x_pos, y_pos);
        LCD_putchar(ch);
        
        ch = (((value % 1000) / 100) + 0x30);
        LCD_goto((x_pos + 1), y_pos);
        LCD_putchar(ch);
        
        ch = (((value % 100) / 10) + 0x30);
        LCD_goto((x_pos + 2), y_pos);
        LCD_putchar(ch);
        
        ch = ((value % 10) + 0x30);
        LCD_goto((x_pos + 3), y_pos);
        LCD_putchar(ch);
    }
    
    else if((value > 9) && (value <= 99))
    {
        ch = 0x20;
        LCD_goto(x_pos, y_pos);
        LCD_putchar(ch);
        
        ch = 0x20;
        LCD_goto((x_pos + 1), y_pos);
        LCD_putchar(ch);
        
        ch = (((value % 100) / 10) + 0x30);
        LCD_goto((x_pos + 2), y_pos);
        LCD_putchar(ch);
        
        ch = ((value % 10) + 0x30);
        LCD_goto((x_pos + 3), y_pos);
        LCD_putchar(ch);
    }
    
    else
    {
        ch = 0x20;
        LCD_goto(x_pos, y_pos);
        LCD_putchar(ch);
        
        ch = 0x20;
        LCD_goto((x_pos + 1), y_pos);
        LCD_putchar(ch);
        
        ch = 0x20;
        LCD_goto((x_pos + 2), y_pos);
        LCD_putchar(ch);
        
        ch = ((value % 10) + 0x30);
        LCD_goto((x_pos + 3), y_pos);
        LCD_putchar(ch);
    }   
}

Explanation

This project is completed with a Nuvoton N76E003 microcontroller. I chose this microcontroller because it is cheap and features a 12-bit ADC. The high-resolution ADC is the main reason for using it because we are dealing with low power and thus low voltage and current. The solar cell that I used is only about 300mW in terms of power. If the reader is new to Nuvoton N76E003 microcontroller, I strongly suggest going through my tutorials on this microcontroller here.

Let us first see what definitions have been used in the code. Most are self-explanatory.

#define Vmpp                    5.162F
#define Impp                    0.056F
#define R_actual                (Vmpp / Impp)
#define R_fixed                 100.0F //    
#define R_Error                 (R_fixed / R_actual)
#define ADC_Max                 4095.0F
#define VDD                     3.3F
#define scale_factor            2.0F

#define cell_efficiency         0.065F // 6.5% (Typical Amorphous Cell Efficiency)
#define cell_length             0.0854F // 85.4mm as per inscription on the cell
#define cell_width              0.0563F // 56.3mm as per inscription on the cell
#define effective_area_factor   0.90F // Ignoring areas without cell, i.e. boundaries, frames, links, etc
#define cell_area               (cell_length * cell_width) // 0.004816 sq.m  
#define effective_cell_area     (cell_area * effective_area_factor * cell_efficiency) // 0.000281736 sq.m 

Obviously VMPP and IMPP are needed to calculate RMPP and this is called here as R_actual. R_fixed is the load resistor that is put in parallel to the solar cell and this is the load resistor needed to fulfill maximum power transfer theorem. Practically, it is not possible to get 92.18Ω easily and so instead of 92.18Ω ,a 100Ω (1% tolerance) resistor is placed in its place. The values are close enough and the difference between these values is about 8%. This difference is also taken into account in the calculations via the definition R_Error.

Thus, during calculation this amount of difference should be compensated for.

ADC_Max and VDD are maximum ADC count and supply voltage values respectively. These would be needed to find the voltage resolution that the ADC can measure.

Since 806µV is a pretty small figure, we can rest assure that very minute changes in solar irradiance will be taken into account during measurement.

scale_factor is the voltage divider ratio. The cell gives a maximum voltage output of 5.691V but N76E003 can measure up to 3.3V. Thus, a voltage divider is needed.

This is the maximum voltage that N76E003 will see when the cell reaches open-circuit voltage. Thus, the ADC input voltage needs to be scaled by a factor of 2 in order to back-calculate the cell voltage, hence the name scale_factor.

The next definitions are related to the cell that is used in this project. Cell length and width are defined and with these the area of the cell is calculated.

The physical cell area does not represent the total area that is sensitive to solar irradiation. There are spaces within this physical area that contain electrical links, bezels or frame, etc. Thus, a good estimate of effective solar sensitive cell area is about 90% of the physical cell area. This is defined as the effective_area_factor.    

Lastly, we have to take account of cell efficiency because we have seen that in a given area not all solar irradiation is absorbed and so the cell_efficiency is also defined. Typically, a thin film cell like the one I used in this project has an efficiency of 6 – 7% and so a good guess is 6.5%. All of the above parameters lead to effective cell area and it is calculated as follows:

So now the aforementioned equation becomes as follows:

The equations suggest that only by reading ADC input voltage we can compute both the power and solar irradiance.

The code initializes by initializing the I2C LCD, printing some fixed messages and enabling ADC pin 0.

void setup(void)
{ 
  LCD_init();
  LCD_clear_home(); 
  LCD_goto(0, 0); 
  LCD_putstr("PV PWR mW:");
  LCD_goto(0, 1); 
  LCD_putstr("E. W/sq.m:");
  
  Enable_ADC_AIN0;
} 

The core components of the code are the functions related to ADC reading and averaging. The code below is responsible for ADC reading.

unsigned int ADC_read(void)
{
  register unsigned int value = 0x0000;
  
  clr_ADCF;
  set_ADCS;                                 
  while(ADCF == 0);
  
  value = ADCRH;
  value <<= 4;
  value |= ADCRL;
  
  return value;
}  

The following code does the ADC averaging part. Sixteen samples of ADC reading are taken and averaged. Signal averaging allows for the elimination of false and noisy data. The larger the number of samples, the more is the accuracy but having a larger sample collection lead to slower performance.

unsigned int ADC_average(void)
{
    signed char samples = 16;
    unsigned long value = 0;
    
    while(samples > 0)
    {
        value += ((unsigned long)ADC_read());
        samples--;
    };
    
    value >>= 4;
    
    return ((unsigned int)value);
}  

In the main, the ADC average is read and this is converted to voltage. The converted voltage is then upscaled by applying the scale_factor to get the actual cell voltage. With the actual voltage, power and irradiation are computed basing on the math aforementioned. The power and irradiation values are displayed on the I2C LCD and the process is repeated every 100ms.

ADC = ADC_average();
v = ((VDD * ADC) / ADC_Max);        
V = (v * scale_factor);
P = (((V * V) / R_fixed) * R_Error);
E = (P / effective_cell_area);
        
lcd_print(12, 0, (unsigned int)(P * 1000.0));
lcd_print(12, 1, (unsigned int)E);
        
delay_ms(100); 

I have tested the device against a SM206-Solar solar irradiation meter and the results are fairly accurate enough for simple measurements.

Demo

Demo video links:

Improvements and Suggestions

Though this device is not a professional solar irradiation measurement meter, it is fair enough for simple estimations. In fact, SMA – a German manufacturer of solar inverter, solar charger and other smart solar solution uses a similar method with their SMA Sunny Weather Station. This integration allows them to monitor their power generation devices such as on-grid inverters, multi-cluster systems, etc. and optimize performances.  

There are rooms for lot of improvements and these are as follows:

• A temperature sensor can be mounted on the backside of the solar cell. This sensor can take account of temperature variations and thereby compensate readings. We have seen that temperature affects solar cell performance and so temperature is a major influencing factor.
• A smaller cell would have performed better but it would have needed additional amplifiers and higher resolution ADCs. A smaller cell will have lesser useless areas and weight. This would make the device more portable.
• Using filters to filter out unnecessary components of solar spectrum.
• Adding a tracking system to scan and align with the sun would result in determining maximum irradiation.

Project Code can be found here.

Happy coding.

Author: Shawon M. Shahryiar

https://www.facebook.com/groups/microarena

https://www.facebook.com/MicroArena                                                                     

28.02.2022

This is the continuation of my first post on STC 8051 Microcontrollers here.

Many Chinese microcontroller manufacturers develop awesome and cheap general-purpose MCUs using the popular 8051 architecture. There are many reasons for that but most importantly the 8051 architecture is a very common one that has been around for quite a long time. Secondly, manufacturing MCUs with 8051 DNA allows manufacturers to focus less on developing their own proprietary core and to give more effort in adding features. Holtek, Nuvoton, STC, etc are a few manufacturers to name.

Rather than mastering a good old 8051-based microcontroller like the AT89C52 or similar, it is better to learn something new that has many similarities with that architecture. As mentioned earlier, STC has various flavour of microcontrollers based on 8051 cores. STC8A8K64S4A12 of the STC8 family is one such example. Here for this documentation, I will be using this MCU specifically. In short, it is a beast as it offers lot of additional hardware that are usually not seen in regular 8051s. Some key features are listed below. The red box highlights the STC8A8K64S4A12 micro in particular.

I chose STC8A8K64S4A12 for this tutorial for all of its rich features. My favourite features include 12-bit ADC, multiple timers, reduced EMI feature and PCA module.

Now let’s see the naming convention of STC microcontrollers. The figure below shows us what the name of a STC8 micro means:

The name STC8A8K64S4A12 is quite a mouthful and given the nomenclature info, STC8A8K64SA412 is actually a STC8 series micro with on-chip 12-bit ADC, 8kB SRAM, 64kB code space and 4 hardware serial (UART) ports. Apart from these hardware thingies, the naming convention does not reveal other cool features, for if it had been so, the device name would be even longer.   

Initially I wanted to make this tutorial with the STC15F(L)204EA microcontroller but later I changed my mind because STC8A8K64S4A12 is much richer in hardware peripheral terms than STC15F(L)204EA, not to mention several similar hardware are present in both models of microcontroller. Since I planned to use STC8A8K64S4A12, I waited for the arrival of the board shown below before completing this work. Although this development board is an official board, it has been smartly designed for fast learning and rapid deployment of projects. As a matter of fact, if someone learns about this micro with this board, he/she will rule over all of STC’s 8051-based line-up.

This board has the following schematic and it will be needed throughout this tutorial.

On board, we have connectors for OLED display, GLCD, LCD, TFT Display, nRF24L01 transceiver, ESP8266 Wi-Fi module, etc. We also have on board W25x16 flash, 24C04 EEPROM, RS485 communication bridge and a CH340G USB-serial converter that doubles as an on-board programmer.

For more details on the introduction pricing and onboard features of CrowPi2, visit the Kickstarter page.

First of all, MSP430F5529 is a monster microcontroller because it offers large memory spaces– 128kB of flash and 8kB of RAM. Secondly, it is a 16-bit RISC microcontroller that host several advanced features like USB, DMA, 12-bit SAR ADC, analogue comparator, a real time clock (RTC), several sophisticated timers with multiple capture-compare I/O channels, etc. There is an on-chip hardware multiplier apart from several bidirectional general-purpose digital input-output (DIO/GPIO) pins, multipurpose communication peripherals (USCIs) and a highly complex clock and power system that can be tweaked to optimize the speed-power performances. The MSP430F5529LP microcontroller featured on-board MSP430F5529 Launchpad is a low power energy-efficient variant of MSP430F5529 and hence the LP designation at the end of the part naming. It can run at low voltage levels like 1.8V. In short, it is a hobbyist wildest dream come true.

MSP-EXP430F5529LP Launchpad Board

The MSP-EXP430F5529LP Launchpad board is just like other Launchpad boards, having similar form-factor and layout. Unlike the previously seen MSP-EXP430G2 Launchpads, its header pins are brought out using dual-sided male- female rail-connectors. These allow us to stack BoosterPacks on both sides.

Shown above and below are the pin maps of this Launchpad board.

The first pin map is useful for Energia users and the second one is useful for CCS users. I use a combination of both. Like other Launchpad boards, this Launchpad comes with a separable MSP-FET USB programmer and debugger interface. Since MSP430F5529 micro has USB hardware embedded in it, the on-board micro USB port can act as a physical USB port when developing USB-based hardware. The micro USB port isn’t, however, directly connected with the chip. Instead of that, the same USB port is connected to the on-board FET programmer and the MSP430F5529 chip via an on-board USB hub. The micro USB port also provides power to the board. The on-board MSP430 chip is powered by 3.3V LDO regulator. This LDO is not meant for driving large loads. There are sufficient power rail pins to hook-up low-power external devices like sensors, LCDs, etc without the need of power rail extenders.   

MSP430F5529 is not a low pin count micro and it has a sophisticated clock system that can be feed with both internal and external clock sources. Thus, unlike MSP430G2xxx Launchpads, this Launchpad comes with two external crystals – a 4MHz and a 32.768kHz crystal that are physically connected with GPIO pins. There are two user buttons and two LEDs also. Additionally, there are dedicated buttons for USB bootstrap loader and hardware reset. There are few jumpers that can be for measurements, debugging, programming, etc.

Shown below is the schematic of MSP430F5529LP Launchpad board:

TI MSP430Ware Driver Library and Other Stuffs

Like with other advanced microcontrollers from TI, there is no GRACE-like support that can be found for MSP430F5529 and similar devices. In fact, GRACE only supports few low-end and mid-end MSP430 microcontrollers and for some reason TI stopped updating this great tool since 2013. One probably reason may be the difficulty in developing a GUI-based application that can be used across all computer platforms (Windows, Linux, Mac OS, etc) while maintaining support for all ever-growing families of MSP430 devices.

Instead of upgrading GRACE, TI invested on something called MSP430Ware Driver Library or simply Driverlib. Driverlib replaces traditional register-level coding with a set of dedicated hardware libraries that reduces learning and implementation curves. These libraries consist of functions, variables and constants that have meaningful names. A sample code is shown below:

Timer_A_outputPWMParam outputPWMParam = {0}; 
outputPWMParam.clockSource = TIMER_A_CLOCKSOURCE_SMCLK; outputPWMParam.clockSourceDivider = TIMER_A_CLOCKSOURCE_DIVIDER_2; outputPWMParam.timerPeriod = 20000; 
outputPWMParam.compareRegister = TIMER_A_CAPTURECOMPARE_REGISTER_1; outputPWMParam.compareOutputMode = TIMER_A_OUTPUTMODE_RESET_SET; outputPWMParam.dutyCycle = 0; 
Timer_A_outputPWM(TIMER_A2_BASE, &outputPWMParam);

Note that there is no register-level coding involved and that’s the beauty. Here all the settings of a timer in PWM mode are being set. Each parameter is named with a meaningful name instead of some meaningless magic numbers and coding jargon.

Initially, I was doubtful and hesitant about using Driverlib because it hides away all the good-old register-level coding and at the same time it lacks good documentations. Comparing Driverlib documentation with the documentation of other manufacturers like STMicroelectronics or Microchip, I would say that Driverlib documentation is somewhat incomplete, clumsy and difficult to perceive. Adding to this is the fact that TI while developing and updating Driverlib made some changes to some function and definition names. This creates further confusion unless you are using the right version of documentation alongside the right Driverlib version.

Here’s one example. Both are correct and the compiler won’t throw any unexpected error but the first one is seen in older documentations while the second is used more often now.

Timer_A_startCounter(__MSP430_BASEADDRESS_T0A5__, TIMER_A_CONTINUOUS_MODE);

or

Timer_A_startCounter(TIMER_A0_BASE, TIMER_A_CONTINUOUS_MODE);

Issues like this one discussed above may not always be that simple and when it comes to older codes/examples, thing may become very ugly.

Another disadvantage that comes along with stuffs like Driverlib is resource management. Indeed, Driverlib reduces coding efforts a lot but at the expense of valuable and limited memory resources. Performance is also a bit compromised as execution speed is reduced due to additional hidden coding.

Despite these facts, I decided to go along with Driverlib because like other coders I didn’t want to spend time going through register-by-registers. In present day’s embedded system arena, people like the easy, effective and quick paths. It happened to me that after few trials I was able to master Driverlib and could also pinpoint issues with documentation and even practically get rid of the issues. As of this moment, I am enjoying it a lot and this whole tutorial is based on it.

Use Resource Explorer of Code Composer Studio (CCS) IDE or visit the following link:

to get access to MSP430Ware. MSP430Ware contains lot example codes, libraries and other stuffs.

The rest of the software suite and hardware tools will be same as the ones used before. Grace support is unavailable and so it won’t be used.

Please also download MSP430F5529 documentations and Launchpad board resources.

Background and Application

Sound needs a medium for propagation or travel. It can’t travel in vacuum. Normally air is that medium but sound can also propagate in liquids and other states of matter. I am not going to lecture on how sound travels and its properties as Wikipedia details everything well here. Everything we see around us has a measurement and a unit. In case of sound pressure, the unit is decibel. Our basic requirement is to be able to measure Sound Pressure Level (SPL) in decibel scale with a typical 8-bit microcontroller, an ordinary microphone and without involving complex algorithms.

Measurement of sound has a number of uses. For instance, monitoring sound pollution, security system, monitoring the quality of an amplifier, detecting sound profile of an environment, etc.

Selecting Microphone

For the ease of work and for known parameters, I selected Seeedstudio’s Grove Sound Sensor which happens to have the following specs:

Seeedstudio – a Shenzhen, China-based component manufacturer and global component supplier, has a good reputation in the hobby-electronics community, particularly amongst Arduino and Raspberry Pi users. It is one of the most reliable electronics partners that make quality items at reasonable price tags.

The Grove microphone module that Seeedstudio sells under the Grove product family banner consists of an electret microphone and a pair of general-purpose op-amps in non-inverting configuration that increase the gain roughly by 100 times. The sensor I used was an old version one and the main difference is an additional potentiometer to alter gain. Shown below is the schematic of the current version of the sensor:

The microphone module is itself very small. The Grove header and connector are simple and all products of Grove family share the same pin/header layout. The headers bring out power pins and signal pin(s). Grove connectors connect with these headers in one way only and the connectors have properly colored-wires. Thus, there is literally no chance of accidental wrong connections. The same type of header brings out the needed connections from the microphone module. We just have to connect them to our host microcontroller and power supply.

The Math

The specs of the microphone in the Grove Sound Sensor suggests that it has a sensitivity of 52 – 48dB at 1kHz spectrum. Therefore, it is best to consider an average sensitivity of 50dB. 

The formula for sensitivity is as follows:

where Output AREF is typically 1000 mV/Pa (1 V/Pa) reference output ratio.

Thus, the sensitivity of the microphone in mv/Pa is found by going on the other side of the formula as shown in the following steps:

Going back to the schematic of the microphone module, we see that the original signal is amplified by about 100 times and so the actual sensitivity of the microphone is calculated to be:

Microphone sensitivity is typically measured with a 1kHz sine wave at a 94dB sound pressure level (SPL), or with 1Pa pressure. This is a reference value. Thus, the SPL value is given by the following formula:

where 94 is the base value.

A dB reading of 40 represents near quietness while a dB reading of 95 represents the while of a train.

Schematic

As can be seen, the above schematic was designed with Proteus VSM. There is no model for Grove Sound Sensor and so to mimic it, an interactive potentiometer was used in its place. Additionally, power and additional GLCD pins have been ignored in the schematic. However, those pins are present physically.

Coding

The code was written with CCS PIC C compiler and a PIC18F242 microcontroller was used for the project due to its large memories. CCS PIC C compiler’s coding style is similar to that of Arduino’s and so I guess nobody would be having any issue understanding the code.

The coding has two major parts. First is data collection and processing, and secondly, the graphical presentation of the collected data on a Graphical Liquid Crystal Display (GLCD).

#include                                    #device *= 16  #device ADC=10 #fuses HS, PUT, NOWDT, PROTECT, CPD, BROWNOUT, BORV45 #fuses NOSTVREN, NOLVP, NODEBUG, NOCPB, NOWRT, NOWRTC #fuses NOWRTB,  NOWRTD, NOEBTR, NOEBTRB, NOOSCSEN        #use delay (clock = 10MHz)                              #define LARGE_LCD                               #define ref_SPL  94  #define sensitivity    3.16                                                                               #include  #include "HDM64GS192.c"              #include "graphics.c"        #include "background_art.c"                                                                                                                                unsigned char txt_dB_msg[30] = {"SPL Meter"}; unsigned char txt_dB_current[30]; unsigned char txt_dB_max[30];    unsigned char txt_dB_min[30];     unsigned char txt_dB_avg[30];                                      unsigned char x = 17;              float dB_max = 0.0; float dB_min = 100.0; float dB_avg = 0.0;              float dB_current = 0.0;                                                                                                                                          void setup(); void draw_background();                                                         float adc_rms();     void read_SPL(); void display_redings();             void plot_data();  float map(float value, float x_min, float x_max, float y_min, float y_max);                               void main()                                                                                 {                             setup();      draw_background();          while(TRUE)                 {         read_SPL();         display_redings();         plot_data();              delay_ms(400);     }                              }                                                                                                                                                                                              void setup()                                                                    {                                                   disable_interrupts(global);          setup_WDT(WDT_off);        setup_spi(spi_ss_disabled|spi_disabled);        setup_timer_0(T0_internal);                                      setup_timer_1(T1_disabled);                                                                                 setup_timer_2(T2_disabled, 255, 1);             set_timer0(0);        set_timer1(0);             set_timer2(0);        setup_ccp1(ccp_off);               setup_ccp2(ccp_off);        setup_ADC_ports(AN0);                                setup_ADC(ADC_clock_div_32);          set_ADC_channel(0);        glcd_init(on);           glcd_fillscreen(0);                    memset(txt_dB_current, 0, 30);             memset(txt_dB_max, 0, 30);         memset(txt_dB_min, 0, 30);            memset(txt_dB_avg, 0, 30);                                                                  glcd_text57(130, 4, txt_dB_msg, 1, ON);  }                                void draw_background()  {                                unsigned long n = 0;                          unsigned char i = 0;    unsigned char j = 0;    unsigned char cs = 0;                for(i = 0; i < 8; ++i)           {                  output_low(GLCD_DI);                                 glcd_writeByte(GLCD_LEFT, 0x40);              glcd_writeByte(GLCD_RIGHT, 0x40);                  glcd_writeByte(GLCD_MID, 0x40);                                     glcd_writeByte(GLCD_LEFT,(i | 0xB8));           glcd_writeByte(GLCD_RIGHT,(i | 0xB8));            glcd_writeByte(GLCD_MID,(i | 0xB8));                output_high(GLCD_DI);                                    for(j = 0; j = 0) && (j  0)     {         read_adc(adc_start_only);         while(!adc_done());         rms = read_adc(adc_read_only);           tmp += (rms * rms);               samples--;           }                          tmp >>= 4;                                rms = (sqrt(tmp));          rms *= 0.004875;           if(rms <= 0)     {      rms = 0.004875;     }          return rms;                     }                                          void read_SPL()  {    dB_current = adc_rms();    db_current = (ref_SPL + 20 * log10(db_current / sensitivity));         if(db_current >= 99)    {        dB_current = 99;    }                                                      if(x > 125)     { db_max = 0.0; db_min = 100.0;     x = 17;                }        if(dB_current > dB_max)          {      db_max = dB_current;      }                      if(dB_current < dB_min)          {                     db_min = dB_current;    }                           dB_avg = ((db_max + dB_min) * 0.5);    }                                                                                        void display_redings()  {                                                               glcd_text57(130, 20, txt_dB_current, 1, OFF);       sprintf(txt_dB_current, "Cr:%2.1g dB", db_current);         glcd_text57(130, 20 , txt_dB_current, 1, ON);                                                     glcd_text57(130, 30, txt_dB_max, 1, OFF);              sprintf(txt_dB_max, "Mx:%2.1g dB", dB_max);     glcd_text57(130, 30 , txt_dB_max, 1, ON);               glcd_text57(130, 40, txt_dB_min, 1, OFF);              sprintf(txt_dB_min, "Mn:%2.1g dB", dB_min);     glcd_text57(130, 40 , txt_dB_min, 1, ON);                             glcd_text57(130, 50, txt_dB_avg, 1, OFF);              sprintf(txt_dB_avg, "Av:%2.1g dB", dB_avg);     glcd_text57(130, 50, txt_dB_avg, 1, ON);  }                                                                                                                   void plot_data()                                 {                                        unsigned char l = 0;                                l = map(dB_current, 40, 99, 61, 2);         glcd_line(x, 2, x, 61, YES);       glcd_line(x, l, x, 61, NO);         x += 2; }                                         float map(float value, float x_min, float x_max, float y_min, float y_max)    {                              return (y_min + (((y_max - y_min) / (x_max - x_min)) * (value - x_min))); }          

Explaining the Code

To efficiently collect data, the Root-Mean-Square (RMS) value of 16 raw output samples from the Grove Sound Sensor is taken and the value is converted from ADC counts to voltage. This way of sampling data ensures cancellation of unnecessary noise and glitches.

float adc_rms()
{                         
    unsigned char samples = 16;
    register unsigned long long tmp = 0;
    register float rms = 0.0;          
                      
    while(samples > 0)
    {
        read_adc(adc_start_only);
        while(!adc_done());
        rms = read_adc(adc_read_only);  
        tmp += (rms * rms);      
        samples--;      
    }                     
    tmp >>= 4;                           
    rms = (sqrt(tmp));     
    rms *= 0.004875; 
    
    if(rms <= 0)
    {
        rms = 0.004875;
    }
    
    return rms;                    
}

The RMS voltage value from the sensor is then put to the derived formula discussed earlier. However, a microcontroller is not your ordinary calculator and it will behave erratically rather than showing an error symbol as in your calculator when it is forced to do a wrong calculation like dividing a value by zero. To avoid such incidents, the readings are checked for upper and lower hardware limits and confined if necessary, before processing and graphical representation.  

Further data processing is done to determine the maximum, minimum and average SPL values.

void read_SPL() 
 {
    dB_current = adc_rms();
    db_current = (ref_SPL + 20 * log10(db_current / sensitivity)); 
 if(db_current <= 40)    {        dB_current = 40;    }    if(dB_current >= 99)
    {
        dB_current = 99;
    }
 if(x > 125) 
    {
       db_max = 0.0;
       db_min = 100.0;    
       x = 17;            
    }
 if(dB_current > dB_max)      
    {     
       db_max = dB_current;  
    }              
 if(dB_current < dB_min)      
    {                    
       db_min = dB_current;
    }                   
 dB_avg = ((db_max + dB_min) * 0.5);   
 } 

Now with the data processed, the data is ready for graphical presentation. The GLCD used here had a resolution of 192 x 64 pixels. It had three regions represented by three chip select (CS) pins. The first two regions were used for graphics while the third or the last region was used for text data.

Every graphical presentation has two components – one is the static background part and the other is the dynamic foreground part. In this code, the static part is the dB scale and the enclosure where the SPL bars graph is to be shown. This part as shown below is loaded only once right after initialization. The dynamic part changes with SPL values in the form of thin vertical bar graphs.  

void display_redings() 
{                                                          
    glcd_text57(130, 20, txt_dB_current, 1, OFF);  
    sprintf(txt_dB_current, "Cr:%2.1g dB", db_current);    
    glcd_text57(130, 20 , txt_dB_current, 1, ON);     
                                          
    glcd_text57(130, 30, txt_dB_max, 1, OFF);         
    sprintf(txt_dB_max, "Mx:%2.1g dB", dB_max);
    glcd_text57(130, 30 , txt_dB_max, 1, ON);     
    
    glcd_text57(130, 40, txt_dB_min, 1, OFF);         
    sprintf(txt_dB_min, "Mn:%2.1g dB", dB_min);
    glcd_text57(130, 40 , txt_dB_min, 1, ON); 
                      
    glcd_text57(130, 50, txt_dB_avg, 1, OFF);         
    sprintf(txt_dB_avg, "Av:%2.1g dB", dB_avg);
    glcd_text57(130, 50, txt_dB_avg, 1, ON); 
}                                
                                                                             
void plot_data()                                
{                                    
   unsigned char l = 0;
                           
   l = map(dB_current, 40, 99, 61, 2); 
   
   glcd_line(x, 2, x, 61, YES);   
   glcd_line(x, l, x, 61, NO); 
   
   x += 2;
}     

                                  
float map(float value, float x_min, float x_max, float y_min, float y_max)   
{                         
    return (y_min + (((y_max - y_min) / (x_max - x_min)) * (value - x_min)));
}      

As shown above the first function is responsible for displaying text data. The second function is responsible for plotting the bar graph. The region where a bar is to be plotted is cleared before plotting. This allows us not to fully refresh the screen. The map function is a straight-line equation solver and it comes useful in quickly translating from one range to another. For instance, in this case, the map function translates dB readings from 40 – 99 dB to 61 – 2 Y-coordinate position of the GLCD. Over 100 bars (X-coordinate points) together show the dB trend plot.

Improvements

A number of improvements can be made to the project. Some of these include:

• Using a more sensitive and professional microphone.
• Using a larger GLCD/TFT display.
• Using a faster chip for faster data processing.
• Adding a computer or mobile-phone application.
• Adding features like FFT data processing, spectrum display, etc.
• Adding a temperature and pressure sensor to take care of changes in medium with temperature and air pressure variations.

Demo

Resources related to this project can be downloaded from here.

Author: Shawon M. Shahryiar

https://www.youtube.com/user/sshahryiar

https://www.facebook.com/MicroArena                                                               

26.05.2015

STC 8051s vs Other 8051s

STC 8051s, as stated, offers additional hardware peripherals when compared to standard 8051s. There are some STC microcontrollers like STC89C52RC that are same as the standard ones while some others like STC8A8K64S4A12 are more robust with many advanced features. Some key differences between standard 8051s and STC micros are discussed below:

• Packages / Sizes
  STC offers microcontrollers in various DIP and SMD IC packages. Thus, instead of using a 40-pin DIP package microcontroller to solve a problem that can be solved with an 8-pin SMD low cost microcontroller, we can avoid using a big microcontroller and thereby save valuable PCB space. Most STC 8051s are, by the way, 100% pin-compatible with other 8051s. This feature makes STC micros easy and viable replacements for devices that use standard 8051s.

• Speed / Operating Frequency
  STC microcontrollers are relatively faster than common 8051s as they can operate at higher clock frequencies. For example, AT89S52 has a maximum operating frequency of 33MHz while STC89C52RC can be clocked with an 80MHz source.

• Additional Hardware Peripherals
  Some STC microcontrollers have in-built ADC, EEPROM, watchdog timer, external interrupt pins and other peripherals. Some are even equipped with higher storage capacities. These are not available in typical 8051s.

• Operating Voltage
  Most 8051 micros need 4.0 – 5.5V DC supply voltage. Some can operate with 3.3V supplies too. Same goes for STC micros. However, there are some STC micros that are designed to operate at yet lower voltage levels. STC offers low power MCUs that operate between 2.0 – 3.6V and general-purpose micros that can operate between 3.6 – 5.5V. The operating voltage ranges and low power consumption figures of STC micros make them well-suited for battery and solar-powered devices.

• Programming Interface
  Most 8051s require a parallel port programmer while some require serial port programmer or separate dedicated programmer hardware. STC micros on the other hand can be programmer with a serial port programmer and so there is no need to buy a dedicated programmer. A simple USB-TTL serial converter can be used to load codes into STC micros.

• Other Minor Differences
  Other areas of differences include added/reduced functionalities/features. In some STC micros, there additional options for GPIOs, timers, etc while in some other devices these extras are not observed. For example, in STC89C52RC, there is 13-bit timer mode for timers 0 and 1 but this feature is absent in STC15L204EA. Likewise in STC15L204EA, there are many ways for setting up GPIOs which are not present in STC89C52RC.

Documentations and Websites

STC microcontrollers are popular in China and Chinese-speaking countries. Owing to this fact, most of the documentation and even the websites are in Chinese. It is hard to get English documentations. Fortunately, we will not be needing anything else other than device datasheets which are luckily available both in Chinese and English.

Unlike other manufacturers who maintain one website dedicated to their products and themselves, STC maintains several websites. Most are in Chinese. This creates lot of confusion about STC. Some common STC websites are listed below:

http://www.stcmicro.com

http://www.stcmcu.com

http://www.stcisp.com

Hardware Tools

From AliExpress, DX, Alibaba and other similar websites/stores, you can buy any STC development board of your choice. Alternatively, you can buy common STC chips and use them with your existing development board or setup a bread-board arrangement.

One such board is shown above. These boards have lot of hardware devices like external 24 series EEPROM, I2C ADC-DAC, communication and display interfaces, etc already embedded and ready for go. Such boards are, thus easy to use and need less wiring. However, boards as such are relatively expensive and big than the one shown below:

This board is designed to bridge a serial interface between a host micro and a nRF24L01 2.4GHz wireless communication module. However, that doesn’t restrict us from using the STC15F(L)204EA micro embedded in it. If you just want to give STC micros a shot with very little investment then this sort of board is all that you can ever expect.

In my tutorials, I’ll be using both kinds of boards but the main focus will be towards STC15L204EA or similar slightly non-standard 8051s since they are not like playing with typical 8051s.

We will also need an USB-serial converter for uploading code.

Apart from these, some regularly used hardware items like LCDs, sensors, wires, etc will be needed. These can easily be found in any starter kit and most are available in any hobbyist’s collection.

Software Tools

Only two software tools will be needed. The first is Keil C51 compiler and second STC ISP tool.

STC ISP tool can be downloaded from here. This is one helluva tool that has many useful features. It a programmer interface, a code generator, serial port monitor, code bank and many other stuffs. It sure does make coding STC micros lot easier than you can possibly imagine.

Keil C51 C compiler will be needed to code STC micros. At present, Keil is the only C compiler that can be used reliably to code STC micros. STC documentations speak of Keil mostly. If you want to use some other compiler like IAR Embedded Workbench, MikroC for 8051, etc other than Keil, your have to add the SFR definitions of your target STC micros and do other stuffs to familiarize it with the STC micro target. Alternatively, you can use models of other similar 8051 model. For example, STC89C52RC is similar to AT89S52. You can use codes for such interchangeably. However, this method won’t work in cases where we have more hardware peripheral than an ordinary 8051 micro. STC15L204EA, for instance, can’t be used like ordinary 8051 or like STC89/90 series micros.

Programming STC Microcontrollers

By default, STC microcontroller database is absent in Keil. It is imperative that this database is added to Keil when using it for STC micros for the very first time. Though this database is not complete in the sense that not chips are enlisted in it, it is still a must or else we will have to use unconventional coding methods by using models of similar microcontrollers of different manufacturers. Personally, I hate unconventional tactics because why use such methods when we can add the database easily. We only have to add this database once.

First run the STC-ISP tool.

After clicking the STC-ISP tool icon, the application starts and the following window appears:

Don’t worry. It is not an error or garbage text window. It appears so if you don’t have Chinese font database installed in your PC and so just click OK to continue. Recent versions of STC-ISP don’t have this issue.

Once the application starts, navigate to Keil ICE Settings tab and locate the highlighted button as shown below:

Now just navigate to Keil installation folder and hit OK as shown below:

Selecting wrong folder will end up with an error and the database won’t be installed.

If the database addition is a success, you’ll get the following message:

Now run Keil C51 compiler.

Go to Project >> New µVision Project… as shown below:

Give your project a folder and a name as shown below:

Select STC Database and appropriate chip or similar part number.

Please note that your target chip may not be in the list. For example, the L-series chips are not enlisted in the database and so they are absent in the list. STC15L204, for example, is not shown in the list. You can use STC15F204EA instead of it as they are similar stuffs. The only difference is their power consumptions. You have to use such tricks when your target chip is not listed. Make sure that the model you selected matches with the target chip or else things may not work properly.

After chip selection, add the startup assembler file to your project.

By default, Keil doesn’t add/create any file and so you’ll see that the project folder has no main source file. We’ll have to create one main source file and add additional files if needed.

Still we are not ready to start coding. This is because we have not yet added SFR definition header file and other custom optional files.

Again, we need to take the help of STC-ISP tool.

In STC-ISP tool, locate the Header File tab and select appropriate MCU series.

Save or copy the file to your desired location.

In Keil, go to target options by right click the folder icon and set target options as shown in the following screenshots:

From this window select clock frequency and memory model.

Select Create HEX File from this window as this file will be uploaded in the target chip.

This section above is highly important because here we have to show the compiler the locations of the header or include files. Check the step numbering carefully.

Lastly disable Warning Number 16. Now, we are good to code.

I made a small Youtube video on all the above discussed processes. If you didn’t understand some part or if you are confused at some point, you can watch the video here.

Now let us discuss about uploading codes to STC micros. The most advantageous part is the fact that we don’t need to invest on a dedicated programmer as with other microcontrollers as a simple USB-serial converter will do the job. However, on first go things may look confusing.

Shown above is the STC-ISP tool’s screenshot with numbers. We have to follow them one-by-one and in incremental order. 1 denotes that we must select the right COM port and part number. You can use Windows Device Manager to find out which COM port is being used for uploading code. Step 2 is to select the target HEX code file. Optionally in step 3, we can set some additional internal MCU parameters. When everything has been set properly, we can hit the Download Program button shown in step 4. If the target microcontroller or board is already powered then the code won’t be uploaded. This is the confusing part because it should have been the other way.

Notice the red arrow in the schematic below. The code is not uploaded by holding and releasing the reset button for some time or by pulling high or low some special pin or by some other means. We need to create a handshake between the PC and the target MCU and this is done when the MCU is powered off and then powered on, i.e. when the micro is powered up.

This is why the red arrow highlights the power switch in the schematic. Though the schematic shows a MAX232-based converter, we can use a USB-serial converter instead.

All of these steps are demoed in this video. Note that no external USB-serial converter/cable can be seen in the video as it is embedded in the board. The following schematic and photo will make this fact clearer. This is why most STC development boards come with such arrangement and without any programmer.

The continuation of this post can be found here.

Communication Peripheral Overview

N76E003 packs basic serial communication peripherals for I2C, SPI and UART. These interfaces enable us to interface external EEPROM and flash memories, real-time clocks (RTC), sensors, etc.

N76E003 has two hardware UARTs, one SPI and one I2C peripheral. The UART interfaces can be further expanded to implement RS-485 and RS-422 communication protocols. With ordinary GPIOs and optionally with hardware timers we can implement software-based UART, SPI and I2C too. However, software methods are slow and resource-hungry. Software-based approach is, on the other hand, needed when we have to interface devices that don’t use any of these communication topologies. For example, the one-wire protocol used by DHT series relative humidity and temperature sensors needs to be implemented by using an ordinary GPIO pin. Same goes for typical text and graphical LCDs.

Note that there is a conflict between UART1 and alternative I2C pins. There are also similar conflicts with other hardware peripherals like PWMs, ADCs, etc since N76E003 packs lots of stuff in such a small form-factor. Every single GPIO pin is precious. Try to keep things with default GPIO pins in order to reduce conflicts with other hardware peripherals, coding and to maximize effective use of GPIOs. Likewise bear in mind that timers have also such conflicts as they are used to implement both hardware-based delays and the UART peripherals. You have to know for sure what you are doing, what do you want and with which stuffs you wish to accomplish your task.

Serial Communication – UART

To date serial communication (UART) is perhaps the simplest and widely used form of communication in use. UART block is only block available in most microcontrollers that can be easily interfaced with a computer or a phone. Most communication modules like Bluetooth, Wi-Fi, GSM modems, GPS modules, etc are interfaced using UART. It has incredible range and is also the backbone of other communication methods like RS-485, RS-422, etc.

To learn more about UART visit the following link:

https://learn.mikroe.com/uart-serial-communication

Code

HMC1022.h

#define Get_Angular_Measurement                      0x31

#define Start_Calibration                            0xC0 

#define End_Calibration                              0xC1                     

#define Set_Magnetic_Declination_High_Byte           0x03  

#define Set_Magnetic_Declination_Low_Byte            0x04

#define no_of_data_bytes_returned                    0x08

#define calibration_LED                              P15

void read_heading(void);

void calibrate_compass(void); 

void factory_reset(void);

void set_declination_angle(unsigned long angle);

HMC1022.c

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

#include "soft_delay.h"

#include "HMC1022.h"

unsigned char done = 0;

unsigned char data_bytes[no_of_data_bytes_returned] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

void read_heading(void)

{                        

     unsigned char s = 0; 

     unsigned long CRC = 0;

     Send_Data_To_UART1(Get_Angular_Measurement); 

     for(s = 0; s < no_of_data_bytes_returned; s++)

     {               

        data_bytes[s] = Receive_Data_From_UART1();

        if(s < (no_of_data_bytes_returned - 1))  

        {

            CRC += data_bytes[s];

        }

     }                                                      

     CRC = (CRC & 0xFF);

     if(CRC == data_bytes[7])

     {                                    

       done = 1;

     }    

}

void calibrate_compass(void)

{

 unsigned char s = 0x00;    

 Send_Data_To_UART1(Start_Calibration);

 for(s = 0; s < 60; s++)

 {

     calibration_LED = 1;       

     delay_ms(100);

     calibration_LED = 0;

     delay_ms(900);

 } 

 for(s = 0; s < 60; s++)   

 {

     calibration_LED = 1;   

     delay_ms(400);            

     calibration_LED = 0;

     delay_ms(600);

 }             

 Send_Data_To_UART1(End_Calibration);

}

void factory_reset(void)

{

 Send_Data_To_UART1(0xA0);

 Send_Data_To_UART1(0xAA);

 Send_Data_To_UART1(0xA5); 

 Send_Data_To_UART1(0xC5);

}     

void set_declination_angle(unsigned long angle)

{

 unsigned long hb = 0;

 unsigned char lb = 0;

 lb = (angle & 0x00FF);   

 hb = (angle & 0xFF00);

 hb >>= 8; 

 Send_Data_To_UART1(Set_Magnetic_Declination_High_Byte);    

 Send_Data_To_UART1(hb);

 Send_Data_To_UART1(Set_Magnetic_Declination_Low_Byte);

 Send_Data_To_UART1(lb);

}

main.c

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

#include "soft_delay.h"

#include "LCD_2_Wire.h"

#include "HMC1022.h"

const unsigned char symbol[8] =

{

   0x00, 0x06, 0x09, 0x09, 0x06, 0x00, 0x00, 0x00

};

extern unsigned char done;

extern unsigned char data_bytes[no_of_data_bytes_returned];

void setup(void);

void lcd_symbol(void);

void main(void)

{

  setup();

  while(1)

  {

    read_heading();

    if(done)

     {

       LCD_goto(6, 1);

       LCD_putchar(data_bytes[2]);

       LCD_goto(7, 1);

       LCD_putchar(data_bytes[3]);

       LCD_goto(8, 1);

       LCD_putchar(data_bytes[4]);

       LCD_goto(9, 1);

       LCD_putchar('.');

       LCD_goto(10, 1);

       LCD_putchar(data_bytes[6]);

       done = 0;

     }

     P15 = ~P15;

     delay_ms(200);

  };

}

void setup(void)

{

  P15_PushPull_Mode;

  LCD_init();

  LCD_clear_home();

  lcd_symbol();

  LCD_goto(3, 0);

  LCD_putstr("Heading  N");

  LCD_goto(11, 0);

  LCD_send(0, DAT);

  InitialUART1_Timer3(9600);

}

void lcd_symbol(void) 

{

  unsigned char s = 0; 

  LCD_send(0x40, CMD);

  for(s = 0; s < 8; s++)

  {

   LCD_send(symbol[s], DAT);

  }

  LCD_send(0x80, CMD);

}

Schematic

Explanation

The following are the commands that HMC1022 acknowledges when sent via UART:

HMC1022 gives heading data when it is requested. The highlighted command is that command.

Once requested it sends out a string of characters that carry heading information. The followings are the response package and its details:

From the above info, it is clear that HMC1022 will return 8 bytes when requested for heading. Out of these we need bytes 2, 3,4 and 6. The rest can be ignored for simplicity.

Data from HM1022 is received by the following function:

void read_heading(void)

{                        

     unsigned char s = 0; 

     unsigned long CRC = 0;

     Send_Data_To_UART1(Get_Angular_Measurement); 

     for(s = 0; s < no_of_data_bytes_returned; s++)

     {               

        data_bytes[s] = Receive_Data_From_UART1();

        if(s < (no_of_data_bytes_returned - 1))  

        {

            CRC += data_bytes[s];

        }

     }                                                      

     CRC = (CRC & 0xFF);

     if(CRC == data_bytes[7])

     {                                    

       done = 1;

     }    

}

Note that the function Send_Data_To_UART1 and Receive_Data_From_UART1 are BSP functions. Likewise, InitialUART1_Timer3(9600) function is also a BSP function that initiates UART1 with Timer 3. As with ADC, BSP functions for UART are enough for basic setup. Try to use Timer 3 as it remains mostly free. If you need more control over the UART, you can manually configure the registers.

In the main, the received bytes containing heading info are displayed.

Demo

UART Interrupt

UART, as we saw in the last example, can be used in polling mode but it is wise to use it in interrupt mode. This feature becomes especially important and therefore, a must-have requirement when it come to that fact that the host micro may not always know when to receive data. Unlike SPI/I2C, UART doesn’t always follow known data transactions. Take the example of a GSM modem. We and so does our tiny host N76E003 micro don’t know for sure when a message would arrive. Thus, when an interrupt due to reception is triggered, it is known to mark the beginning of data reception process. The host micro can relax idle until data is received fully.

Here, we will see how to use UART interrupt to read a LV-Max EZ0 SONAR module.

Code

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "soft_delay.h"

#include "LCD_2_Wire.h"

unsigned char received = 0;

unsigned char count = 0;

unsigned char buffer[5] = {0x00, 0x00, 0x00, 0x00, 0x00};

void setup(void);

void UART0_ISR(void)    

interrupt 4 

{

    if(RI == 1)

    {                                                               

        buffer[count] = SBUF;

        count++;

        if(count >= 4)

        {

            clr_ES;

            received = 1;

        }

        clr_RI;

    }

    P15 = ~P15;

}

void main(void)

{

    unsigned char i = 0;

    setup();

    while(1)

    {

        Send_Data_To_UART0('S');

        delay_ms(40);

        set_ES;     

        if(received)

        {

            for(i = 1; i < 4; i++)

            {

              LCD_goto((12 + i), 1);

              LCD_putchar(buffer[i]);

            }

            count = 0;

            received  = 0;

            set_ES;

        }

        delay_ms(40);

    }

}

void setup(void)

{

    P15_PushPull_Mode;

    LCD_init();

    LCD_clear_home();

    LCD_goto(1, 0);

    LCD_putstr("UART Interrupt");

    LCD_goto(0, 1);

    LCD_putstr("Range/Inch:");

    InitialUART0_Timer3(9600);

    set_EA;

}

Schematic

*Note the LV-Max EZ0 SONAR sensor is not directly connected with the N76E003 as shown in the schematic but rather it is connected via a 74HC04 hex inverter. Two of these inverters are used – one for the TX side and the other for the RX side.

Explanation

This time UART0 is used and is setup using BSP built-in function. The only exception is the interrupt part. The global interrupt is enabled but not the UART interrupt.

InitialUART0_Timer3(9600);

set_EA;

The UART interrupt is only enabled after commanding the SONAR sensor:

Send_Data_To_UART0('S');

delay_ms(40);

set_ES;  

This is done to avoid unnecessary reads.

The sensor is read inside the interrupt routine. The sensor outputs data as Rxxx<CR>. So, there are 5 bytes to read. The “R” in the readout works as a preamble or sync byte. The “xxx” part contains range info in inches. Finally, <CR> is a carriage return character. Therefore, every time a character is received an interrupt is triggered and the character is saved in an array. When all 5 bytes have been received, the display is updated. On exiting the interrupt, the interrupt flag is cleared. P15 is also toggled to visually indicate that an UART interrupt has been triggered.

void UART0_ISR(void)    

interrupt 4 

{

  if(RI == 1)

  {                                                               

     buffer[count] = SBUF;

     count++;

     if(count >= 4)

     {

       clr_ES;

       received = 1;

     }

     clr_RI;

  }

  P15 = ~P15;

}

Demo

Inter-Integrated Circuit (I2C) – Interfacing DS1307 I2C RTC

Developed by Philips nearly three decades ago, I2C communication (Inter-Integrated Circuit) is widely used in a number of devices and is comparatively easier than SPI. For I2C communication only two wires – serial data (SDA) and serial clock (SCK) are needed and these two wires form a bus in which we can connect up to 127 devices.

Everything you need to know about I2C can be found in these pages:

• https://learn.mikroe.com/i2c-everything-need-know
• https://learn.sparkfun.com/tutorials/i2c
• http://www.ti.com/lsds/ti/interface/i2c-overview.page
• http://www.robot-electronics.co.uk/i2c-tutorial
• https://www.i2c-bus.org/i2c-bus
• http://i2c.info

Apart from these N76E003’s datasheet explains I2C communication in high detail.

Code

I2C.h

#define regular_I2C_pins              0

#define alternate_I2C_pins            1

#define regular_I2C_GPIOs()           do{P13_OpenDrain_Mode; P14_OpenDrain_Mode; clr_I2CPX;}while(0)

#define alternative_I2C_GPIOs()       do{P02_OpenDrain_Mode; P16_OpenDrain_Mode; set_I2CPX;}while(0)

#define I2C_GPIO_Init(mode)           do{if(mode != 0){alternative_I2C_GPIOs();}else{regular_I2C_GPIOs();}}while(0)

#define I2C_CLOCK                     0x27 //Fclk = Fsys / (4*(prescalar + 1))

#define I2C_ACK                       0

#define I2C_NACK                      1

#define timeout_count                 1000

void I2C_init(void);

void I2C_start(void);

void I2C_stop(void);

unsigned char I2C_read(unsigned char ack_mode);

void I2C_write(unsigned char value);

I2C.c

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

#include "I2C.h"

void I2C_init(void)

{

    I2C_GPIO_Init(regular_I2C_pins);

    I2CLK = I2C_CLOCK;

    set_I2CEN;

}

void I2C_start(void)

{

    signed int t = timeout_count;

    set_STA;                               

    clr_SI;

    while((SI == 0) && (t > 0))

    {

       t--;

    };    

}

void I2C_stop(void)

{

    signed int t = timeout_count;

    clr_SI;

    set_STO;

    while((STO == 1) && (t > 0))

    {

        t--;

    };    

}

unsigned char I2C_read(unsigned char ack_mode)

{

    signed int t = timeout_count;

    unsigned char value = 0x00;

    set_AA;                            

    clr_SI;

    while((SI == 0) && (t > 0))

    {

        t--;

    };      

    value = I2DAT;

    if(ack_mode == I2C_NACK)

    {

        t = timeout_count;

        clr_AA;  

        clr_SI;

        while((SI == 0) && (t > 0))

        {

            t--;

        };          

    }

    return value;

}

void I2C_write(unsigned char value)

{

    signed int t = timeout_count;

    I2DAT = value;

    clr_STA;          

    clr_SI;

    while((SI == 0) && (t > 0))

    {

        t--;

    }; 

}

DS1307.h

#define I2C_W                            0

#define I2C_R                            1

#define sec_reg                          0x00

#define min_reg                          0x01

#define hr_reg                           0x02

#define day_reg                          0x03

#define date_reg                         0x04

#define month_reg                        0x05

#define year_reg                         0x06

#define control_reg                      0x07

#define DS1307_addr                      0xD0

#define DS1307_WR                        (DS1307_addr + I2C_W)

#define DS1307_RD                        (DS1307_addr + I2C_R)

void DS1307_init(void);

unsigned char DS1307_read(unsigned char address);

void DS1307_write(unsigned char address, unsigned char value);

unsigned char bcd_to_decimal(unsigned char value);

unsigned char decimal_to_bcd(unsigned char value);

void get_time(void);

void set_time(void);

DS1307.c

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

#include "DS1307.h"

#include "I2C.h"

struct

{

   unsigned char s;

   unsigned char m;

   unsigned char h;

   unsigned char dy;

   unsigned char dt;

   unsigned char mt;

   unsigned char yr;

}time;

void DS1307_init(void)

{

    I2C_init();

  DS1307_write(control_reg, 0x00);

}

unsigned char DS1307_read(unsigned char address)

{

    unsigned char value = 0x00;

    I2C_start();

    I2C_write(DS1307_WR);

    I2C_write(address);

    I2C_start();

    I2C_write(DS1307_RD);

    value = I2C_read(I2C_NACK);

    I2C_stop();

    return value;

}

void DS1307_write(unsigned char address, unsigned char value)

{

    I2C_start();

    I2C_write(DS1307_WR);

    I2C_write(address);

    I2C_write(value);

    I2C_stop();

}

unsigned char bcd_to_decimal(unsigned char value)

{

    return ((value & 0x0F) + (((value & 0xF0) >> 0x04) * 0x0A));

}

unsigned char decimal_to_bcd(unsigned char value)

{

    return (((value / 0x0A) << 0x04) & 0xF0) | ((value % 0x0A) & 0x0F);

}

void get_time(void)

{

    time.s = DS1307_read(sec_reg);

    time.s = bcd_to_decimal(time.s);

    time.m = DS1307_read(min_reg);

    time.m = bcd_to_decimal(time.m);

    time.h = DS1307_read(hr_reg);

    time.h = bcd_to_decimal(time.h);

    time.dy = DS1307_read(day_reg);

    time.dy = bcd_to_decimal(time.dy);

    time.dt = DS1307_read(date_reg);

    time.dt = bcd_to_decimal(time.dt);

    time.mt = DS1307_read(month_reg);

    time.mt = bcd_to_decimal(time.mt);

    time.yr = DS1307_read(year_reg);

    time.yr = bcd_to_decimal(time.yr);

}

void set_time(void)

{

    time.s = decimal_to_bcd(time.s);

    DS1307_write(sec_reg, time.s);

    time.m = decimal_to_bcd(time.m);

    DS1307_write(min_reg, time.m);

    time.h = decimal_to_bcd(time.h);

    DS1307_write(hr_reg, time.h);

    time.dy = decimal_to_bcd(time.dy);

    DS1307_write(day_reg, time.dy);

    time.dt = decimal_to_bcd(time.dt);

    DS1307_write(date_reg, time.dt);

    time.mt = decimal_to_bcd(time.mt);

    DS1307_write(month_reg, time.mt);

    time.yr = decimal_to_bcd(time.yr);

    DS1307_write(year_reg, time.yr);

}

main.c

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

#include "soft_delay.h"

#include "LCD_3_Wire.h"

#include "I2C.h"

#include "DS1307.h"

extern struct

{

   unsigned char s;

   unsigned char m;

   unsigned char h;

   unsigned char dy;

   unsigned char dt;

   unsigned char mt;

   unsigned char yr;

}time;

void show_value(unsigned char x_pos, unsigned char y_pos, unsigned char value);

void display_time(void);

void main(void)

{

    time.s = 30;

    time.m = 58;

    time.h = 23;

    P15_PushPull_Mode;

    LCD_init();

    LCD_clear_home();

    LCD_goto(0, 0);

    LCD_putstr("N76E003 I2C RTCC");

    DS1307_init();

    set_time();

    while(1)

    {

        get_time();

        display_time();

    };

}

void show_value(unsigned char x_pos, unsigned char y_pos, unsigned char value)

{

    unsigned char chr = 0;

    chr = ((value / 10) + 0x30);

    LCD_goto(x_pos, y_pos);

    LCD_putchar(chr);

    chr = ((value % 10) + 0x30);

    LCD_goto((x_pos + 1), y_pos);

    LCD_putchar(chr);

}

void display_time(void)

{

    P15 ^= 1;

    LCD_goto(6, 1);

    LCD_putchar(' ');

    LCD_goto(9, 1);

    LCD_putchar(' ');

    delay_ms(400);

    show_value(4, 1, time.h);

    show_value(7, 1, time.m);

    show_value(10, 1, time.s);

    LCD_goto(6, 1);

    LCD_putchar(':');

    LCD_goto(9, 1);

    LCD_putchar(':');

    delay_ms(400);

}

Schematic

*Note that the pin naming of the chip in the schematic above is wrong. P13 and P14 are both SDA pins according to this naming when actually P13 is SCL and P14 is SDA pin. 

Explanation

I have coded two files for I2C easy and quick I2C implementation. These are I2C header and source file. These files describe I2C hardware functionality as well as provide higher level functions under the hood of which I2C hardware is manipulated. I have only coded these files for master mode only since barely we would ever need N76E003 slaves. I also didn’t implement interrupt-based I2C functionalities as this, in my experience, is also not needed in most of the cases.

void I2C_init(void);

void I2C_start(void);

void I2C_stop(void);

unsigned char I2C_read(unsigned char ack_mode);

void I2C_write(unsigned char value);

Using hardware I2C requires us to manipulate the following registers apart from clock and GPIO settings.

I2C GPIOs must be set as open-drain GPIOs as per I2C standard. I2C clock must be set according to the devices connected in the bus. Typically, I2C clock speed ranges from 20 – 400kHz. This clock speed is dependent on system clock speed Fsys. Therefore, before setting I2C clock speed you have to set/know Fsys. I2C clock is decided by the value of I2CLK register. It is basically a prescalar value in master mode.

So, if Fsys = 16MHz and I2CLK = 39 (0x27), the I2C bus clock rate is 100kHz.

Note that only in master I2C clock can be setup. In slave mode, the slave(s) synchronizes automatically with bus clock.

I2CON register is they key register for using I2C. It contains all the flags and condition-makers.

For instance, consider the I2C start condition. In order to make a start condition, we have to set the STA bit and clear I2C interrupt flag, SI. Since I used polling mode, SI is polled until it is cleared. This ensures that a start condition has been successfully made. I have also added a software-based timeout feature should there be an issue with the I2C bus. In N76E003, there is a hardware-based approach for timeout too. Note that I didn’t care about the I2C status register states as again this is rarely needed. If you want more grip on the I2C you can follow the BSP examples.

void I2C_start(void)

{

    signed int t = timeout_count;

    set_STA;                               

    clr_SI;

    while((SI == 0) && (t > 0))

    {

       t--;

    };    

}

Finally, the last register that we will need is the I2C data register (I2DAT). It is through it we send and receive data from I2C bus.

The demo I have shown here is that of a DS1307 I2C-based real time clock. Perhaps this is the simplest device for learning about and understanding I2C.

Demo

Serial Peripheral Interface (SPI) – Interfacing MAX7219 and MAX6675

SPI just like I2C is another highly popular form of onboard serial communication. Compared to I2C it is fast and robust. However, it requires more GPIO pins than other communication forms. These make it ideal communication interface for TFT displays, OLED displays, flash memories, DACs, etc.

SPI is best realized as a shift register that shifts data in and out with clock pulses. In a SPI bus, there is always one master device which generates clock and selects slave(s). Master sends commands to slave(s). Slave(s) responds to commands sent by the master. The number of slaves in a SPI bus is virtually unlimited. Except the chip selection pin, all SPI devices in a bus can share the same clock and data pins.

In general, if you wish to know more about SPI bus here are some cool links:

• • https://learn.mikroe.com/spi-bus

• • https://learn.sparkfun.com/tutorials/serial-peripheral-interface-spi

• • http://ww1.microchip.com/downloads/en/devicedoc/spi.pdf

• • http://tronixstuff.com/2011/05/13/tutorial-arduino-and-the-spi-bus

• • https://embeddedmicro.com/tutorials/mojo/serial-peripheral-interface-spi

• http://www.circuitbasics.com/basics-of-the-spi-communication-protocol

Code

MAX72xx.h

#define MAX72xx_SPI_GPIO_init()                             do{P00_PushPull_Mode; P10_PushPull_Mode; P11_PushPull_Mode;}while(0)

#define MAX72xx_CS_OUT_HIGH()                               set_P11

#define MAX72xx_CS_OUT_LOW()                                clr_P11

#define NOP                                                 0x00

#define DIG0                                                0x01

#define DIG1                                                0x02

#define DIG2                                                0x03

#define DIG3                                                0x04

#define DIG4                                                0x05

#define DIG5                                                0x06

#define DIG6                                                0x07

#define DIG7                                                0x08

#define decode_mode_reg                                     0x09

#define intensity_reg                                       0x0A

#define scan_limit_reg                                      0x0B

#define shutdown_reg                                        0x0C

#define display_test_reg                                    0x0F

#define shutdown_cmd                                        0x00

#define run_cmd                                             0x01

#define no_test_cmd                                         0x00

#define test_cmd                                            0x01

#define digit_0_only                                        0x00

#define digit_0_to_1                                        0x01

#define digit_0_to_2                                        0x02

#define digit_0_to_3                                        0x03

#define digit_0_to_4                                        0x04

#define digit_0_to_5                                        0x05

#define digit_0_to_6                                        0x06

#define digit_0_to_7                                        0x07

#define No_decode_for_all                                   0x00

#define Code_B_decode_digit_0                               0x01

#define Code_B_decode_digit_0_to_3                         0x0F    

#define Code_B_decode_for_all                               0xFF

void MAX72xx_SPI_HW_Init(unsigned char clk_value);

void MAX72xx_init(void);

void MAX72xx_write(unsigned char address, unsigned char value);

MAX72xx.c

#include "N76E003_IAR.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

#include "MAX72xx.h"

void MAX72xx_SPI_HW_Init(unsigned char clk_value)

{

  switch(clk_value)

  {

    case 1:

    {

      clr_SPR1;

      set_SPR0;

      break;

    }

    case 2:

    {

      set_SPR1;

      clr_SPR0;

      break;

    }

    case 3:

    {

      set_SPR1;

      set_SPR0;

      break;

    }

    default:

    {

      clr_SPR1;

      clr_SPR0;

      break;

    }

  }   

  set_DISMODF;

  set_MSTR;

  clr_CPOL;

  clr_CPHA;

  set_SPIEN;

}

void MAX72xx_init(void)

{

  MAX72xx_SPI_GPIO_init();

  MAX72xx_SPI_HW_Init(0);

  MAX72xx_write(shutdown_reg, run_cmd);

  MAX72xx_write(decode_mode_reg, Code_B_decode_digit_0_to_3);

  MAX72xx_write(scan_limit_reg, digit_0_to_3);

  MAX72xx_write(intensity_reg, 0x19);

}

void MAX72xx_write(unsigned char address, unsigned char value)

{

  MAX72xx_CS_OUT_LOW(); 

  SPDR = address;

  while(!(SPSR & SET_BIT7)); 

  clr_SPIF;

  SPDR = value;

  while(!(SPSR & SET_BIT7)); 

  clr_SPIF;

  MAX72xx_CS_OUT_HIGH();

}

MAX6675.h

#define MAX6675_SPI_GPIO_init()     do{P01_Input_Mode; P10_PushPull_Mode; P12_PushPull_Mode;}while(0)

#define MAX6675_CS_OUT_HIGH()       set_P12

#define MAX6675_CS_OUT_LOW()        clr_P12

#define T_min                       0

#define T_max                       1024

#define count_max                   4096

#define no_of_pulses                16

#define deg_C                       0

#define deg_F                       1

#define tmp_K                       2

#define open_contact                0x04

#define close_contact               0x00

#define scalar_deg_C                0.25

#define scalar_deg_F_1              1.8

#define scalar_deg_F_2              32.0

#define scalar_tmp_K                273.0

#define no_of_samples               16

void MAX6675_SPI_HW_Init(unsigned char clk_value);

void MAX6675_init(void);

unsigned char MAX6675_get_ADC(unsigned int *ADC_data);

float MAX6675_get_T(unsigned int ADC_value, unsigned char T_unit);

MAX6675.c

#include "N76E003_IAR.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

#include "MAX6675.h"

void MAX6675_SPI_HW_Init(unsigned char clk_value)

{

  switch(clk_value)

  {

    case 1:

    {

      clr_SPR1;

      set_SPR0;

      break;

    }

    case 2:

    {

      set_SPR1;

      clr_SPR0;

      break;

    }

    case 3:

    {

      set_SPR1;

      set_SPR0;

      break;

    }

    default:

    {

      clr_SPR1;

      clr_SPR0;

      break;

    }

  }   

  set_DISMODF;

  set_MSTR;

  clr_CPOL;

  set_CPHA;

  set_SPIEN;

}

void MAX6675_init(void)

{

    MAX6675_SPI_GPIO_init();

    MAX6675_SPI_HW_Init(0);

}

unsigned char MAX6675_get_ADC(unsigned int *ADC_data)

{

    unsigned char lb = 0;

    unsigned char hb = 0;

    unsigned char samples = no_of_samples;

    unsigned int temp_data = 0;

    unsigned long avg_value = 0;

    while(samples > 0)

    {

         MAX6675_CS_OUT_LOW();

         SPDR = 0x00;

         while(!(SPSR & SET_BIT7)); 

         hb = SPDR;

         clr_SPIF; 

         SPDR = 0x00;

         while(!(SPSR & SET_BIT7));         

         lb = SPDR;

         clr_SPIF;   

         MAX6675_CS_OUT_HIGH();

         temp_data = hb;

         temp_data <<= 8;

         temp_data |= lb;

         temp_data &= 0x7FFF;

         avg_value += (unsigned long)temp_data;

         samples--;

         Timer0_Delay1ms(10);

    };

    temp_data = (avg_value >> 4);

    if((temp_data & 0x04) == close_contact)

    {

        *ADC_data = (temp_data >> 3);

        return close_contact;

    }

    else

    {

        *ADC_data = (count_max + 1);

        return open_contact;

    }

}

float MAX6675_get_T(unsigned int ADC_value, unsigned char T_unit)

{

    float tmp = 0.0;

    tmp = (((float)ADC_value) * scalar_deg_C);

    switch(T_unit)

    {

        case deg_F:

        {

             tmp *= scalar_deg_F_1;

             tmp += scalar_deg_F_2;

             break;

        }

        case tmp_K:

        {

            tmp += scalar_tmp_K;

            break;

        }

        default:

        {

            break;

        }

    }

    return tmp;

}

main.c

#include "N76E003_IAR.h"

#include "Common.h"

#include "Delay.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "soft_delay.h"

#include "MAX72xx.h"

#include "MAX6675.h"

void main(void)

{

  unsigned int ti = 0;

  unsigned int t = 0;

  P15_PushPull_Mode;

  MAX6675_init();

  MAX72xx_init(); 

  while(1)

  {

      P15 = 1;

      clr_CPOL;

      set_CPHA;

      MAX6675_get_ADC(&ti);

      t = ((unsigned int)MAX6675_get_T(ti, tmp_K));

      delay_ms(100);

      P15 = 0;

      clr_CPOL;

      clr_CPHA;

      MAX72xx_write(DIG3, ((t / 1000) % 10));

      MAX72xx_write(DIG2, ((t / 100) % 10));

      MAX72xx_write(DIG1, ((t / 10) % 10));

      MAX72xx_write(DIG0, (t % 10));

      delay_ms(100);

  };

}

Schematic

Explanation

With SPI we have to deal with two things – first, the initialization and second, the data transfer process. Configuring SPI needs a few things to be set up. These are:

• SPI communication bus speed or simply clock speed
• Clock polarity
• Clock phase
• Orientation of data, i.e. MSB first or LSB first
• Master/slave status
• Optionally hardware slave selection pin use

Most of these can be done by manipulating the following registers:

SPCR configures the hardware SPI peripheral of N76E003 while SPDR is used for transferring data.

To aid in all these I have coded the following functions. Though I didn’t use these code snippets in the actual demo code for demonstration purposes, these will most certainly work and reduce coding effort.

void SPI_init(unsigned char clk_speed, unsigned char mode)

{

  set_SPI_clock_rate(clk_speed);

  set_SPI_mode(mode);

  set_DISMODF;

  set_MSTR;

  set_SPIEN;

}

unsigned char SPI_transfer(unsigned char write_value)

{

  signed int t = timeout_count;

  register unsigned char read_value = 0x00;

  SPDR = write_value;

  while((!(SPSR & SET_BIT7)) && (t > 0))

  {

    t--;

  };        

  read_value = SPDR;

  clr_SPIF;   

  return read_value;

}

SPI_init function sets up the SPI peripheral using two information – the bus clock speed and SPI data transfer mode. It initializes the SPI hardware as a SPI master device and without hardware salve selection pin. This configuration is mostly used in common interfacings. Only mode and clock speed are the variables. In the demo, it is visible that MAX7219 and MAX6675 work with different SPI modes. I also didn’t use the hardware slave selection because there are two devices and one slave pin. Certainly, both external devices are not driven at the same time although both share the same bus lines.

SPI_transfer reads and writes on the SPI bus. Here the master writes to the slave first, waits for successful transmission and reads from the slave later. It is best realized by the following figure:

To demo SPI, MAX6675 and MAX7219 were used because one lacked read feature while the other lacked write feature. In the demo, MAX6675 is read to measure the temperature sensed by the K-type thermocouple attached with it and display the measured temperature in Kelvin on MAX7219-based seven segment display arrays.

Demo

One Wire (OW) Communication – Interfacing DHT11

One protocol is not a standard protocol like I2C or SPI. It is just a mere method of communicating with a device that uses just one wire. There are a few devices that uses such principle for communication. DHT series sensors, DS18B20s, digital serial number chips, etc. are a few to mention. As I stated before, since one wire communication doesn’t belong to a dedicated format of communication, there is no dedicated hardware for it. With just a bidirectional GPIO pin we can implement one wire communication. Optionally we can also use a timer for measuring response pulse widths since the method of sending ones and zeroes over one wire requires the measurement of pulse durations. This way of encoding ones and zeros as a function of pulse width is called time-slotting.

Shown above is the timing diagram for DHT11’s time slots. Check the length of pulse high time for one and zero. This is the technique applied in time-slotting mechanism. We have to time pulse lengths in order to identify the logic states.

Code

DHT11.h

#define HIGH                    1

#define LOW                     0

#define DHT11_pin_init()        P05_Quasi_Mode      

#define DHT11_pin_HIGH()        set_P05

#define DHT11_pin_LOW()         clr_P05

#define DHT11_pin_IN()          P05             

void DHT11_init(void);

unsigned char get_byte(void);

unsigned char get_data(void);

DHT11.c

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

#include "soft_delay.h"

#include "DHT11.h"

extern unsigned char values[5];

void DHT11_init(void)

{

   DHT11_pin_init();

   delay_ms(1000);

}

unsigned char get_byte(void)

{

   unsigned char s = 0;

   unsigned char value = 0;

   for(s = 0; s < 8; s++)

   {

      value <<= 1;

      while(DHT11_pin_IN() == LOW);

      delay_us(30);

      if(DHT11_pin_IN() == HIGH)

      {

          value |= 1;

      }

      while(DHT11_pin_IN() == HIGH);

   }

   return value;

}

unsigned char get_data(void)

{

   short chk = 0;

   unsigned char s = 0;

   unsigned char check_sum = 0;

   DHT11_pin_HIGH();

   DHT11_pin_LOW();

   delay_ms(18);

   DHT11_pin_HIGH();

   delay_us(26);

   chk = DHT11_pin_IN();

   if(chk)

   {

      return 1;

   }

   delay_us(80);

   chk = DHT11_pin_IN();

   if(!chk)

   {

      return 2;

   }

   delay_us(80);

   for(s = 0; s <= 4; s += 1)

   {

       values[s] = get_byte();

   }

   DHT11_pin_HIGH();

   for(s = 0; s < 4; s += 1)

   {

       check_sum += values[s];

   }

   if(check_sum != values[4])

   {

      return 3;

   }

   else

   {

      return 0;

   }

}

main.c

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

#include "soft_delay.h"

#include "LCD_2_Wire.h"

#include "DHT11.h"

unsigned char values[5];

const unsigned char symbol[8] =

{

   0x00, 0x06, 0x09, 0x09, 0x06, 0x00, 0x00, 0x00

};

void setup(void);

void lcd_symbol(void);

void lcd_print(unsigned char x_pos, unsigned char y_pos, unsigned char value);

void main(void)

{

  unsigned char state = 0;

  setup();

  while(1)

  {

    state = get_data();

    switch(state)

    {

            case 1:

            {

            }

            case 2:

            {

                 LCD_clear_home();

                 LCD_putstr("No Sensor Found!");

                 break;

            }

            case 3:

            {

                 LCD_clear_home();

                 LCD_putstr("Checksum Error!");

                 break;

            }

            default:

            {

                 LCD_goto(0, 0);

                 LCD_putstr("R.H/ %:       ");

                 lcd_print(14, 0, values[0]);

                 LCD_goto(0, 1);

                 LCD_putstr("Tmp/");

                 LCD_goto(4, 1);

                 LCD_send(0, DAT);

                 LCD_goto(5, 1);

                 LCD_putstr("C:");

                 if((values[2] & 0x80) == 1)

                 {

                     LCD_goto(13, 1);

                     LCD_putstr("-");

                 }

                 else

                 {

                     LCD_goto(13, 1);

                     LCD_putstr(" ");

                 }

                 lcd_print(14, 1, values[2]);

                 break;

            }

    }

    delay_ms(1000);

  };

}

void setup(void)

{

  DHT11_init();

  LCD_init(); 

  LCD_clear_home();

  lcd_symbol();

}

void lcd_symbol(void) 

{

  unsigned char s = 0; 

  LCD_send(0x40, CMD);

  for(s = 0; s < 8; s++)

  {

   LCD_send(symbol[s], DAT);

  }

  LCD_send(0x80, CMD);

}

void lcd_print(unsigned char x_pos, unsigned char y_pos, unsigned char value)

{

 unsigned char chr = 0x00;

 chr = ((value / 10) + 0x30);

 LCD_goto(x_pos, y_pos);

 LCD_putchar(chr);

 chr = ((value % 10) + 0x30);

 LCD_goto((x_pos + 1), y_pos);

 LCD_putchar(chr);

}

Schematic

Explanation

As stated earlier, OW basically needs two things – first, the control of a single GPIO pin and second, the measurement of time. I would like to highlight the most important part of the whole code here:

unsigned char get_byte(void)

{

   unsigned char s = 0;

   unsigned char value = 0;

   for(s = 0; s < 8; s++)

   {

      value <<= 1;

      while(DHT11_pin_IN() == LOW);

      delay_us(30);

      if(DHT11_pin_IN() == HIGH)

      {

          value |= 1;

      }

      while(DHT11_pin_IN() == HIGH);

   }

   return value;

}

From DHT11’s timing diagram, we know that a zero is define by a pulse of 26 – 28μs and a logic one is defined by a pulse of 70μs. It is here in the get_byte function we check the pulse coming from DHT11. The DHT11’s pin is polled as an input and after 30μs if the result of this polling is high then it is considered as a logic one or else it is considered otherwise. Once triggered, DHT11 will provide a 5-byte output. All of the bits in these 5 bytes are checked this way. Though it is not the best method to do so, it is easy and simple.

Demo

One Wire (OW) Communication – Interfacing DS18B20

One wire communication, as stated previously, doesn’t have a defined protocol. Except for the time-slotting mechanism part, there is nothing in common across the devices using this form of communication. We have seen how to interface a DHT11 relative humidity and temperature sensor previously. In this segment, we will see how to interface a DS18B20 one-wire digital temperature sensor with N76E003. DS18B20 follows and uses a completely different set of rules for communication.

Code

one_wire.h

#define DS18B20_GPIO_init()             P06_OpenDrain_Mode

#define DS18B20_IN()                    P06

#define DS18B20_OUT_LOW()               clr_P06

#define DS18B20_OUT_HIGH()              set_P06

#define TRUE                            1

#define FALSE                           0

unsigned char onewire_reset(void);

void onewire_write_bit(unsigned char bit_value);

unsigned char onewire_read_bit(void);

void onewire_write(unsigned char value);   

unsigned char onewire_read(void);

one_wire.c

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

#include "soft_delay.h"

#include "one_wire.h"

unsigned char onewire_reset(void) 

{                                        

     unsigned char res = FALSE;

     DS18B20_GPIO_init();

     DS18B20_OUT_LOW();

     delay_us(480);       

     DS18B20_OUT_HIGH();

     delay_us(60);       

     res = DS18B20_IN();

     delay_us(480);      

     return res;

}

void onewire_write_bit(unsigned char bit_value)

{

    DS18B20_OUT_LOW();

    if(bit_value)

    {       

        delay_us(104);

        DS18B20_OUT_HIGH();  

    }             

}    

unsigned char onewire_read_bit(void)       

{    

    DS18B20_OUT_LOW(); 

    DS18B20_OUT_HIGH(); 

  delay_us(15);

    return(DS18B20_IN());   

}

void onewire_write(unsigned char value)

{                   

     unsigned char s = 0;

     while(s < 8)   

     {                             

          if((value & (1 << s)))

          {

              DS18B20_OUT_LOW();

                nop;

              DS18B20_OUT_HIGH(); 

              delay_us(60);  

          }      

          else

          {

            DS18B20_OUT_LOW();           

              delay_us(60);          

              DS18B20_OUT_HIGH();  

              nop;

          }

          s++;

     }

}                                     

unsigned char onewire_read(void)

{

     unsigned char s = 0x00;

     unsigned char value = 0x00;

     while(s < 8)

     {

          DS18B20_OUT_LOW();

          nop;

          DS18B20_OUT_HIGH(); 

          if(DS18B20_IN()) 

          {                                     

              value |=  (1 << s);                         

          }       

          delay_us(60);

          s++;

     }    

     return value;

}

DS18B20.h

#include "one_wire.h" 

#define convert_T                       0x44

#define read_scratchpad                 0xBE           

#define write_scratchpad                0x4E

#define copy_scratchpad                 0x48  

#define recall_E2                       0xB8

#define read_power_supply               0xB4   

#define skip_ROM                        0xCC

#define resolution                      12

void DS18B20_init(void);

float DS18B20_get_temperature(void); 

DS18B20.c

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

#include "soft_delay.h"

#include "DS18B20.h"

void DS18B20_init(void)                            

{                                      

    onewire_reset();

    delay_ms(100);

}             

float DS18B20_get_temperature(void)

{                                              

    unsigned char msb = 0x00;

    unsigned char lsb = 0x00;

    register float temp = 0.0; 

    onewire_reset();    

    onewire_write(skip_ROM);       

    onewire_write(convert_T);

    switch(resolution)  

    {                                                 

        case 12:

        {                                           

            delay_ms(750);

            break;

        }               

        case 11:                                    

        {             

            delay_ms(375);

            break;

        }          

        case 10:                            

        {                                

            delay_ms(188);  

            break;

        }                                       

        case 9:                                  

        {                                               

            delay_ms(94);                

            break;                           

        }                       

    }                 

    onewire_reset();

    onewire_write(skip_ROM);                

    onewire_write(read_scratchpad);

    lsb = onewire_read();

    msb = onewire_read();

    temp = msb;                          

    temp *= 256.0;

    temp += lsb;

    switch(resolution)  

    {                                 

        case 12:           

        {                                               

            temp *= 0.0625;                

            break;                           

        }       

        case 11:

        {          

            temp *= 0.125;      

            break;

        }               

        case 10:

        {           

            temp *= 0.25;       

            break;

        } 

        case 9:                                

        {                                

            temp *= 0.5;        

            break;     

        }                         

    }  

    delay_ms(40);       

    return (temp);      

}

main.c

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

#include "soft_delay.h"

#include "DS18B20.h"

#include "LCD_3_Wire.h"

const unsigned char symbol[8] =

{

   0x00, 0x06, 0x09, 0x09, 0x06, 0x00, 0x00, 0x00

};

void lcd_symbol(void);

void print_C(unsigned char x_pos, unsigned char y_pos, signed int value);

void print_I(unsigned char x_pos, unsigned char y_pos, signed long value);

void print_D(unsigned char x_pos, unsigned char y_pos, signed int value, unsigned char points);

void print_F(unsigned char x_pos, unsigned char y_pos, float value, unsigned char points);

void main(void)

{

    float t = 0.0;

    DS18B20_init();

    LCD_init();

    lcd_symbol();

    LCD_goto(0, 0);

    LCD_putstr("N76E003 DS18B20");

    LCD_goto(0, 1);

    LCD_putstr("T/ C");

    LCD_goto(2, 1);

    LCD_send(0, DAT);

    while(1)

    {

       t = DS18B20_get_temperature();

       print_F(9, 1, t, 3);

       delay_ms(100);

    };

}

void lcd_symbol(void)

{

    unsigned char s = 0;

   LCD_send(0x40, CMD);

   for(s = 0; s < 8; s++)

   {

        LCD_send(symbol[s], DAT);

   }

   LCD_send(0x80, CMD);

}

void print_C(unsigned char x_pos, unsigned char y_pos, signed int value)

{

     char ch[5] = {0x20, 0x20, 0x20, 0x20, '\0'};

     if(value < 0x00)

     {

        ch[0] = 0x2D;

        value = -value;

     }

     else

     {

        ch[0] = 0x20;

     }

     if((value > 99) && (value <= 999))

     {

         ch[1] = ((value / 100) + 0x30);

         ch[2] = (((value % 100) / 10) + 0x30);

         ch[3] = ((value % 10) + 0x30);

     }

     else if((value > 9) && (value <= 99))

     {

         ch[1] = (((value % 100) / 10) + 0x30);

         ch[2] = ((value % 10) + 0x30);

         ch[3] = 0x20;

     }

     else if((value >= 0) && (value <= 9))

     {

         ch[1] = ((value % 10) + 0x30);

         ch[2] = 0x20;

         ch[3] = 0x20;

     }

     LCD_goto(x_pos, y_pos);

     LCD_putstr(ch);

}

void print_I(unsigned char x_pos, unsigned char y_pos, signed long value)

{

    char ch[7] = {0x20, 0x20, 0x20, 0x20, 0x20, 0x20, '\0'};

    if(value < 0)

    {

        ch[0] = 0x2D;

        value = -value;

    }

    else

    {

        ch[0] = 0x20;

    }

    if(value > 9999)

    {

        ch[1] = ((value / 10000) + 0x30);

        ch[2] = (((value % 10000)/ 1000) + 0x30);

        ch[3] = (((value % 1000) / 100) + 0x30);

        ch[4] = (((value % 100) / 10) + 0x30);

        ch[5] = ((value % 10) + 0x30);

    }

    else if((value > 999) && (value <= 9999))

    {

        ch[1] = (((value % 10000)/ 1000) + 0x30);

        ch[2] = (((value % 1000) / 100) + 0x30);

        ch[3] = (((value % 100) / 10) + 0x30);

        ch[4] = ((value % 10) + 0x30);

        ch[5] = 0x20;

    }

    else if((value > 99) && (value <= 999))

    {

        ch[1] = (((value % 1000) / 100) + 0x30);

        ch[2] = (((value % 100) / 10) + 0x30);

        ch[3] = ((value % 10) + 0x30);

        ch[4] = 0x20;

        ch[5] = 0x20;

    }

    else if((value > 9) && (value <= 99))

    {

        ch[1] = (((value % 100) / 10) + 0x30);

        ch[2] = ((value % 10) + 0x30);

        ch[3] = 0x20;

        ch[4] = 0x20;

        ch[5] = 0x20;

    }

    else

    {

        ch[1] = ((value % 10) + 0x30);

        ch[2] = 0x20;

        ch[3] = 0x20;

        ch[4] = 0x20;

        ch[5] = 0x20;

    }

    LCD_goto(x_pos, y_pos);

    LCD_putstr(ch);

}

void print_D(unsigned char x_pos, unsigned char y_pos, signed int value, unsigned char points)

{

    char ch[5] = {0x2E, 0x20, 0x20, '\0'};

    ch[1] = ((value / 100) + 0x30);

    if(points > 1)

    {

        ch[2] = (((value / 10) % 10) + 0x30);

        if(points > 1)

        {

            ch[3] = ((value % 10) + 0x30);

        }

    }

    LCD_goto(x_pos, y_pos);

    LCD_putstr(ch);

}

void print_F(unsigned char x_pos, unsigned char y_pos, float value, unsigned char points)

{

    signed long tmp = 0x0000;

    tmp = value;

    print_I(x_pos, y_pos, tmp);

    tmp = ((value - tmp) * 1000);

    if(tmp < 0)

    {

       tmp = -tmp;

    }

    if(value < 0)

    {

        value = -value;

        LCD_goto(x_pos, y_pos);

        LCD_putchar(0x2D);

    }

    else

    {

        LCD_goto(x_pos, y_pos);

        LCD_putchar(0x20);

    }

    if((value >= 10000) && (value < 100000))

    {

        print_D((x_pos + 6), y_pos, tmp, points);

    }

    else if((value >= 1000) && (value < 10000))

    {

        print_D((x_pos + 5), y_pos, tmp, points);

    }

    else if((value >= 100) && (value < 1000))

    {

        print_D((x_pos + 4), y_pos, tmp, points);

    }

    else if((value >= 10) && (value < 100))

    {

        print_D((x_pos + 3), y_pos, tmp, points);

    }

    else if(value < 10)

    {

        print_D((x_pos + 2), y_pos, tmp, points);

    }

}

Schematic

Explanation

One wire communication is detailed in these application notes from Maxim:

https://www.maximintegrated.com/en/app-notes/index.mvp/id/126

https://www.maximintegrated.com/en/app-notes/index.mvp/id/162

These notes are all that are needed for implementing the one wire communication interface for DS18B20. Please go through these notes. The codes are self-explanatory and are implemented from the code examples in these app notes.

Decoding NEC IR Remote Protocol

IR remote controllers are used in a number of devices for remotely controlling them. Examples of these devices include TV, stereo, smart switches, projectors, etc. IR communication as such is unidirectional and in a way one wire communication. Ideally there is one transmitter and one receiver only.

Data to be sent from a remote transmitter is sent by modulating it with a carrier wave (usually between 36kHz to 40kHz). Modulation ensure safety from data corruption and long-distance transmission. An IR receiver at the receiving end receives and demodulates the sent out modulated data and outputs a stream of pulses. These pulses which vary in pulse widths/timing/position/phase carry the data information that was originally sent by the remote transmitter. How the pulses should behave is governed closely by a protocol or defined set of rules. In most micros, there is no dedicated hardware for decoding IR remote protocols. A micro that needs to decode IR remote data also doesn’t know when it will be receiving an IR data stream. Thus, a combination of external interrupt and timer is needed for decoding IR data.

In this segment, we will see how we can use an external interrupt and a timer to easily decode a NEC IR remote. This same method can be applied to any IR remote controller. At this stage, I recommend that you do a study of NEC IR protocol from here. SB-Project’s website is an excellent page for info as such.

Code

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

#include "soft_delay.h"

#include "LCD_2_Wire.h"

#define sync_high          22000

#define sync_low           14000

#define one_high            3600

#define one_low             2400

#define zero_high           1800

#define zero_low            1200

bit received;

unsigned char bits = 0;

unsigned int frames[33];

void setup(void);

void set_Timer_0(unsigned int value);

unsigned int get_Timer_0(void);

void erase_frames(void);

unsigned char decode(unsigned char start_pos, unsigned char end_pos);

void decode_NEC(unsigned char *addr, unsigned char *cmd);

void lcd_print(unsigned char x_pos, unsigned char y_pos, unsigned char value);

void EXTI0_ISR(void)

interrupt 0

{

  frames[bits] = get_Timer_0();

  bits++;

  set_TR0;

  if(bits >= 33)

  {

     received = 1;

     clr_EA;

     clr_TR0;

  }

  set_Timer_0(0x0000);

  P15 = ~P15;

}

void main(void)

{

  unsigned char address = 0x00;

  unsigned char command = 0x00;

  setup();

  while(1)

  {   

     if(received)

     {

       decode_NEC(&address, &command);

       lcd_print(13, 0, address); 

       lcd_print(13, 1, command);

       delay_ms(100);

       erase_frames();

       set_EA;

     }

  };

}

void setup(void)

{ 

  erase_frames();

  P15_PushPull_Mode;  

  TIMER0_MODE1_ENABLE;          

  set_Timer_0(0x0000);

  set_IT0;

  set_EX0;  

  set_EA;

  LCD_init();

  LCD_clear_home();

  LCD_goto(0, 0);

  LCD_putstr("Address:");

  LCD_goto(0, 1);

  LCD_putstr("Command:");

}

void set_Timer_0(unsigned int value)

{

  TH0 = ((value && 0xFF00) >> 8);

  TL0 = (value & 0x00FF);

}

unsigned int get_Timer_0(void)

{

  unsigned int value = 0x0000;

  value = TH0;

  value <<= 8;

  value |= TL0;

  return value;

}

void erase_frames(void)

{

  for(bits = 0; bits < 33; bits++)

  {

    frames[bits] = 0x0000;

  }

  set_Timer_0(0x0000);

  received = 0;

  bits = 0;

}

unsigned char decode(unsigned char start_pos, unsigned char end_pos)

{

  unsigned char value = 0;

  for(bits = start_pos; bits <= end_pos; bits++)

  {

    value <<= 1;

    if((frames[bits] >= one_low) && (frames[bits] <= one_high))

    {

      value |= 1;

    }

    else if((frames[bits] >= zero_low) && (frames[bits] <= zero_high))

    {

      value |= 0;

    }

    else if((frames[bits] >= sync_low) && (frames[bits] <= sync_high))

    {

      return 0xFF;

    }

  }

  return value;

}

void decode_NEC(unsigned char *addr, unsigned char *cmd)

{

  *addr = decode(2, 9);

  *cmd = decode(18, 25);

}

void lcd_print(unsigned char x_pos, unsigned char y_pos, unsigned char value)

{ 

  LCD_goto(x_pos, y_pos);

  LCD_putchar((value / 100) + 0x30);

  LCD_goto((x_pos + 1), y_pos);

  LCD_putchar(((value % 10) / 10) + 0x30);

  LCD_goto((x_pos + 2), y_pos);

  LCD_putchar((value % 10) + 0x30);

}

Schematic

Explanation

A NEC transmission sends out 33 pulses. The first one is a sync bit and the rest 32 contain address and command info. These 32 address and command bits can be divided into 4 groups – address, command, inverted address and inverted command. The first 16 bits contain address and inverted address while the rest contain command and inverted command. The inverted signals can be used against the non-inverted ones for checking signal integrity.

We already know that IR data is received as a steam of pulses. Pulses represent sync bit or other info, ones and zeros. In case of NEC IR protocol, the pulses have variable lengths. Sync bit represented by a pulse of 9ms high and 4.5ms low – total pulse time is 13.5ms. Check the timing diagram below. Please note that in this timing diagram the blue pulses are from the transmitter’s output and the yellow ones are those received by the receiver. Clearly the pulses are inverted.

Logic one is represented by a pulse of 560µs high time and 2.25ms of low time – total pulse time is 2.81ms. Likewise, logic zero is represented by a pulse of 560µs high time and 1.12ms of low time – total pulse time is 1.68ms.

These timings can vary slightly about 15 – 25% due to a number of factors like medium, temperature, etc. Therefore, we can assume the following timings:

Now as per timing info and timing diagram we have to detect falling edges and time how long it takes to detect another falling edge. In this way, we can time the received pulses and use the pulse time info to decode a received signal.

In the demo, I used external interrupt channel EXTI0 and Timer 0. The system clock frequency is set to 16MHz with HIRC. Timer 0 is set in Mode 1 and its counter is rest to 0 count. EXTI0 is set to detect falling edges. Note that the timer is set but not started.

TIMER0_MODE1_ENABLE;          

set_Timer_0(0x0000);

set_IT0;

set_EX0;  

set_EA;

Also note that each tick of Timer 0 here is about:

Based on this tick info, we can deduce the maximum and minimum pulse durations as like:

#define sync_high          22000 // 22000 × 0.75ms = 16.5ms

#define sync_low           14000 // 14000 × 0.75ms = 10.5ms

#define one_high            3600 // 3600 × 0.75ms = 2.7ms

#define one_low             2400 // 2400 × 0.75ms = 1.8ms

#define zero_high           1800 // 1800 × 0.75ms = 1.35ms

#define zero_low            1200 // 1200 × 0.75ms = 0.9ms

Now when an IR transmission is received, an interrupt will be triggered. Therefore, in the ISR, we immediately capture the timer’s tick count and reset it. When all 33 pulses have been received this way, we temporarily halt all interrupts by disabling the global interrupt and stop the timer in order to decode the received signal. P15 is also toggled to demonstrate reception.

void EXTI0_ISR(void)

interrupt 0

{

  frames[bits] = get_Timer_0();

  bits++;

  set_TR0;

  if(bits >= 33)

  {

     received = 1;

     clr_EA;

     clr_TR0;

  }

  set_Timer_0(0x0000);

  P15 = ~P15;

}

Now the signal is decoded in the decode function. This function scans a fixed length of time frames for sync, ones and zeros and return the value obtained by scanning the time info of the pulses. In this way, a received signal is decoded.

unsigned char decode(unsigned char start_pos, unsigned char end_pos)

{

  unsigned char value = 0;

  for(bits = start_pos; bits <= end_pos; bits++)

  {

    value <<= 1;

    if((frames[bits] >= one_low) && (frames[bits] <= one_high))

    {

      value |= 1;

    }

    else if((frames[bits] >= zero_low) && (frames[bits] <= zero_high))

    {

      value |= 0;

    }

    else if((frames[bits] >= sync_low) && (frames[bits] <= sync_high))

    {

      return 0xFF;

    }

  }

  return value;

}

In the main loop, the decode info are displayed on a text LCD.

Demo

Epilogue

After going through all these topics and exploring the N76E003 to the finest details, I have to say that just like flagship killer cell phones, this is a flagship killer 8-bit microcontroller. In terms of price vs feature ratio, it is a winner. I’m truly impressed by its performance and hardware features. It offers something like an 8051 but with more advanced modern features. Old-school 8051 users will surely love to play with it.

Every day we talk about software piracy and hacking but little effort is done to prevent them. Students, hobbyists and low-profile business houses can’t afford to use the expensive Keil/IAR compiler. They often go for pirated versions of these software and this is a very wrong path to follow. Like I said in my first post on N76E003, Nuvoton has rooms for making its devices more popular by investing on a compiler of its own or at least start doing something with free Eclipse-IDE.

All files and code examples can be downloaded from here.

Youtube playlist.

Happy coding.

Author: Shawon M. Shahryiar

https://www.youtube.com/user/sshahryiar

https://www.facebook.com/groups/microarena

https://www.facebook.com/MicroArena                                                                         

06.08.2018