using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
/// <summary>
/// Contains <see cref="Type"/> extension methods.
/// </summary>
public static class TypeExtensions
{
/// <summary>
/// Gets all the extension methods registered in the specified assembly.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="extensionsAssembly">The extensions assembly.</param>
/// <returns></returns>
public static IEnumerable<MethodInfo> GetExtensionMethods(this Type type, Assembly extensionsAssembly)
{
var query = from t in extensionsAssembly.GetTypes()
where !t.IsGenericType && !t.IsNested
from m in t.GetMethods(BindingFlags.Static | BindingFla#include <Container.h>
#include <PMR/Common/MessageContainer.pb-c.h>
#include <PMR/Stubs/ProgressRequest.pb-c.h>
#include <PMR/Stubs/ProgressResponse.pb-c.h>
#include "include.h"
#include "driverlib/gpio.h"
#include "Communication/Connection.h"
#include "Drivers/USB_Communication/USBCDCD.h"
#include "StateMachines/Initialization/PowerOffSequence.h"
#include "drivers/Flash_Memory/FATFS/ff.h"
#include "drivers/Flash_Memory/FATFS/Control_File_System.h"
#include "drivers/adc_sampling/adc.h"
#include "drivers/Heater/TemperatureSensor.h"
#include "drivers/ADC_Sampling/adc.h"
#include "drivers/Flash_ram/MCU_E2Prom.h"
#include "Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h"
#include "Drivers/I2C_Communication/Head_Card/Fan/fan_click.h"
#include "Drivers/I2C_Communication/Head_Card/Fan/Head_Fan.h"
#include "drivers/Motors/Motor.h"
#include "drivers/FPGA/FPGA_SPI_Comm.h"
#include "Modules/IFS/ifs.h"
#include "Modules/IDS/ids_ex.h"
#include "Modules/Control/MillisecTask.h"
#include "modules/thread/thread_ex.h"
#include <Drivers/I2C_Communication/I2C.h>
#include <Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.h>
#include <Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h>
#include "drivers/adc_sampling/adc.h"
#include <Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.h>
#include <Drivers/I2C_Communication/WHS_Card/WHS_data.h>
#include <Drivers/I2C_Communication/WHS_Card/IO_Ports_TCA9555/WHS_IO.h>
extern float NumberOfRotationPerPassage; // how many rotations per spool passage
//#include "graphics_adapter.h"
extern uint8_t Input_Voltage;
extern uint8_t Test_Read_Buf[4];
extern uint8_t Head_Fan_PWM_Command[2];
extern uint16_t Head_Fan_Tach[2];
void Stub_ProgressRequest(MessageContainer* requestContainer)
{
MessageContainer responseContainer;
ProgressRequest* request = progress_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
//writeLine("Progress Request...");
ProgressResponse response = PROGRESS_RESPONSE__INIT;
// uint8_t high_byte = 0;
// uint8_t low_byte = 0;
uint8_t addr = 0;
uint8_t port = 0;
uint8_t pin = 0;
uint8_t value= 0;
if(request->amount == 0x3E9) // set TCA9555 u3 or u4
{
if (request->delay & 0x8000) // bit15 select the chip address
{
addr = I2CExp2_ADDRESS;
}
else
{
addr = I2CExp1_ADDRESS;
}
if (request->delay & 0x4000) // bit 14 select port 0 or 1
{
port = D_TCA9555_PORT_1;
}
else
{
port = D_TCA9555_PORT_0;
}
pin = ((request->delay & 0x0F00) >> 8); // 8..11
if (request->delay & 0x0001)
{
value = 1;
}
else
{
value = 0;
}
response.progress = Write_WHS_9555_io_value( addr, port, pin, value);
response.has_progress = true;
}
else
if((request->amount == 0xDE) && (request->delay < 8) && (request->delay >= 0)) // read dispenser type + LS status
{
response.progress = ((Dispenser_struct[request->delay].Type) << 8) + Dispenser_struct[request->delay].Status;
response.has_progress = true;
}
else
if(request->amount == 0xAD) //undef AUTO_HOME_DISPENSERS
{
if ((request->delay >=AutoHoming_off )&&(request->delay<=AutoHoming_JobEnd_PowerOn_off ))
IDS_Dispenser_SetAutoHoming_Config(request->delay);
response.progress = 01;
response.has_progress = true;
}
else
if((request->amount == 0x01) && ((request->delay &0x010000) == 0x010000)) //change mode powerset01
{
response.progress = Power_Step_01_Mode(((request->delay &0x00FF00)>>8), request->delay &0x0000FF);
response.has_progress = true;
}
else
if((request->amount == 0xAB) && (request->delay == 0xAB)) //Get pressure with flow (orifice flow meter)
{
response.progress = Calculate_Pitot_Pressure(true);
response.has_progress = true;
}
else
if((request->amount == 0xAB) && (request->delay == 0x0)) //measured sensor voltage without flow (orifice flow meter)
{
response.progress = Calculate_Pitot_Pressure(false);
response.has_progress = true;
}
else
if((request->amount == 0xAC) && (request->delay == 0xAC)) //VAC
{
response.progress = ReadVAC();
response.has_progress = true;
}
else
if(request->amount == 0x0EAD) //Head Card I/O
{
uint8_t Write_Buf[2] = {0,0};
uint8_t Script_Slave_Add = request -> delay >> 16;
Write_Buf[0] = request -> delay >> 8;
Write_Buf[1] = request -> delay & 0x0000FF;
Select_Main_Head_Mux_Channel();
I2C_Write(I2C_ID_HEAD_CARD, Script_Slave_Add, Write_Buf, 2);
delayms(1);
uint8_t Read_Buf[2] = {0,0};
I2C_Read(I2C_ID_HEAD_CARD, Script_Slave_Add + 1, Read_Buf, 2);
response.progress = Read_Buf[1] << 8 | Read_Buf[0];
response.has_progress = true;
}
else
if(request->amount == 0xFEAD) //functions Head Card I/O
{
Select_Main_Head_Mux_Channel();
if((request -> delay & 0xFFF000) == 0xCAF000)//Actuator
{
HeadCard_Actuators_Control((ACTUATORS)((request -> delay & 0x100)>>8), (bool)((request -> delay & 0x10)>>4), (bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
response.progress = HeadCard_Actuators_Status((ACTUATORS)(request -> delay & 0x100)>>8);
response.has_progress = true;
}
else
if((request -> delay & 0xFF0000) == 0xCA0000)//control all heaters
{
if(request -> delay & 0x01)
{
Disconnect_Mixer_and_12_Heaters_Latch();
HeadCard_Control_Heaters((request -> delay & 0xFF00)>>8, TRUE);
Connect_Mixer_and_12_Heaters_Latch();
}
else
HeadCard_Control_Heaters((request -> delay & 0xFF00)>>8, FALSE);
}
}
else
if((request->amount == 0xFAC0) /*&& (request->delay == 0xFAC)*/) //Head Fan control
{
//Head_Fan_PWM_Command[0] = (request->delay & 0xFF) ;
//Test_Head_fan_Click();
Head_Fan_PWM_Control(0, request->delay & 0xFF);
//response.progress = Fan_Click_Info.Product_ID;
response.progress = Head_Fan_Tach[0];
response.has_progress = true;
}
else
if((request->amount == 0xFAC1) /*&& (request->delay == 0xFAC)*/) //Head Fan control
{
Head_Fan_PWM_Control(1, request->delay & 0xFF);
response.progress = Head_Fan_Tach[1];
response.has_progress = true;
}
else
if ((request->amount & 0x0000FFF0) == 0xFAC0) //WHS Fan control
{
uint16_t fan_tacho = 0;
WHS_set_fan_speed(((request->amount & 0x0000000F)-1) , request->delay & 0x000000FF);
WHS_Read_fan_tach(((request->amount & 0x0000000F)-1), &fan_tacho);
response.progress = fan_tacho;
response.has_progress = true;
}
else
if((request->amount == 0x0A) && ((request->delay >= 0) && (request->delay < 8))) //read the midtank calibration
{
response.progress = Initial_Offset_A[request->delay];
response.has_progress = true;
}
else
if((request->amount == 0xB) && ((request->delay >= 0) && (request->delay < 8))) //read the midtank calibration
{
response.progress = Slope_B[request->delay];
response.has_progress = true;
}
else
if((request->amount == 0x5C4E) && (request->delay == 0x5C4E)) //Screw Home Pos dir
{
test_Home_Pos();
}
else
if((request->amount == 0x100) && (request->delay == 0x100)) //head card PT100
{
Test_HeadCard_PT100(TEMP_SENSE_ANALOG_DYEINGH_TEMP1);
//response.progress = (double)Test_Read_Buf[0];
response.progress = (double)Data_ADC_Head;
response.has_progress = true;
}
else
if((request->amount == 0xCF) && (request->delay == 0xCF)) //Create File System on the Drive
{
#ifdef WATCHDOG
ROM_WatchdogResetDisable(WATCHDOG0_BASE);
uint32_t timeout = 0xFFFFFFFFU;
ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout);
#endif
FRESULT iFResult = Init_Flash_File_System(true);
if(iFResult != FR_OK)
{
LOG_ERROR (iFResult, "Error during init Flash File System");
assert(iFResult);
}
#ifdef WATCHDOG
ROM_WatchdogResetEnable(WATCHDOG0_BASE);
timeout = 120000000*3;
ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout);
#endif
}
else
if((request->amount == 0x0C) && (request->delay == 0x0C)) //Get Gas Sensor
{
response.progress = (double)Calculate_Gas_Power_Consumption();
response.has_progress = true;
}
else
if((request->amount == 0xDD) && (request->delay == 0xDD)) //Read Input Voltage
{
LOG_ERROR(request->delay,"CheckAcInputVoltage");
CheckAcInputVoltage();
response.progress = (double)Input_Voltage;
response.has_progress = true;
}
else
if((request->amount == 0x0CE) && (request->delay == 0x0CE)) //Get Gas Sensor
{
LOG_ERROR(request->delay,"FlashInitAndLoad");
FlashInitAndLoad();
response.progress = (double)OK;
response.has_progress = true;
}
else
if(request->amount == 0x0CC) //C�������� V��������� ��������
{
LOG_ERROR(request->delay,"ResponseDemo");
ResponseDemo(request->delay);
response.progress = (double)OK;
response.has_progress = true;
}
else
if(request->amount == 0xE0) //fast refresh for pressure
{
LOG_ERROR(request->delay,"setRapidPressureRead");
setRapidPressureRead(request->delay);
response.progress = (double)OK;
response.has_progress = true;
}
else
if(request->amount == 0xE1) //fast refresh for pressure
{
LOG_ERROR(request->delay,"Starting Dispenser PID");
IDS_Start_Pid_Testing(request->delay);
response.progress = (double)OK;
response.has_progress = true;
}
else
if(request->amount == 0xE2) //fast refresh for pressure
{
LOG_ERROR(request->delay,"Stoping Dispenser PID");
IDS_Stop_Pid_Testing(request->delay);
response.progress = (double)OK;
response.has_progress = true;
}
else
if(request->amount == 0xB1) //fast refresh for pressure
{
LOG_ERROR(request->delay,"Set loading arm center");
Read_Dryer_ENC_Position();
Task_sleep(500);
Read_Dryer_ENC_Position();
Task_sleep(500);
response.progress = (double)MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CENTER,Read_Dryer_ENC_Position(0,0));
response.has_progress = true;
}
else
if(request->amount == 0xB2) //fast refresh for pressure
{
LOG_ERROR(request->delay,"Set loading arm cycles");
response.progress = (double)MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,request->delay);
response.has_progress = true;
}
else
if(request->amount == 0xB3) //fast refresh for pressure
{
LOG_ERROR(request->amount,"keep alive test");
keepalivetest = true;
response.progress = keepalivetest;
response.has_progress = true;
}
else
if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
{
PowerOffInit();
}
else
if(request->amount == 0xF1)
{
LOG_ERROR(request->delay,"NumberOfRotationPerPassage");
NumberOfRotationPerPassage = (float)(request->delay)/1000;
}
else
{
response.has_progress = true;
int i = 0;
for (i = 0; i < request->amount; i++)
{
response.progress = i;
responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size);
uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
size_t container_size = message_container__pack(&responseContainer, container_buffer);
free(responseContainer.data.data);
SendChars((char*)container_buffer, container_size);
//free(container_buffer);
int co = 0;
for (co = 0; co < request->delay; co++)
{
__delay_cycles(1000000);
}
}
}
responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, true, &response, &progress_response__pack, &progress_response__get_packed_size);
uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
size_t container_size = message_container__pack(&responseContainer, container_buffer);
free(responseContainer.data.data);
//writeLine("Progress Completed!");
SendChars((char*)container_buffer, container_size);
//free(container_buffer);
return;
}
