AHURATUS Smart Home Voice Assistant

N|Solid


N|Solid


AHURATUS Smart Home Voice Assistant


Developed by Ehsan Shaghaei
Innopolis University
AHURATUS Scientific Club.

STM32F103ZET6 UNIVERSAL BOARD


Introduction


AHURATUS Smart Home Voice Assistant is an IOT device developed in order to control other home devices by voice detection. Note: This device is made ONLY for academic purposes.


Approach


Description


"AHURATUS Smart Home Voice Assistant" uses an ARM Cortex-M3 process for running the instructions as well as several peripheral devices in order to decrease the complexity of data bus and RF-Circuit calculations.


Bill of Materials


# Component Name Role Technical Document links
1 STM32F103ZET6 Process and Control Datasheet
2 HC-05 Bluetooth Module Bluetooth Radio Connection Datasheet
3 220-5V AC-DC Adapter Powering the circuit Datasheet
4 LED or Mosfets or Relays To System Output Datasheet

Workbench and Softwares


# Software Name Role Links and refrences
1 STM32CubeIDE IDE for Coding our instruction Link
2 GNU-ARM C-Compiler for ARM processors Link
3 Jlink Programmer and Debugger Link
4 HERCULES SerialPort Monitoring Software Link
5 Arduino Voice Control Android Application to send data to our device Link

STM32F103ZET6 UNIVERSAL BOARD


Details


We use HAL drivers which were provided by the processor manufacture in order to reduce the complexity of fault checking and straight forward usage of peripherals. We use HC-05 in order to receive data from our user via a wireless connection by setting the module settings trough the following AT command:


Transmit: AT+UART = 115200, 0, 0
Response: OK
_ Note: In order to apply AT Commands you need to connect the KEY pin to the HIGH level.

by using STM32CubeIDE we set the peripheral registers as follows:


  • UART2 (HC-05 Serial Port):

 huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }

  • UART1 (Monitoring Serial Port Trough RS-232 Standard Port):

 huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }

  • DMA Channels 11, 15 and 16 (Direct Memory Access for UART2 RX and UART1 RX and UART1 TX respectively.):

 /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();

  /* DMA interrupt init */
  /* DMA1_Channel1_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
  /* DMA1_Channel5_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
  /* DMA1_Channel6_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel6_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn);

Furthermore, we set the GPIO modes as following in order to Drive our LEDs or other Devices.


  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOE_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOG_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOE, GPIO_PIN_5, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOF, LED3_Pin|GPIO_PIN_7|LED1_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, LED4_Pin|GPIO_PIN_2, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOG, GPIO_PIN_6|LED2_Pin|GPIO_PIN_11, GPIO_PIN_RESET);

  /*Configure GPIO pin : PE2 */
  GPIO_InitStruct.Pin = GPIO_PIN_2;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

  /*Configure GPIO pins : PE3 PE4 PE6 */
  GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_6;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

  /*Configure GPIO pin : PE5 */
  GPIO_InitStruct.Pin = GPIO_PIN_5;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

  /*Configure GPIO pins : LED3_Pin PF7 LED1_Pin */
  GPIO_InitStruct.Pin = LED3_Pin|GPIO_PIN_7|LED1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

  /*Configure GPIO pin : PA0 */
  GPIO_InitStruct.Pin = GPIO_PIN_0;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pins : LED4_Pin PB2 */
  GPIO_InitStruct.Pin = LED4_Pin|GPIO_PIN_2;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pin : PB10 */
  GPIO_InitStruct.Pin = GPIO_PIN_10;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pin : PB11 */
  GPIO_InitStruct.Pin = GPIO_PIN_11;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pins : PG6 LED2_Pin PG11 */
  GPIO_InitStruct.Pin = GPIO_PIN_6|LED2_Pin|GPIO_PIN_11;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);

  /*Configure GPIO pin : PG8 */
  GPIO_InitStruct.Pin = GPIO_PIN_8;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);

Finally, we write the following code in c main() function in order to execute our command decoding algorithm :


HAL_UART_Transmit(&huart1,"Ping->> AHURATUS VOICE ASSISTANT\r\n", sizeof("Ping->> AHURATUS VOICE ASSISTANT\r\n"), 1);
int i;
    for (i=0; i<100;i++){
          data[i] = '\0';
      }
