Published January 25, 2019 © GPL3+

Intelligent AC Solid State Switch

Bipolar solid state power relay, capable of commutation without arcing and/or overcurrent events.

ExpertFull instructions providedOver 12 days1,749

Best Industrial Application (e.g. Telecom, Server, Solar, Industrial Robots & Cobots)

Powering the Future with Infineon

Things used in this project

Hardware components

Infineon CoolMOS C7 Gold SJ MOSFET

Mosfet used

STMicroelectronics STM32 Nucleo-64 Board

Logic control unit

ACS720

Galvanically isolated Current sensor

ACPL-335J

Opto Gate Driver

Software apps and online services

Autodesk Eagle CAD

PCB design software

STMicroelectronics STM32Cube

STM32 microcontroller configuration tool

Story

Overview

Different loads behave differently when connected to the AC mains. Traditional electromechanical relays/contactors employed in industry and automation are not capable of synchronizing with the grid electrical quantities when making or breaking connection. As a result, arcing and/or overcurrent occurs, reducing the lifetime of relay contacts and stressing unnecessarily the commutated load.

System Description

This project consists in the design of a bipolar intelligent power Solid State Relay (SSR), capable of commutating different loads (resistive, inductive or capacitive) without introducing overcurrents during the turn-on phase and avoiding voltage spikes during the turn-off phase. Bipolar topology allows to completely insulate the load from the AC source.

When the load is predominantly of capacitive type, the turn-on commutation is performed at the zero-crossing of the input voltage sine wave. This allows to greatly reduce the inrush current.

When the load is predominantly of inductive type, the turn-on is performed at the peak of the input voltage sine wave, in order to avoid core saturation an then reduce inrush current when driving e.g. large transformers.

During turn-off, in boh cases, the commutation occurs on current zero crossing, in order to avoid voltage spikes caused by the stray inductance of the power line.

The following figure shows the functional scheme. The AC grid is directly connected at the input of the SSR. The system consists of two main PCB: the SSR board and the Nucleo-64 logic unit board.

Functional scheme

Power Solid State Relay (SSR)

The power SSR was developed using EAGLE PCB CAD software. The SSR employes four 600 V CoolMOS™ C7 in antiseries connection to implement the bipolar switch topology. The MOSFETs are controlled by opto gate drivers. The input voltage is measured by the optically insulated voltage sensor ACPL-C87B. The input current is measured by the galvanically insulated current sensor ACS720.

1 / 2

Nucleo-64 Logic Unit

The logic unit is implemented by the development board Nucleo-64. The sensing of input voltage/current and the generation of the gate signals is performed by the on board microcontroller STM32F446.

Logic unit: Development Board Nucleo-64

The GPIO and all peripherals were configured using STM32CubeMX tool.

1 / 2 • STM32CubeMX pin configuration

Control and Operation Modes

The following figure shows the control system flowchart implemented by the code.

Control Flow Chart

Start: in this state the code is initialized. All microcontroller peripherals are properly configurated. This state is invoked at the power-on and every time the reset button is pressed.

Peak voltage measure: if the Nucleo-64 B1 blue switch button is pressed, the control looks for the turn-on modality. The turn-on modality is set by the Mode Selctor pin (PA15 GPIO). If the pin is linked to ground, the capacitive mode will be selected. If it is pulled-up, the inductive mode will be selected.
Capacitive mode: in capacitive mode the turn-on of the gate signals is at the zero-crossing of the input sine wave voltage (ZVS).
Inductive mode: in inductive mode the turn-on of the gate signals is at the peak of the input sine wave voltage.
Disabling SSR: if the B1 button is pressed, the SSR is disabled. The gate signals are turned-off on at the zero-crossing of the current. If a fault event is detected, the turn-off happens immediatly without delay.

Fault events:

Three different fault events are monitored:

1) Self-diagnosis of undervoltage lockout and overcurrent fault implemented by the opto gate drivers. The microcontroller monitors the predefined GPIO where the faults are reported. The fault event is managed by an interrupt service routine.

2) software load overcurrent.

3) software input overvoltage.

Experimental Results

The SSR was tested in Inductive Mode and Capacitive Mode.

System under test

Legend of the oscilloscope captures:

blue trace: gate signal of one CoolMOS
green trace: grid sine-wave voltage
red trace: load sine-wave voltage
purple trace: current load

Preliminary tests were conducted on a purely resistive load, in order to validate the different load commutation strategies implemented.

The following capture shows the SSR turn-on at the peak of the input voltage, when Inductive Mode is selected.

Turn-on at the peak of the input voltage in Inductive Mode

The following capture shows the SSR turn-on at the zero-crossing of the input voltage, when Capacitive Mode is selected.

