/**
******************************************************************************
* File Name : main.c
* Description : Main program body
******************************************************************************
*
* COPYRIGHT(c) 2015 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.
*
******************************************************************************
*/
/*
MODIFIED by Hexabitz for BitzOS (BOS) V0.2.3 - Copyright (C) 2017-2019 Hexabitz
All rights reserved
*/
/* Includes ------------------------------------------------------------------*/
#include "BOS.h"
uint8_t x0,x1,x2,x3,x4,x5,x6,x7;
uint8_t y3,y2,y1,y0=1;
uint8_t sw=2;
volatile uint8_t var_out=0;
/* Private variables ---------------------------------------------------------*/
bool input_ind=0;
/* Private function prototypes -----------------------------------------------*/
uint8_t HEX_2_ASCII(uint8_t dec);
uint8_t ASCII_2_hex(uint8_t ascii);
void MODBUS_ASCII(uint8_t address_slave, uint8_t functio_code, uint8_t start_reg_h,uint8_t start_reg_l, uint8_t number_of_reg_h,uint8_t number_of_reg_l);
uint8_t output(uint8_t out3,uint8_t out2,uint8_t out1,uint8_t out0);
void input(uint8_t var_input);
void action(uint8_t selector,uint8_t y3,uint8_t y2,uint8_t y1,uint8_t y0);
uint8_t mod_mm[17];
extern uint8_t MODBUS_recive[15];
/* Main functions ------------------------------------------------------------*/
int main(void)
{
/* MCU Configuration----------------------------------------------------------*/
/* Reset all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all user peripherals */
/* Initialize BitzOS */
BOS_Init();
/* Call init function for freertos objects (in freertos.c) */
MX_FREERTOS_Init();
/* Start scheduler */
osKernelStart();
/* We should never get here as control is now taken by the scheduler */
/* Infinite loop */
while (1)
{
}
}
/*-----------------------------------------------------------*/
//Y0 Y1 Y2 Y3
/* User Task */
void UserTask(void * argument)
{
//MODBUS_ASCII(0x02, 0x06, 0x10, 0x04, 0x00, 0x01); //writing regester D4 for output ->y0 >> ON
//
//MODBUS_ASCII(0x02, 0x03, 0x10, 0x03, 0x00, 0x01); ////////reading D3 fo input
//MODBUS_ASCII(0x02, 0x02, 0x04, 0x00, 0x00, 0x07); /////// reading X0 >> X7
//MODBUS_ASCII(0x02, 0x02, 0x05, 0x00, 0xFF, 0x00); /////set y0
//MODBUS_ASCII(0x02, 0x02, 0x05, 0x00, 0x00, 0x00); /////reset y0
//MODBUS_ASCII(0x02, 0x02, 0x05, 0x01, 0xFF, 0x00); /////set y1
//MODBUS_ASCII(0x02, 0x02, 0x05, 0x01, 0x00, 0x00); /////reset y1
//MODBUS_ASCII(0x02, 0x02, 0x05, 0x02, 0xFF, 0x00); /////set y2
//MODBUS_ASCII(0x02, 0x02, 0x05, 0x02, 0x00, 0x00); /////reset y2
//MODBUS_ASCII(0x02, 0x02, 0x04, 0x03, 0xFF, 0x00); /////set y3
//MODBUS_ASCII(0x02, 0x02, 0x04, 0x03, 0x00, 0x00); /////reset y3
///////////////////////////////////////////////////
/* Infinite loop */
for(;;)
{
////////writing output
IND_ON();
action(sw,y0,y1,y2,y3);
Delay_ms(50);
IND_OFF();
Delay_ms(100);
//////////readig input
}
}
/*-----------------------------------------------------------*/
/************************ (C) COPYRIGHT HEXABITZ *****END OF FILE****/
///////////////////////MODBUS ASCII PROTOCOL (7,N,1,ASCII,115200)
/* all argumants in HEX
address_slave: destination.
start_reg: destination regestar.
functio_code: 02 reading contact ,03 reading register ,05 preset singel coil ,06 preset singel regester.
number_of_reg: number of regester to be read.
*/
//// mes = [0x3A, 2 BYTE for address , 2 BYTE for function code , //4 BYTE for adress regester// ,2 BYTE LRC ,0x0D,0x0A]
//0x1000;
void action(uint8_t selector,uint8_t y3,uint8_t y2,uint8_t y1,uint8_t y0)
{
uint8_t j=0,MODBUS_recive_l,MODBUS_recive_h,var_input;
uint8_t modbus_reg=output(y3,y2,y1,y0);
switch(selector)
{
/////////writing output status
case 1:
MODBUS_ASCII(0x02, 0x06, 0x10, 0x04, 0x00, modbus_reg);/////D4
break;
///////reading input status
case 2:
MODBUS_ASCII(0x02, 0x03, 0x10, 0x03, 0x00, 0x01);////D3
/////////////parsing data for input regester
for(int i=0;i<15;i++)
if(MODBUS_recive[i]==0x3a)
{j=i;break;}
switch(j)
{case 0: MODBUS_recive_h=MODBUS_recive[9] ;MODBUS_recive_l=MODBUS_recive[10] ; break;
case 1: MODBUS_recive_h=MODBUS_recive[10] ;MODBUS_recive_l=MODBUS_recive[11] ; break;
case 2: MODBUS_recive_h=MODBUS_recive[11] ;MODBUS_recive_l=MODBUS_recive[12] ; break;
case 3: MODBUS_recive_h=MODBUS_recive[12] ;MODBUS_recive_l=MODBUS_recive[13] ; break;
case 4: MODBUS_recive_h=MODBUS_recive[13] ;MODBUS_recive_l=MODBUS_recive[14] ; break;
case 5: MODBUS_recive_h=MODBUS_recive[14] ;MODBUS_recive_l=MODBUS_recive[0] ; break;
case 6: MODBUS_recive_h=MODBUS_recive[0] ;MODBUS_recive_l=MODBUS_recive[1] ; break;
case 7: MODBUS_recive_h=MODBUS_recive[1] ;MODBUS_recive_l=MODBUS_recive[2] ; break;
case 8: MODBUS_recive_h=MODBUS_recive[2] ;MODBUS_recive_l=MODBUS_recive[3] ; break;
case 9: MODBUS_recive_h=MODBUS_recive[3] ;MODBUS_recive_l=MODBUS_recive[4] ; break;
case 10: MODBUS_recive_h=MODBUS_recive[4] ;MODBUS_recive_l=MODBUS_recive[5] ; break;
case 11: MODBUS_recive_h=MODBUS_recive[5] ;MODBUS_recive_l=MODBUS_recive[6] ; break;
case 12: MODBUS_recive_h=MODBUS_recive[6] ;MODBUS_recive_l=MODBUS_recive[7] ; break;
case 13: MODBUS_recive_h=MODBUS_recive[7] ;MODBUS_recive_l=MODBUS_recive[8] ; break;
case 14: MODBUS_recive_h=MODBUS_recive[8] ;MODBUS_recive_l=MODBUS_recive[9] ; break;
}
var_input=ASCII_2_hex(MODBUS_recive_l)+ASCII_2_hex(MODBUS_recive_h)*0x10; ///////////raw data
input(var_input);
break;
default:
break;
}
}
void MODBUS_ASCII(uint8_t address_slave, uint8_t functio_code, uint8_t start_reg_h,uint8_t start_reg_l, uint8_t number_of_reg_h,uint8_t number_of_reg_l)
{
uint8_t modbus_mes[17]={0};
modbus_mes[0]=0x3A; /// :
if(address_slave<=0x0F)
{
modbus_mes[1]=HEX_2_ASCII(0x00);
modbus_mes[2]=HEX_2_ASCII(address_slave);
}
else
{
modbus_mes[1]=HEX_2_ASCII(address_slave/0x10);
modbus_mes[2]=HEX_2_ASCII(address_slave%0x10);
}
modbus_mes[3]=HEX_2_ASCII(0x00);
modbus_mes[4]=HEX_2_ASCII(functio_code);
modbus_mes[5]=HEX_2_ASCII(start_reg_h/0x10);
modbus_mes[6]=HEX_2_ASCII(start_reg_h%0x10);
modbus_mes[7]=HEX_2_ASCII(start_reg_l/0x10);
modbus_mes[8]=HEX_2_ASCII(start_reg_l%0x10);
modbus_mes[9] =HEX_2_ASCII(number_of_reg_h/0x10);
modbus_mes[10]=HEX_2_ASCII(number_of_reg_h%0x10);
modbus_mes[11]=HEX_2_ASCII(number_of_reg_l/0x10);
modbus_mes[12]=HEX_2_ASCII(number_of_reg_l%0x10);
uint8_t nLRC = 0 ; // LRC char initialized
nLRC =address_slave+functio_code+start_reg_h+start_reg_l+number_of_reg_h+number_of_reg_l;
nLRC=0xFF-nLRC;
nLRC++;
modbus_mes[13]=HEX_2_ASCII(nLRC/0x10);
modbus_mes[14]=HEX_2_ASCII(nLRC%0x10);
modbus_mes[15]=0x0D;
modbus_mes[16]=0x0A;
//////for monitoring message
for(int i=0;i<17;i++)
mod_mm[i]=modbus_mes[i];
HAL_UART_Transmit(&huart4,modbus_mes,17,100);
}
uint8_t output(uint8_t out3,uint8_t out2,uint8_t out1,uint8_t out0)
{
var_out=out3<<3 | out2<<2 | out1<<1 | out0;
return var_out;
}
void input(uint8_t var_input)
{
x0=var_input & 1;if(x0>0)x0=1;
x1=var_input & 2;if(x1>0)x1=1;
x2=var_input & 4;if(x2>0)x2=1;
x3=var_input & 8;if(x3>0)x3=1;
x4=var_input & 16;if(x4>0)x4=1;
x5=var_input & 32;if(x5>0)x5=1;
x6=var_input & 64;if(x6>0)x6=1;
x7=var_input & 128;if(x7>0)x7=1;
}
uint8_t HEX_2_ASCII(uint8_t hex)
{
uint8_t result;
switch(hex)
{
case 0x00:
result=0x30;
break;
case 1:
result=0x31;
break;
case 2:
result=0x32;
break;
case 3:
result=0x33;
break;
case 4:
result=0x34;
break;
case 5:
result=0x35;
break;
case 6:
result=0x36;
break;
case 7:
result=0x37;
break;
case 8:
result=0x38;
break;
case 9:
result=0x39;
break;
case 0x0A:
result=0x41;
break;
case 0x0B:
result=0x42;
break;
case 0x0C:
result=0x43;
break;
case 0x0D:
result=0x44;
break;
case 0x0E:
result=0x45;
break;
case 0x0F:
result=0x46;
break;
}
return result;
}
uint8_t ASCII_2_hex(uint8_t ascii)
{
uint8_t result;
switch(ascii)
{
case 0x30:
result=0x00;
break;
case 0x31:
result=0x01;
break;
case 0x32:
result=0x02;
break;
case 0x33:
result=0x03;
break;
case 0x34:
result=0x04;
break;
case 0x35:
result=0x05;
break;
case 0x36:
result=0x06;
break;
case 0x37:
result=0x07;
break;
case 0x38:
result=0x08;
break;
case 0x39:
result=0x09;
break;
case 0x41:
result=0x0A;
break;
case 0x42:
result=0x0B;
break;
case 0x43:
result=0x0C;
break;
case 0x44:
result=0x0D;
break;
case 0x45:
result=0x0E;
break;
case 0x46:
result=0x0F;
break;
}
return result;
}
Comments
Please log in or sign up to comment.