HAL_UART_Receive_DMA(&huart2, data, sizeof(data));

   while (1)
  {
     if(strlen(data)>2){
         if(strcasecmp( data,"Hey")==0){
                  HAL_UART_DMAStop(&huart2);
                  HAL_UART_Transmit(&huart1, "How can I help you ?\r\n", sizeof("How can I help you ?\r\n"), 100);//Users Signal Receieved!
                  int i;
                  for (i=0; i<100;i++){
                      data[i] = '\0';
                  }
                  HAL_UART_Receive_DMA(&huart2, data, sizeof(data));// Polling for new data
                  int FLG = 1;
                  while(!strlen(data)){

                      if(FLG){
                          HAL_UART_Transmit(&huart1, "Polling for Command ...\r\n", sizeof("Polling for Command ...\r\n"), 1);
                      }
                     FLG= 0;
                     //wait...
                  }
                  HAL_Delay(200);//short delay to recieve the rest of data;

                  if(   (!strcasecmp(data,"turn on light one"))
                          ||(!strcasecmp(data,"turn on light 1")) ){
                    HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_GPIO_Port,GPIO_PIN_SET);
                            HAL_UART_Transmit(&huart1, "Light 1 Turned ON\r\n", sizeof("Light 1 Turned ON\r\n"), 1);
                  }else if( (!strcasecmp(data,"turn off light one"))
                          ||(!strcasecmp(data,"turn off light 1")) ){
                    HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_GPIO_Port,GPIO_PIN_RESET);
                            HAL_UART_Transmit(&huart1,  "Light 1 Turned OFF\r\n", sizeof("Light 1 Turned OFF\r\n"), 1);
                  }else if( (!strcasecmp(data,"turn on light two"))
                          ||(!strcasecmp(data,"turn on light 2")) ){
                    HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_GPIO_Port,GPIO_PIN_SET);
                            HAL_UART_Transmit(&huart1,  "Light 2 Turned ON\r\n", sizeof("Light 2 Turned ON\r\n"), 1);
                  }else if( (!strcasecmp(data,"turn off light two"))
                          ||(!strcasecmp(data,"turn off light 2")) ){
                    HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_GPIO_Port,GPIO_PIN_RESET);
                            HAL_UART_Transmit(&huart1,  "Light 2 Turned OFF\r\n", sizeof("Light 2 Turned OFF\r\n"), 1);
                  }else if( (!strcasecmp(data,"turn on light three"))
                          ||(!strcasecmp(data,"turn on light 3")) ){
                    HAL_GPIO_WritePin(LED3_GPIO_Port, LED3_GPIO_Port,GPIO_PIN_SET);
                            HAL_UART_Transmit(&huart1,  "Light 3 Turned ON\r\n", sizeof("Light 3 Turned ON\r\n"), 1);
                  }else if( (!strcasecmp(data,"turn off light three"))
                          ||(!strcasecmp(data,"turn off light 3")) ){
                    HAL_GPIO_WritePin(LED3_GPIO_Port, LED3_GPIO_Port,GPIO_PIN_RESET);
                            HAL_UART_Transmit(&huart1, "Light 3 Turned OFF\r\n", sizeof("Light 3 Turned OFF\r\n"), 1);
                  }else if( (!strcasecmp(data,"turn on light four"))
                          ||(!strcasecmp(data,"turn on light 4")) ){
                    HAL_GPIO_WritePin(LED4_GPIO_Port, LED4_GPIO_Port,GPIO_PIN_SET);
                            HAL_UART_Transmit(&huart1, "Light 4 Turned ON\r\n", sizeof("Light 4 Turned ON\r\n"), 1);

                  }else if( (!strcasecmp(data,"turn off light four"))
                          ||(!strcasecmp(data,"turn off light 4")) ){
                    HAL_GPIO_WritePin(LED4_GPIO_Port, LED4_GPIO_Port,GPIO_PIN_RESET);
                            HAL_UART_Transmit(&huart1, "Light 4 Turned OFF\r\n", sizeof("Light 4 Turned OFF\r\n"), 1);
                  }

                  }else{
                            HAL_UART_Transmit(&huart1, "ERROR-> INVALID Command\r\n", sizeof("ERROR-> INVALID Command\r\n"), 1);
                  }
                  HAL_UART_DMAStop(&huart2);
                  for (i=0; i<100;i++){ data[i] = '\0'; }//makes the buffer empty
                  HAL_UART_Receive_DMA(&huart2, data, sizeof(data));

              }

     }

Afterward, we use an android device to connect to our system by Bluetooth. we use "Arduino Voice Control" application in order to send voice to our system.
by Keyword "HEY" our system polls for the next commands and follows your voice commands as mentioned above.


Conclusion


"AHURATUS Smart Home Voice Assistant" project can be used in order to have a simple and cheap functional smart home device by a few simple modifications in the circuit; such as:


  • Using a MOSFET and an AC Isolation Circuit to control devices with AC working voltages
  • Using Pulse Width Modulation (PWM) in order to have more control over the output
  • Use TRIAC to have a adjustable light level setter
  • Design a better application to have better interaction with user
  • use Kinect or other Motion Detection Devices to measure make the device compatible with users gestures.

Regards,
Ehsan Shaghaei
Contact to me
Share post

Similar posts

AdBlock has stolen the banner, but banners are not teeth — they will be back

More
Ads

Comments 1

    0
    is an IOT device developed in order to control other home devices by voice detection

    As I understand, a smartphone must be connected to this device to analyse voice commands. So, this mean that you are speaking about a system, not just about single device.

    Only users with full accounts can post comments. Log in, please.