Turn-on at the zero-crossing of the input voltage in Capacitive Mode

The following capture shows the SSR turn-off at the zero-crossing of the input current.

Turn-off at the zero-crossing of the load current

Code

Application Code

/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  ** This notice applies to any and all portions of this file
  * that are not between comment pairs USER CODE BEGIN and
  * USER CODE END. Other portions of this file, whether 
  * inserted by the user or by software development tools
  * are owned by their respective copyright owners.
  *
  * COPYRIGHT(c) 2019 STMicroelectronics
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *   1. Redistributions of source code must retain the above copyright notice,
  *      this list of conditions and the following disclaimer.
  *   2. Redistributions in binary form must reproduce the above copyright notice,
  *      this list of conditions and the following disclaimer in the documentation
  *      and/or other materials provided with the distribution.
  *   3. Neither the name of STMicroelectronics nor the names of its contributors
  *      may be used to endorse or promote products derived from this software
  *      without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "adc.h"
#include "dac.h"
#include "tim.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stm32f4xx.h"
#include "DWT_Delay.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
uint8_t Fault = DISABLE;
uint32_t Value_ADC1[2];
//Global structure
 typedef struct
{
	float ADC1_val;										//ADC1 Value
	float ADC2_val;										//ADC2 Value
	float I_IN;                       //Grid Current
	double V_IN;                      //Grid Voltage
	float Cor_ADC1;                   //Correction factor ADC1
	float Cor_ADC2;										//Correction factor ADC2
	float V_IN_Peak_MAX;              //Peak Grid Voltage
	uint8_t Status_Switch;            //OPERATING Status
	uint8_t Tick_TIM;                 //Time peak voltage detection
	uint8_t Fault;                    //State Faults
	uint8_t Start_conversion;         //Start peak voltage detection
	uint8_t OPERATING_MODE;           //OPERATING MODE
	uint16_t V_IN_Limit;              //Voltage limit
	uint8_t I_IN_Limit;               //Current limit
}t_SystemStruct;


t_SystemStruct SysStruct;
t_SystemStruct *p = &SysStruct;
#define INDUCTIVE_MODE 0  //INDUCTIVE MODE
#define CAPACITIVE_MODE 1 //CAPACITIVE MODE
#define IDLE  0           // State of System
#define START 1           // State of System
#define STOP  2           // State of System


/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
 
/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_ADC1_Init();
  MX_USART2_UART_Init();
  MX_ADC2_Init();
  MX_DAC_Init();
  MX_TIM6_Init();
  MX_TIM7_Init();
  /* USER CODE BEGIN 2 */
	HAL_ADC_Start(&hadc1);
	HAL_ADC_Start(&hadc2);
  HAL_DAC_Start(&hdac,DAC1_CHANNEL_1);	
  InitParameter();
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
  if(p->Start_conversion == ENABLE)
    { // Start conversion
     if(HAL_ADC_PollForConversion(&hadc1, 100) == HAL_OK) //timeout di 100ms
       {//I_in
       p->ADC1_val= HAL_ADC_GetValue(&hadc1);	
       p->I_IN = ((p->ADC1_val*0.00081)-1.65)*(p->Cor_ADC1); //Logic Volt -> Grid Current
       }
    	   
    if(HAL_ADC_PollForConversion(&hadc2, 100) == HAL_OK) //timeout di 100ms
      {	//Vin
       p->ADC2_val = HAL_ADC_GetValue(&hadc2);
       p->V_IN = (p->ADC2_val*0.00081)*(p->Cor_ADC2); //Logic Volt -> Grid Volt 
      }
    if(p->V_IN_Peak_MAX < p->V_IN)
      {
       p->V_IN_Peak_MAX=p->V_IN;
      }
    }
   if((p->V_IN_Peak_MAX >=p->V_IN_Limit || p->V_IN_Peak_MAX <=-(p->V_IN_Limit) ) || (p->I_IN>= p->I_IN_Limit|| p->I_IN<= -(p->I_IN_Limit))) 
    {// Over Current & Over Voltage Fault
    p->Fault=ENABLE; 	
		HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin,GPIO_PIN_RESET);
		HAL_GPIO_WritePin(PWM_1_GPIO_Port, PWM_1_Pin,GPIO_PIN_RESET);
		HAL_GPIO_WritePin(PWM_2_GPIO_Port, PWM_2_Pin,GPIO_PIN_RESET);
		HAL_TIM_Base_Stop_IT(&htim6);
		HAL_TIM_Base_Start_IT(&htim7);
    }
	switch (p->Status_Switch)
				{
					case START: //Enable Switch
									if (p->V_IN>=p->V_IN_Peak_MAX )
								{
									if(p->OPERATING_MODE == CAPACITIVE_MODE)
										{
											HAL_Delay(12);  // Delay ms
											DWT_Delay(500); // Delay us
									  }
									HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin,GPIO_PIN_SET);
									HAL_GPIO_WritePin(PWM_1_GPIO_Port, PWM_1_Pin,GPIO_PIN_SET);
									HAL_GPIO_WritePin(PWM_2_GPIO_Port, PWM_2_Pin,GPIO_PIN_SET);
									
								}	
					break;
					case STOP: //Disable Switch
									if (p->I_IN <= 0.1 && p->I_IN >= -0.1 )
								{
									HAL_TIM_Base_Stop_IT(&htim6);
									HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin,GPIO_PIN_RESET);
									HAL_GPIO_WritePin(PWM_1_GPIO_Port, PWM_1_Pin,GPIO_PIN_RESET);
									HAL_GPIO_WritePin(PWM_2_GPIO_Port, PWM_2_Pin,GPIO_PIN_RESET);
									InitParameter();
									
								}	  		
					break;
				}
  }
		
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /**Configure the main internal regulator output voltage 
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE3);
  /**Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 16;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
  RCC_OscInitStruct.PLL.PLLQ = 2;
  RCC_OscInitStruct.PLL.PLLR = 2;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /**Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */


void InitParameter(void)
{
  p->Cor_ADC1 =58;          				// Correction Number for ADC1
  p->Cor_ADC2 =10;          				// Correction Number for ADC2
  p->V_IN_Peak_MAX=0;       				// Reset Voltage Peak Detection
  p->Status_Switch=DISABLE; 				// Reset Status Switch
  p->Tick_TIM=0;           			    // Reset Tick Timer
  p->Fault=DISABLE;       				  // Reset Faults
  p->Start_conversion =DISABLE;   	// Reset Status Conversion
  p->V_IN_Limit = 300;      				// Max peak Voltage
  p->I_IN_Limit =20;	       				// Max peak Current
  
  if((HAL_GPIO_ReadPin(Mode_Selector_GPIO_Port,Mode_Selector_Pin)))
   {
     p->OPERATING_MODE = INDUCTIVE_MODE;
   }
  else
   {
     p->OPERATING_MODE = CAPACITIVE_MODE;
   }
}


void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  if (htim->Instance == TIM6)
    {
     p->Start_conversion = ENABLE; //Start peack voltage detection
     if(p->Tick_TIM<=3)
       {
        p->Tick_TIM++;
       }
     if(p->Tick_TIM==2)
       {
          p->Status_Switch = START; //Enable Switch
       }
    }
 if (htim->Instance == TIM7)
    {
     HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin); // LED Blink
     if(p->Status_Switch==START)
       {
        p->Status_Switch = STOP;} // -> State STOP
       }
}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  if((GPIO_Pin==B1_Pin) && (p->Status_Switch==START) )
		{		
			//STOP			
			p->Status_Switch = STOP;
		}
	else if((GPIO_Pin==B1_Pin) && (p->Status_Switch==IDLE) && p->Fault==DISABLE)
		{		
			//Start
			HAL_TIM_Base_Start_IT(&htim6);
			HAL_TIM_Base_Stop_IT(&htim7);
		}
  if(((HAL_GPIO_ReadPin(FAULT_N_GPIO_Port,FAULT_N_Pin))== RESET || (HAL_GPIO_ReadPin(UVLO_N_GPIO_Port,UVLO_N_Pin))== RESET ||(HAL_GPIO_ReadPin(FAULT_L_GPIO_Port,FAULT_L_Pin))== RESET || (HAL_GPIO_ReadPin(UVLO_L_GPIO_Port,UVLO_L_Pin))== RESET ) )
		{
      // Faults & Diable Switch
      p->Fault=ENABLE; 	
			HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin,GPIO_PIN_RESET);
			HAL_GPIO_WritePin(PWM_1_GPIO_Port, PWM_1_Pin,GPIO_PIN_RESET);
      HAL_GPIO_WritePin(PWM_2_GPIO_Port, PWM_2_Pin,GPIO_PIN_RESET);
      HAL_TIM_Base_Stop_IT(&htim6);
      HAL_TIM_Base_Start_IT(&htim7); //Active LED
			  
		}
}
/* USER CODE END 4 */

Credits

GIOVANNI MIGLIAZZA

2 projects • 3 followers

I'm Mechatronic Engineering, PhD Student at the University of Modena and Reggio Emilia, Department of science and methods for engineering.

Comments

Awards

Best Industrial Application (e.g. Telecom, Server, Solar, Industrial Robots & Cobots)

Powering the Future with Infineon

Intelligent AC Solid State Switch