From 0d0031e73f3b51fd0fe41ad8843e6c368f92c121 Mon Sep 17 00:00:00 2001 From: gusenkovs Date: Sat, 8 Oct 2016 15:02:12 +0300 Subject: [PATCH] FSM Clien and Server Beta 1 --- FSM/FSMClientIOCtl.c | 143 ++ FSM/FSMClientProtocol.c | 509 +++++++ FSM/FSMFIFOAudioStream.c | 197 +++ FSM/FSMServerIODev.c | 101 ++ FSM/FSMTreeSetting.c | 179 +++ FSM/FSM_AudioStream.c | 166 +++ FSM/FSM_Beep.c | 56 + FSM/FSM_CCKControl.c | 109 ++ FSM/FSM_CRC.c | 36 + FSM/FSM_Client.c | 470 +++++++ FSM/FSM_Commutator.c | 84 ++ FSM/FSM_Commutator.h | 5 + FSM/FSM_ControlDevice.c | 24 + FSM/FSM_ControlDeviceClass.c | 31 + FSM/FSM_Crypt.c | 70 + FSM/FSM_DeviceProcess.c | 362 +++++ FSM/FSM_E1CAS1.c | 64 + FSM/FSM_E1Device.c | 241 ++++ FSM/FSM_Flash.c | 240 ++++ FSM/FSM_GPIO.c | 283 ++++ FSM/FSM_MN111Device.c | 310 +++++ FSM/FSM_MN825Device.c | 227 +++ FSM/FSM_MN921Device.c | 236 ++++ FSM/FSM_PO06Device.c | 203 +++ FSM/FSM_PO07Device.c | 227 +++ FSM/FSM_PO08Device.c | 226 +++ FSM/FSM_SendSignalToPipe.c | 82 ++ FSM/FSM_SettingClient.c | 182 +++ FSM/FSM_SettingServer.c | 101 ++ FSM/FSM_SkyNet.c | 121 ++ FSM/FSM_SocialAnalytic.c | 132 ++ FSM/FSM_StatisticClient.c | 223 +++ FSM/FSM_StatisticServer.c | 83 ++ FSM/Kconfig | 275 ++++ FSM/Makefile | 33 + Kconfig | 1 + Makefile | 2 +- include/FSM/FSMAudio/FSM_AudioStream.h | 57 + include/FSM/FSMCrypto/FSM_crypt.h | 28 + include/FSM/FSMDevice/FSME1Cas.h | 11 + include/FSM/FSMDevice/FSMSysCtl.h | 4 + include/FSM/FSMDevice/FSM_DeviceProcess.h | 206 +++ include/FSM/FSMDevice/fcm_audiodeviceclass.h | 365 +++++ include/FSM/FSMDevice/fcmprotocol.h | 1295 ++++++++++++++++++ include/FSM/FSMDevice/fsm_electrodevice.h | 21 + include/FSM/FSMDevice/fsm_statusstruct.h | 322 +++++ include/FSM/FSMEthernet/FSMEthernetHeader.h | 39 + include/FSM/FSMSetting/FSM_settings.h | 90 ++ include/FSM/FSM_Client/FSM_client.h | 79 ++ include/FSM/FSM_Commutator/FSM_Commutator.h | 29 + include/FSM/FSM_SA/FSM_SA.h | 37 + include/FSM/FSM_Switch/fsm_switch.h | 44 + 52 files changed, 8660 insertions(+), 1 deletion(-) create mode 100644 FSM/FSMClientIOCtl.c create mode 100644 FSM/FSMClientProtocol.c create mode 100644 FSM/FSMFIFOAudioStream.c create mode 100644 FSM/FSMServerIODev.c create mode 100644 FSM/FSMTreeSetting.c create mode 100644 FSM/FSM_AudioStream.c create mode 100644 FSM/FSM_Beep.c create mode 100644 FSM/FSM_CCKControl.c create mode 100644 FSM/FSM_CRC.c create mode 100644 FSM/FSM_Client.c create mode 100644 FSM/FSM_Commutator.c create mode 100644 FSM/FSM_Commutator.h create mode 100644 FSM/FSM_ControlDevice.c create mode 100644 FSM/FSM_ControlDeviceClass.c create mode 100644 FSM/FSM_Crypt.c create mode 100644 FSM/FSM_DeviceProcess.c create mode 100644 FSM/FSM_E1CAS1.c create mode 100644 FSM/FSM_E1Device.c create mode 100644 FSM/FSM_Flash.c create mode 100644 FSM/FSM_GPIO.c create mode 100644 FSM/FSM_MN111Device.c create mode 100644 FSM/FSM_MN825Device.c create mode 100644 FSM/FSM_MN921Device.c create mode 100644 FSM/FSM_PO06Device.c create mode 100644 FSM/FSM_PO07Device.c create mode 100644 FSM/FSM_PO08Device.c create mode 100644 FSM/FSM_SendSignalToPipe.c create mode 100644 FSM/FSM_SettingClient.c create mode 100644 FSM/FSM_SettingServer.c create mode 100644 FSM/FSM_SkyNet.c create mode 100644 FSM/FSM_SocialAnalytic.c create mode 100644 FSM/FSM_StatisticClient.c create mode 100644 FSM/FSM_StatisticServer.c create mode 100644 FSM/Kconfig create mode 100644 FSM/Makefile create mode 100644 include/FSM/FSMAudio/FSM_AudioStream.h create mode 100644 include/FSM/FSMCrypto/FSM_crypt.h create mode 100644 include/FSM/FSMDevice/FSME1Cas.h create mode 100644 include/FSM/FSMDevice/FSMSysCtl.h create mode 100644 include/FSM/FSMDevice/FSM_DeviceProcess.h create mode 100644 include/FSM/FSMDevice/fcm_audiodeviceclass.h create mode 100644 include/FSM/FSMDevice/fcmprotocol.h create mode 100644 include/FSM/FSMDevice/fsm_electrodevice.h create mode 100644 include/FSM/FSMDevice/fsm_statusstruct.h create mode 100644 include/FSM/FSMEthernet/FSMEthernetHeader.h create mode 100755 include/FSM/FSMSetting/FSM_settings.h create mode 100644 include/FSM/FSM_Client/FSM_client.h create mode 100644 include/FSM/FSM_Commutator/FSM_Commutator.h create mode 100644 include/FSM/FSM_SA/FSM_SA.h create mode 100644 include/FSM/FSM_Switch/fsm_switch.h diff --git a/FSM/FSMClientIOCtl.c b/FSM/FSMClientIOCtl.c new file mode 100644 index 00000000000000..36a3f6b2601848 --- /dev/null +++ b/FSM/FSMClientIOCtl.c @@ -0,0 +1,143 @@ +/*! +\file +\brief Модуль командного управления +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#define SUCCESS 0 + +#include +#include +#include +#include + +#include "FSM/FSMAudio/FSM_AudioStream.h" +#include +#include "FSM/FSMDevice/fcmprotocol.h" +#include "FSM/FSMDevice/fcm_audiodeviceclass.h" +#include "FSM/FSMDevice/FSM_DeviceProcess.h" +#include "FSM/FSMSetting/FSM_settings.h" +#include "FSM/FSMDevice/fsm_statusstruct.h" +#include "FSM/FSM_Client/FSM_client.h" + +struct FSM_SendCmdUserspace FSM_CIO_fsmdat; +struct fsm_ioctl_struct fsmioctl[FSM_IOCTLTreeSize]; +static dev_t FSM_CIO_first; // Global variable for the first device number +static struct cdev FSM_CIO_c_dev; // Global variable for the character device structure +static struct class* FSM_CIO_cl; // Global variable for the device class + +struct fsm_ioctl_struct* FSM_RegisterIOCtl(unsigned int id, IOClientProcess Handler) +{ + int i; + for(i = 0; i < FSM_IOCTLTreeSize; i++) { + if(fsmioctl[i].reg == 0) { + fsmioctl[i].reg = 1; + fsmioctl[i].id = id; + fsmioctl[i].Handler = Handler; + return &fsmioctl[i]; + } + } + return 0; +} +EXPORT_SYMBOL(FSM_RegisterIOCtl); + +struct fsm_ioctl_struct* FSM_FindIOCtl(unsigned int id) +{ + int i; + for(i = 0; i < FSM_IOCTLTreeSize; i++) { + if((fsmioctl[i].reg == 1) && (fsmioctl[i].id == id)) { + return &fsmioctl[i]; + } + } + return 0; +} +EXPORT_SYMBOL(FSM_FindIOCtl); + +void FSM_DeleteIOCtl(unsigned int id) +{ + struct fsm_ioctl_struct* evnt = FSM_FindIOCtl(id); + if(evnt != 0) + evnt->reg = 0; +} +EXPORT_SYMBOL(FSM_DeleteIOCtl); + +static int device_open(struct inode* inode, struct file* file) +{ + // printk( KERN_INFO "FSM SDEvOpen\n" ); + return SUCCESS; +} + +static int device_release(struct inode* inode, struct file* file) +{ + // printk( KERN_INFO "FSM SDEvClose\n" ); + return SUCCESS; +} + +long device_ioctl(struct file* f, unsigned int cmd, unsigned long arg) +{ + struct fsm_ioctl_struct* dftv; + switch(cmd) { + case FSMIOCTL_SendData: + + if(copy_from_user(&FSM_CIO_fsmdat, (void*)arg, sizeof(struct FSM_SendCmdUserspace))) + return -EFAULT; + dftv = FSM_FindIOCtl(FSM_CIO_fsmdat.IDDevice); + if(dftv != 0) { + dftv->Handler((char*)&FSM_CIO_fsmdat, sizeof(struct FSM_SendCmdUserspace), dftv); + printk(KERN_INFO "FSM SIOCTL\n"); + printk(((struct SendSignalStruct*)FSM_CIO_fsmdat.Data)->pipe); + } + FSM_CIO_fsmdat.opcode = PacketToUserSpace; + if(copy_to_user((void*)arg, &FSM_CIO_fsmdat, sizeof(struct FSM_SendCmdUserspace))) + return -EFAULT; + + break; + default: + return -ENOTTY; + } + return 0; +} + +static struct file_operations fops = { .open = device_open, .release = device_release, .unlocked_ioctl = device_ioctl }; + +static int __init FSM_CSIOCTLModule_init(void) +{ + if(alloc_chrdev_region(&FSM_CIO_first, 0, 1, "fsmr") < 0) + return -1; + if((FSM_CIO_cl = class_create(THIS_MODULE, "fsm")) == NULL) { + unregister_chrdev_region(FSM_CIO_first, 1); + return -1; + } + if(device_create(FSM_CIO_cl, NULL, FSM_CIO_first, NULL, "fsmio") == NULL) { + class_destroy(FSM_CIO_cl); + unregister_chrdev_region(FSM_CIO_first, 1); + return -1; + } + cdev_init(&FSM_CIO_c_dev, &fops); + if(cdev_add(&FSM_CIO_c_dev, FSM_CIO_first, 1) == -1) { + device_destroy(FSM_CIO_cl, FSM_CIO_first); + class_destroy(FSM_CIO_cl); + unregister_chrdev_region(FSM_CIO_first, 1); + return -1; + } + printk(KERN_INFO "FSM SIOCTL module loaded\n"); + return 0; +} + +static void __exit FSM_CSIOCTLModule_exit(void) +{ + cdev_del(&FSM_CIO_c_dev); + device_destroy(FSM_CIO_cl, FSM_CIO_first); + class_destroy(FSM_CIO_cl); + unregister_chrdev_region(FSM_CIO_first, 1); + + printk(KERN_INFO "FSM SIOCTL module unloaded\n"); +} +module_init(FSM_CSIOCTLModule_init); +module_exit(FSM_CSIOCTLModule_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM CSIOCTL Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSMClientProtocol.c b/FSM/FSMClientProtocol.c new file mode 100644 index 00000000000000..3b9ea866295fa5 --- /dev/null +++ b/FSM/FSMClientProtocol.c @@ -0,0 +1,509 @@ +/*! +\file +\brief Модуль взаимодествия с Ethernet +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +#include + +//struct sock* nl_sk = NULL; +struct FSM_DeviceFunctionTree FSM_Ethernet_dft; +struct FSM_DeviceTree* FSM_Ethernet_dt; +struct fsm_ethernet_dev FSM_Ethernet_fsdev[FSM_EthernetDeviceTreeSize]; +struct FSM_SendCmd FSM_Ethernet_fsmsc; +struct fsm_ethernet_dev FSM_Ethernet_fsdev2; +FSM_StreamProcessSend FSM_AudioStreamCallback; + +static int packet_direct_xmit(struct sk_buff* skb) +{ + struct net_device* dev = skb->dev; + netdev_features_t features; + struct netdev_queue* txq; + int ret = NETDEV_TX_BUSY; + + if(unlikely(!netif_running(dev) || !netif_carrier_ok(dev))) + goto drop; + + features = netif_skb_features(skb); + if(skb_needs_linearize(skb, features) && __skb_linearize(skb)) + goto drop; + + txq = skb_get_tx_queue(dev, skb); + + local_bh_disable(); + + HARD_TX_LOCK(dev, txq, smp_processor_id()); + if(!netif_xmit_frozen_or_drv_stopped(txq)) + ret = netdev_start_xmit(skb, dev, txq, false); + HARD_TX_UNLOCK(dev, txq); + + local_bh_enable(); + + if(!dev_xmit_complete(ret)) + kfree_skb(skb); + + return ret; +drop: + atomic_long_inc(&dev->tx_dropped); + kfree_skb(skb); + return NET_XMIT_DROP; +} + +unsigned int FSM_Send_Ethernet_Package(void* data, int len, struct fsm_ethernet_dev* fsmdev) +{ + + struct net_device* dev; + struct sk_buff* skb; + int hlen; + int tlen; + + if(fsmdev == 0) + return 1; + dev = fsmdev->dev; + tlen = dev->needed_tailroom; + hlen = LL_RESERVED_SPACE(dev); + // skb = alloc_skb(len + hlen + tlen, GFP_ATOMIC); + skb = dev_alloc_skb(len + hlen + tlen); + if(skb == NULL) { + printk(KERN_INFO "SKB Eror\n"); + goto out; + } + skb_reserve(skb, hlen); + skb->dev = dev; + // skb->protocol = fsmdev.eth.h_proto; + skb_reset_network_header(skb); + memcpy(skb_put(skb, len), data, len); + if(dev_hard_header(skb, dev, __constant_htons(FSM_PROTO_ID_R), fsmdev->destmac, dev->dev_addr, skb->len) < 0) + goto out; + packet_direct_xmit(skb); +//надо чистить буфер + return 0; + +out: + kfree_skb(skb); + return 0; +} +EXPORT_SYMBOL(FSM_Send_Ethernet_Package); + +unsigned int FSM_Send_Ethernet_Package2(void* data, int len, int id) +{ + + return FSM_Send_Ethernet_Package(data, len, &FSM_Ethernet_fsdev[id]); +} +EXPORT_SYMBOL(FSM_Send_Ethernet_Package2); + +int FSM_RegisterEthernetDevice(struct FSM_DeviceRegistr* fsmrg, struct net_device* dev, char* mac) +{ + int newr = 1; + int i = 0; + for(i = 0; i < FSM_EthernetDeviceTreeSize; i++) { + if((fsmrg->IDDevice == FSM_Ethernet_fsdev[i].id) && (FSM_Ethernet_fsdev[i].reg == 1)) { + FSM_Ethernet_fsdev[i].reg = 0; + newr = 0; + } + } + for(i = 0; i < FSM_EthernetDeviceTreeSize; i++) { + if(FSM_Ethernet_fsdev[i].reg == 0) { + FSM_Ethernet_fsdev[i].dev = dev; + FSM_Ethernet_fsdev[i].id = fsmrg->IDDevice; + FSM_Ethernet_fsdev[i].reg = 1; + FSM_Ethernet_fsdev[i].numdev = i; + memcpy(FSM_Ethernet_fsdev[i].destmac, mac, 6); + if(newr) + printk(KERN_INFO "FSM Ethernet Device Registred %u \n", fsmrg->IDDevice); + return 0; + } + } + + return 2; +} +struct fsm_ethernet_dev* FSM_FindEthernetDevice(unsigned short id) +{ + int i; + for(i = 0; i < FSM_EthernetDeviceTreeSize; i++) { + if((id == FSM_Ethernet_fsdev[i].id) && (FSM_Ethernet_fsdev[i].reg == 1)) + return &FSM_Ethernet_fsdev[i]; + } + + return 0; +} +EXPORT_SYMBOL(FSM_FindEthernetDevice); + +int FSM_DeleteEthernetDevice(unsigned short id) +{ + + int i; + for(i = 0; i < FSM_EthernetDeviceTreeSize; i++) { + if((id == FSM_Ethernet_fsdev[i].id) && (FSM_Ethernet_fsdev[i].reg == 1)) { + FSM_Ethernet_fsdev[i].reg = 0; + printk(KERN_INFO "FSM Ethernet Device UnRegistred %u \n", id); + return 0; + } + } + + return 1; +} +void FSM_EthernetSendPckt(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + struct fsm_ethernet_dev* fsmsd; + struct fsm_ethernet_dev fsdev2; + fsmsd = 0; + if(to_dt != 0) + fsmsd = FSM_FindEthernetDevice(from_dt->IDDevice); + else + fsmsd = 0; + + if(fsmsd == 0) { + fsdev2.numdev = 1; + memset(fsdev2.destmac, 0xFF, 6); + fsdev2.dev = first_net_device(&init_net); + while(fsdev2.dev) { + FSM_Send_Ethernet_Package(data, len, &fsdev2); + fsdev2.dev = next_net_device(fsdev2.dev); + } + // printk(KERN_INFO "FSM Ethernet Not Registred. Use Broacast \n"); + return; + } + // printk( KERN_INFO "FSM Send %u \n",len); + + FSM_Send_Ethernet_Package(data, len, fsmsd); +} + +void FSM_RegisterAudioStreamCallback(FSM_StreamProcessSend FSM_ASC) +{ + FSM_AudioStreamCallback = FSM_ASC; +} +EXPORT_SYMBOL(FSM_RegisterAudioStreamCallback); + +FSM_ADSendEthPack FSM_GetAudioStreamCallback(void) +{ + return FSM_Send_Ethernet_Package2; +} +EXPORT_SYMBOL(FSM_GetAudioStreamCallback); + +int +FSMClientProtocol_pack_rcv(struct sk_buff* skb, struct net_device* dev, struct packet_type* pt, struct net_device* odev) +{ + struct FSM_DeviceTree* dftv; + + char dats = ((char*)skb->data)[0]; + struct ethhdr* eth = eth_hdr(skb); + if(skb->pkt_type == PACKET_OTHERHOST || skb->pkt_type == PACKET_LOOPBACK) + goto clear; + + // printk( KERN_ERR "RegDev %u\n",dats); + switch(dats) { + case RegDevice: ///< Регистрация устройства + + if(FSM_RegisterEthernetDevice((struct FSM_DeviceRegistr*)skb->data, dev, eth->h_source) == 0) { + if(FSM_DeviceRegister(*((struct FSM_DeviceRegistr*)skb->data)) != 0) + goto clear; + } + dftv = FSM_FindDevice(((struct FSM_DeviceRegistr*)skb->data)->IDDevice); + if(dftv == 0) { + printk(KERN_INFO "Eror \n"); + goto clear; + } + // printk( KERN_INFO "FSM Dev %u\n",((struct FSM_SendCmdTS *)skb->data)->IDDevice); + dftv->TrDev = FSM_Ethernet_dt; + dftv->dt->Proc((char*)skb->data, sizeof(struct FSM_DeviceRegistr), dftv, FSM_Ethernet_dt); + ((struct FSM_DeviceRegistr*)skb->data)->opcode = AnsRegDevice; + FSM_Send_Ethernet_Package(skb->data, + sizeof(struct FSM_DeviceRegistr), + FSM_FindEthernetDevice(((struct FSM_DeviceRegistr*)skb->data)->IDDevice)); + + break; + case AnsRegDevice: ///< Подтверждение регистрации + break; + case DelLisr: ///< Удаление устройства из списка + dftv = FSM_FindDevice(((struct FSM_DeviceDelete*)skb->data)->IDDevice); + if(dftv == 0) { + printk(KERN_INFO "Eror \n"); + goto clear; + } + // printk( KERN_INFO "FSM Dev %u\n",((struct FSM_SendCmdTS *)skb->data)->IDDevice); + dftv->dt->Proc((char*)skb->data, sizeof(struct FSM_DeviceDelete), dftv, FSM_Ethernet_dt); + FSM_DeRegister(*((struct FSM_DeviceDelete*)skb->data)); + ((struct FSM_DeviceDelete*)skb->data)->opcode = AnsDelList; + FSM_Send_Ethernet_Package(skb->data, + sizeof(struct FSM_DeviceDelete), + FSM_FindEthernetDevice(((struct FSM_DeviceDelete*)skb->data)->IDDevice)); + FSM_DeleteEthernetDevice(((struct FSM_DeviceDelete*)skb->data)->IDDevice); + + break; + case AnsDelList: ///< Подтверждение удаления устройства из списка + break; + case AnsPing: + dftv = FSM_FindDevice(((struct FSM_Ping*)skb->data)->IDDevice); + if(dftv == 0) { + printk(KERN_INFO "Eror \n"); + goto clear; + } + dftv->dt->Proc((char*)skb->data, sizeof(struct FSM_Ping), dftv, FSM_Ethernet_dt); + break; + case FSMPing: ///< Пинг + ((struct FSM_Ping*)skb->data)->opcode = AnsPing; + FSM_Send_Ethernet_Package( + skb->data, sizeof(struct FSM_Ping*), FSM_FindEthernetDevice(((struct FSM_Ping*)skb->data)->IDDevice)); + break; + case SendCmdToDevice: ///< Отправка команды устройству + goto clear; + break; + case AnsSendCmdToDevice: ///< Подтверждение приёма команды устройством + break; + case RqToDevice: ///< Ответ на команду устройством + break; + case AnsRqToDevice: ///< Подтверждение приёма команды сервером + break; + case SendCmdToServer: ///< Отправка команды серверу + dftv = FSM_FindDevice(((struct FSM_SendCmdTS*)skb->data)->IDDevice); + if(dftv == 0) { + printk(KERN_INFO "Eror \n"); + FSM_Ethernet_fsmsc.cmd = FSMNotRegistred; + FSM_Ethernet_fsmsc.CRC = 0; + FSM_Ethernet_fsmsc.countparam = 0; + FSM_Ethernet_fsmsc.IDDevice = ((struct FSM_SendCmdTS*)skb->data)->IDDevice; + FSM_Ethernet_fsmsc.opcode = SendCmdGlobalcmdToClient; + memset(FSM_Ethernet_fsdev2.destmac, 0xFF, 6); + FSM_Ethernet_fsdev2.id = ((struct FSM_SendCmdTS*)skb->data)->IDDevice; + FSM_Ethernet_fsdev2.numdev = 1; + FSM_Ethernet_fsdev2.dev = dev; + FSM_Send_Ethernet_Package(&FSM_Ethernet_fsmsc, sizeof(struct FSM_SendCmd) - sizeof(FSM_Ethernet_fsmsc.Data), &FSM_Ethernet_fsdev2); + + goto clear; + } + // printk( KERN_INFO "FSM Dev %u\n",((struct FSM_SendCmdTS *)skb->data)->IDDevice); + dftv->dt->Proc((char*)skb->data, skb->len, dftv, FSM_Ethernet_dt); + ((struct FSM_SendCmdTS*)skb->data)->opcode = AnsRqToDevice; + FSM_Send_Ethernet_Package(skb->data, + FSMH_Header_Size_AnsAnsCmd, + FSM_FindEthernetDevice(((struct FSM_SendCmdTS*)skb->data)->IDDevice)); + break; + case SendTxtMassage: ///< Отправка текстового сообщения + dftv = FSM_FindDevice(((struct FSM_Header*)skb->data)->IDDevice); + if(dftv == 0) { + goto clear; + } + dftv->dt->Proc((char*)skb->data, skb->len, dftv, FSM_Ethernet_dt); + goto clear; + break; + case AnsSendTxtMassage: ///< Подтверждение приёма текстового сообщения + break; + case SendTxtEncMassage: ///< Отправка зашифрованного текстового сообщения + break; + case AnsSendTxtEncMassage: ///< Подтверждение приёма зашифрованного текстового сообщения + break; + case SendAudio: ///< Передача аудио данных + // printk( KERN_INFO "FSM ID %u\n",((struct FSM_SendAudioData*)skb->data)->IDDevice); + if((FSM_AudioStreamCallback != 0) && + (((struct FSM_SendAudioData*)skb->data)->IDDevice < FSM_AudioStreamDeviceTreeSize)) + FSM_AudioStreamCallback(((struct FSM_SendAudioData*)skb->data)->IDDevice, skb->data, skb->len); + goto clear; + break; + case SendVideo: ///< Передача видео данных + break; + case SendBinData: ///< Передача бинарных данных + break; + case AnsSendBinData: ///< Подтверждение приёма бинарных данных + break; + case SendSMS: ///< Отправить СМС + break; + case SendAnsSMS: ///< Подтверждение СМС + break; + case SendSMStoDev: ///< Передача СМС устройству + break; + case SendAnsSMStoDev: ///< Подтверждение СМС устройством + break; + case SendEncSMS: ///< Отправить зашифрованного СМС + break; + case SendAnsEncSMS: ///<Подтверждение зашифрованного СМС + break; + case SendEncSMStoDev: ///< Отправить зашифрованного СМС устройству + break; + case SendAnsEncSMStoDev: ///< Подтверждение зашифрованного СМС устройства + break; + case SendEmail: ///< Отправка email + break; + case AnsEmail: ///<Подтверждение email + break; + case SendEmailtoDevice: ///<Передача email устройству + break; + case AnsSendEmailtoDevice: ///<Подтверждение email устройством + break; + case SendEncEmail: ///<Отправить зашифрованного email + break; + case AnsEncEmail: ///<Подтверждение зашифрованного email + break; + case SendEncEmailtoDev: ///< Отправить зашифрованного email устройству + break; + case AnsEncEmailtoDev: ///< Подтверждение зашифрованного email устройства + break; + case SocSend: ///< Отправка сообщение в социальную сеть + break; + case AnsSocSend: ///< Подтверждение сообщения в социальную сеть + break; + case SocSendtoDev: ///< Передача сообщения в социальную сеть устройству + break; + case AnsSocSendtoDev: ///< Подтверждение сообщения в социальную сеть устройством + break; + case SocEncSend: ///< Отправить зашифрованного сообщения в социальную сеть + break; + case AnsSocEncSend: ///< Подтверждение зашифрованного сообщения в социальную сеть + break; + case SocEncSendtoDev: ///< Отправить зашифрованного сообщения в социальную сеть устройству + break; + case AnsSocEncSendtoDev: ///< Подтверждение зашифрованного сообщения в социальную сеть устройства + break; + case Alern: ///<Тревога + printk(KERN_ALERT "%u:Alerm\n", ((struct FSM_Header*)(skb->data))->IDDevice); + FSM_GPIO_EventEror(); + dftv = FSM_FindDevice(((struct FSM_Header*)skb->data)->IDDevice); + if(dftv == 0) { + printk(KERN_INFO "Eror \n"); + goto clear; + } + // printk( KERN_INFO "FSM Dev %u\n",((struct FSM_SendCmdTS *)skb->data)->IDDevice); + dftv->dt->Proc((char*)skb->data, FSMH_Header_Size_AlernSignal, dftv, FSM_Ethernet_dt); + break; + case Warning: ///<Предупреждение + // FSM_GPIO_EventEror(); + printk(KERN_WARNING "%u:Warning\n", ((struct FSM_Header*)(skb->data))->IDDevice); + dftv = FSM_FindDevice(((struct FSM_Header*)skb->data)->IDDevice); + if(dftv == 0) { + printk(KERN_INFO "Eror \n"); + goto clear; + } + // printk( KERN_INFO "FSM Dev %u\n",((struct FSM_SendCmdTS *)skb->data)->IDDevice); + dftv->dt->Proc((char*)skb->data, FSMH_Header_Size_WarningSignal, dftv, FSM_Ethernet_dt); + break; + + case Trouble: ///<Сбой + FSM_GPIO_EventEror(); + printk(KERN_ERR "%u:Troubles\n", ((struct FSM_Header*)(skb->data))->IDDevice); + dftv = FSM_FindDevice(((struct FSM_Header*)skb->data)->IDDevice); + if(dftv == 0) { + printk(KERN_INFO "Eror \n"); + goto clear; + } + // printk( KERN_INFO "FSM Dev %u\n",((struct FSM_SendCmdTS *)skb->data)->IDDevice); + dftv->dt->Proc((char*)skb->data, FSMH_Header_Size_TroubleSignal, dftv, FSM_Ethernet_dt); + break; + case Beep: ///<Звук + FSM_Beep(3000, 300); + break; + case SendCmdGlobalcmdToServer: + switch(((struct FSM_SendCmdTS*)skb->data)->cmd) { + case FSMGetCmdStream: + dftv = FSM_FindDevice(((struct FSM_Header*)skb->data)->IDDevice); + if(dftv != 0) { + ((struct FSM_SendCmdTS*)skb->data)->opcode = SendCmdGlobalcmdToClient; + ((struct FSM_SendCmdTS*)skb->data)->cmd = AnsFSMGetCmdStream; + ((int*)(((struct FSM_SendCmdTS*)skb->data)->Data))[0] = FSM_ToCmdStream(dftv); + FSM_Send_Ethernet_Package(skb->data, + FSMH_Header_Size_AnsAnsCmd, + FSM_FindEthernetDevice(((struct FSM_SendCmdTS*)skb->data)->IDDevice)); + } + break; + case FSMFlash_Start: + case FSMFlash_Execute: + case FSMFlash_Confirm: + case FSMFlash_Data: + dftv = FSM_FindDevice(((struct FSM_Header*)skb->data)->IDDevice); + if(dftv==0) goto clear; + FSM_FlashRecive(skb->data,sizeof(struct FSM_SendCmdTS),dftv); + break; + } + break; + + case SendCmdToServerStream: ///< Отправка команды серверу + FSM_ToProcess(((struct FSM_Header*)skb->data)->IDDevice, (char*)skb->data, skb->len, FSM_Ethernet_dt); + break; + + case Ans_FSM_Setting_Read: + case Ans_FSM_Setting_Write: + case Ans_FSM_Setting_GetTree: + dftv = FSM_FindDevice(((struct FSM_Header*)skb->data)->IDDevice); + if(dftv == 0) + goto clear; + FSM_TreeRecive((char*)skb->data, skb->len, dftv); + goto clear; + break; + } + +/*fsdev.destmac[0]=0xa0; + fsdev.destmac[1]=0xa1; + fsdev.destmac[2]=0xa2; + fsdev.destmac[3]=0xa3; + fsdev.destmac[4]=0xa4; + fsdev.destmac[5]=0xa5;*/ + +// printk( KERN_ERR "packet received with length: %u\n", skb->len ); + +// FSM_Send_Ethernet_Package(odev,dts,3,fsdev); + +clear: + kfree_skb(skb); + return skb->len; +}; + +static struct packet_type FSMClientProtocol_proto = { + .type = cpu_to_be16(FSM_PROTO_ID), // may be: __constant_htons( TEST_PROTO_ID ), + .func = FSMClientProtocol_pack_rcv, +}; + +static int __init FSMClientProtocol_init(void) +{ + struct FSM_DeviceRegistr regp; + dev_add_pack(&FSMClientProtocol_proto); + FSM_Ethernet_dft.type = (unsigned char)Network; + FSM_Ethernet_dft.VidDevice = (unsigned char)Ethernet; + FSM_Ethernet_dft.PodVidDevice = (unsigned char)WireEthernet; + FSM_Ethernet_dft.KodDevice = (unsigned char)StandartEthernet; + FSM_Ethernet_dft.Proc = FSM_EthernetSendPckt; + FSM_Ethernet_dft.config_len = 0; + FSM_DeviceClassRegister(FSM_Ethernet_dft); + + regp.IDDevice = FSM_EthernetID2; + regp.VidDevice = FSM_Ethernet_dft.VidDevice; + regp.PodVidDevice = FSM_Ethernet_dft.PodVidDevice; + regp.KodDevice = FSM_Ethernet_dft.KodDevice; + regp.type = FSM_Ethernet_dft.type; + regp.opcode = RegDevice; + regp.CRC = 0; + FSM_DeviceRegister(regp); + FSM_Ethernet_dt = FSM_FindDevice(FSM_EthernetID2); + FSM_Statstic_SetStatus(FSM_Ethernet_dt, "ok"); + if(FSM_Ethernet_dt == 0) + return 1; + memset(FSM_Ethernet_fsdev, 0, sizeof(FSM_Ethernet_fsdev)); + FSM_SendEventToAllDev(FSM_EthernetStarted); + printk(KERN_INFO "FSMClientProtocol module loaded\n"); + + return 0; +} + +static void __exit FSMClientProtocol_exit(void) +{ + struct FSM_DeviceDelete delp; + dev_remove_pack(&FSMClientProtocol_proto); + delp.IDDevice = FSM_EthernetID2; + delp.opcode = DelLisr; + delp.CRC = 0; + FSM_DeRegister(delp); + FSM_ClassDeRegister(FSM_Ethernet_dft); + printk(KERN_INFO "FSMClientProtocol module unloaded\n"); +} + +module_init(FSMClientProtocol_init); +module_exit(FSMClientProtocol_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM Protocol Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSMFIFOAudioStream.c b/FSM/FSMFIFOAudioStream.c new file mode 100644 index 00000000000000..224bc85126699d --- /dev/null +++ b/FSM/FSMFIFOAudioStream.c @@ -0,0 +1,197 @@ + +#include +#include +#include +#include "FSM/FSMDevice/fcmprotocol.h" +#include "FSM/FSMDevice/fcm_audiodeviceclass.h" +#include "FSM/FSMDevice/FSM_DeviceProcess.h" +#include "FSM/FSMSetting/FSM_settings.h" +#include "FSM/FSMAudio/FSM_AudioStream.h" +#include "FSM/FSMEthernet/FSMEthernetHeader.h" + +struct FSM_FIFOAS fsmfifoas[FSM_FIFOAudioStreamDeviceTreeSize]; +struct FSM_SendAudioData sad; + +#ifdef DEBUG_CALL_STACK +uint64_t debug_this3; +extern uint64_t debug_global; +#define DEBUG_CALL_STACK_SetStack debug_this3 = (debug_this3 << 8) +#define DEBUG_CALL_STACK_THIS 3 +#define DEBUG_CALL_STACK_GLOBSET debug_global = (debug_global << 8) | (DEBUG_CALL_STACK_THIS); + +typedef enum debug_function { + init_on = 0x00, + init_off = 0x01, + exit_on = 0x02, + exit_off = 0x03, + get_astb_init = 0x04, + get_astb_exit = 0x05, + get_asr_init = 0x06, + get_asr_exit = 0x07, + get_asw_init = 0x08, + get_asw_exit = 0x09, + get_asre_init = 0x10, + get_asre_exit = 0x11, + +} debug_fun; +#endif + +void FSM_FIFOAudioStreamTobuffer(char* Data, short len, int id) +{ + int i = 0; + struct FSM_SendAudioData* FSMAPk = (struct FSM_SendAudioData*)Data; + struct FSM_FIFOAS* devfifo = &fsmfifoas[FSM_AudioStreamGetFIFODevice(FSMAPk->IDDevice)]; + +#ifdef DEBUG_CALL_STACK + DEBUG_CALL_STACK_GLOBSET + DEBUG_CALL_STACK_SetStack | (get_astb_init); +#endif + + for(i = 0; i < FSMAPk->len; i++) { + if(devfifo->in_count < 1024) { + devfifo->inBuffer[devfifo->in_writeptr] = FSMAPk->Data[i]; + devfifo->in_writeptr++; + if(devfifo->in_writeptr >= 1024) + devfifo->in_writeptr = 0; + devfifo->in_count++; + } + } + +#ifdef DEBUG_CALL_STACK + DEBUG_CALL_STACK_SetStack | (get_astb_exit); +#endif +} +EXPORT_SYMBOL(FSM_FIFOAudioStreamTobuffer); +int FSM_FIFOAudioStreamRegistr(struct FSM_AudioStream fsmas, unsigned short* idfifo) +{ + int fsmstream, i; + +#ifdef DEBUG_CALL_STACK + DEBUG_CALL_STACK_GLOBSET + DEBUG_CALL_STACK_SetStack | (get_asr_init); +#endif + + fsmas.ToUser = FSM_FIFOAudioStreamTobuffer; + fsmas.TransportDeviceType = FSM_FifoID; + fsmstream = FSM_AudioStreamRegistr(fsmas); + if(fsmstream != -1) { + for(i = 0; i < FSM_FIFOAudioStreamDeviceTreeSize; i++) { + if(fsmfifoas[i].reg == 0) { + fsmfifoas[i].reg = 1; + fsmfifoas[i].streamid = fsmstream; + FSM_AudioStreamSetFIFODevice(fsmstream, i); + *idfifo = i; + return fsmstream; + } + } + } + +#ifdef DEBUG_CALL_STACK + DEBUG_CALL_STACK_SetStack | (get_asr_exit); +#endif + + return -1; +} +EXPORT_SYMBOL(FSM_FIFOAudioStreamRegistr); +void FSM_FIFOAudioStreamWrite(char* Data, short len, unsigned short idfifo) +{ + int i = 0; + +#ifdef DEBUG_CALL_STACK + DEBUG_CALL_STACK_GLOBSET + DEBUG_CALL_STACK_SetStack | (get_asw_init); +#endif + + if(idfifo >= FSM_FIFOAudioStreamDeviceTreeSize) + return; + for(i = 0; i < len; i++) { + fsmfifoas[idfifo].outBuffer[fsmfifoas[idfifo].out_count] = Data[i]; + fsmfifoas[idfifo].out_count++; + if(fsmfifoas[idfifo].out_count >= 160) { + sad.IDDevice = fsmfifoas[idfifo].streamid; + sad.len = 160; + memcpy(sad.Data, fsmfifoas[idfifo].outBuffer, sad.len); + FSM_AudioStreamToProcess( + fsmfifoas[idfifo].streamid, (char*)&sad, sizeof(struct FSM_SendAudioData) - sizeof(sad.Data) + sad.len); + fsmfifoas[idfifo].out_count -= 160; + } + } + +#ifdef DEBUG_CALL_STACK + DEBUG_CALL_STACK_SetStack | (get_asw_exit); +#endif +} +EXPORT_SYMBOL(FSM_FIFOAudioStreamWrite); +int FSM_FIFOAudioStreamRead(char* Data, unsigned short count, unsigned short idfifo) +{ + int i; + +#ifdef DEBUG_CALL_STACK + DEBUG_CALL_STACK_GLOBSET + DEBUG_CALL_STACK_SetStack | (get_asre_init); +#endif + + for(i = 0; i < count; i++) { + if(fsmfifoas[idfifo].in_count > 0) { + Data[i] = fsmfifoas[idfifo].inBuffer[fsmfifoas[idfifo].in_readptr]; + fsmfifoas[idfifo].in_readptr++; + if(fsmfifoas[idfifo].in_readptr >= 1024) + fsmfifoas[idfifo].in_readptr = 0; + fsmfifoas[idfifo].in_count--; + + } else { + Data[i] = 0xff; + } + } + +#ifdef DEBUG_CALL_STACK + DEBUG_CALL_STACK_SetStack | (get_asre_exit); +#endif + + return count; +} +EXPORT_SYMBOL(FSM_FIFOAudioStreamRead); +unsigned short FSM_FIFOAudioStreamGetAS(unsigned short idfifo) +{ + return fsmfifoas[idfifo].streamid; +} +EXPORT_SYMBOL(FSM_FIFOAudioStreamGetAS); + +static int __init FSM_FIFOAudioStream_init(void) +{ + +#ifdef DEBUG_CALL_STACK + DEBUG_CALL_STACK_GLOBSET + DEBUG_CALL_STACK_SetStack | (init_on); +#endif + + memset(fsmfifoas, 0, sizeof(fsmfifoas)); + sad.opcode = SendAudio; + printk(KERN_INFO "FSM FIFO Audio Stream Module loaded\n"); + +#ifdef DEBUG_CALL_STACK + DEBUG_CALL_STACK_SetStack | (init_off); +#endif + return 0; +} + +static void __exit FSM_FIFOAudioStream_exit(void) +{ +#ifdef DEBUG_CALL_STACK + DEBUG_CALL_STACK_GLOBSET + DEBUG_CALL_STACK_SetStack | (exit_on); +#endif + + printk(KERN_INFO "FSM FIFO Audio Stream Module unloaded\n"); + +#ifdef DEBUG_CALL_STACK + DEBUG_CALL_STACK_SetStack | (exit_off); +#endif +} + +module_init(FSM_FIFOAudioStream_init); +module_exit(FSM_FIFOAudioStream_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM FIFO Audio Stream Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSMServerIODev.c b/FSM/FSMServerIODev.c new file mode 100644 index 00000000000000..d1ba72aebdd140 --- /dev/null +++ b/FSM/FSMServerIODev.c @@ -0,0 +1,101 @@ +/*! +\file +\brief Модуль командного управления +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#define SUCCESS 0 + +#include +#include +#include +#include + +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +struct FSM_SendCmdUserspace FSM_ServerIO_fsmdat; + +static dev_t FSM_ServerIO_first; // Global variable for the first device number +static struct cdev FSM_ServerIO_c_dev; // Global variable for the character device structure +static struct class* FSM_ServerIO_cl; // Global variable for the device class + +static int device_open(struct inode* inode, struct file* file) +{ + // printk( KERN_INFO "FSM SIOCTLOpen\n" ); + return SUCCESS; +} + +static int device_release(struct inode* inode, struct file* file) +{ + // printk( KERN_INFO "FSM SIOCTLClose\n" ); + return SUCCESS; +} + +long device_ioctl(struct file* f, unsigned int cmd, unsigned long arg) +{ + struct FSM_DeviceTree* dftv; + + switch(cmd) { + case FSMIOCTL_SendData: + if(copy_from_user(&FSM_ServerIO_fsmdat, (void*)arg, sizeof(struct FSM_SendCmdUserspace))) + return -EFAULT; + dftv = FSM_FindDevice(FSM_ServerIO_fsmdat.IDDevice); + if(dftv != 0) { + dftv->dt->Proc((char*)&FSM_ServerIO_fsmdat, sizeof(struct FSM_SendCmdUserspace), dftv, 0); + if(dftv->debug) + printk(KERN_INFO "FSM SIOCTL, \n"); + } + FSM_ServerIO_fsmdat.opcode = PacketToUserSpace; + if(copy_to_user((void*)arg, &FSM_ServerIO_fsmdat, sizeof(struct FSM_SendCmdUserspace))) + return -EFAULT; + + break; + default: + return -ENOTTY; + } + return 0; +} + +static struct file_operations fops = { .open = device_open, .release = device_release, .unlocked_ioctl = device_ioctl }; + +static int __init FSM_SIOCTLModule_init(void) +{ + if(alloc_chrdev_region(&FSM_ServerIO_first, 0, 1, "fsmr") < 0) + return -1; + if((FSM_ServerIO_cl = class_create(THIS_MODULE, "fsm")) == NULL) { + unregister_chrdev_region(FSM_ServerIO_first, 1); + return -1; + } + if(device_create(FSM_ServerIO_cl, NULL, FSM_ServerIO_first, NULL, "fsmio") == NULL) { + class_destroy(FSM_ServerIO_cl); + unregister_chrdev_region(FSM_ServerIO_first, 1); + return -1; + } + cdev_init(&FSM_ServerIO_c_dev, &fops); + if(cdev_add(&FSM_ServerIO_c_dev, FSM_ServerIO_first, 1) == -1) { + device_destroy(FSM_ServerIO_cl, FSM_ServerIO_first); + class_destroy(FSM_ServerIO_cl); + unregister_chrdev_region(FSM_ServerIO_first, 1); + return -1; + } + printk(KERN_INFO "FSM SIOCTL module loaded\n"); + return 0; +} + +static void __exit FSM_SIOCTLModule_exit(void) +{ + cdev_del(&FSM_ServerIO_c_dev); + device_destroy(FSM_ServerIO_cl, FSM_ServerIO_first); + class_destroy(FSM_ServerIO_cl); + unregister_chrdev_region(FSM_ServerIO_first, 1); + + printk(KERN_INFO "FSM SIOCTL module unloaded\n"); +} +module_init(FSM_SIOCTLModule_init); +module_exit(FSM_SIOCTLModule_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM SIOCTL Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSMTreeSetting.c b/FSM/FSMTreeSetting.c new file mode 100644 index 00000000000000..03913f0ab1909e --- /dev/null +++ b/FSM/FSMTreeSetting.c @@ -0,0 +1,179 @@ +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +struct FSM_DeviceFunctionTree FSMDevSet_dft; +struct SettingTreeInfo FSMDevSetTree[FSM_DeviceSettingTreeSize]; +struct FSM_GetTreeList FSMDevSet_fsmgetts; +struct FSM_SetSetting FSMDevSet_fsmtset; +struct FSM_GetSetting FSMDevSet_fsmtget; +struct FSM_DeviceTree* FSMDevSet_dftv; +void FSM_SendReuestDevTree(struct FSM_DeviceTree* to_dt) +{ + FSMDevSet_fsmgetts.CRC = 0; + FSMDevSet_fsmgetts.IDDevice = to_dt->IDDevice; + FSMDevSet_fsmgetts.opcode = FSM_Setting_GetTree; + to_dt->TrDev->dt->Proc((char*)&FSMDevSet_fsmgetts, FSMH_Header_Size_GetTreeList, to_dt->TrDev, to_dt); +} +EXPORT_SYMBOL(FSM_SendReuestDevTree); + +void FSM_SetTreeAdd(struct FSM_DeviceTree* to_dt) +{ + int i = 0; + for(i = 0; i < FSM_DeviceSettingTreeSize; i++) { + if((FSMDevSetTree[i].id == to_dt->IDDevice) && (FSMDevSetTree[i].reg == 1)) { + FSM_SendReuestDevTree(to_dt); + return; + } + } + for(i = 0; i < FSM_DeviceSettingTreeSize; i++) { + if(FSMDevSetTree[i].reg == 0) { + FSMDevSetTree[i].id = to_dt->IDDevice; + FSMDevSetTree[i].reg = 1; + FSMDevSetTree[i].dt = to_dt; + FSM_SendReuestDevTree(to_dt); + return; + } + } +} +EXPORT_SYMBOL(FSM_SetTreeAdd); + +void FSM_TreeRecive(char* data, short len, struct FSM_DeviceTree* to_dt) +{ + int i; + struct FSM_SetTreeElementFS* fsmtel=((struct FSM_SetTreeElementFS*)(((struct FSM_AnsGetTreeList*)data)->Data)); + struct FSM_AnsGetSetting* fsmtans =(struct FSM_AnsGetSetting*)data; + + switch(data[0]) { + case Ans_FSM_Setting_GetTree: + for(i = 0; i < FSM_DeviceSettingTreeSize; i++) { + if((FSMDevSetTree[i].id == to_dt->IDDevice) && (FSMDevSetTree[i].reg == 1)) + { + FSMDevSetTree[i].type = (char)(((struct FSM_AnsGetTreeList*)data)->size); + + memcpy(&FSMDevSetTree[i].fsmdtl[fsmtel->iid],((struct FSM_AnsGetTreeList*)data)->Data,sizeof(struct FSM_SetTreeElementFS)); + return; + } + } + break; + case Ans_FSM_Setting_Read: + for(i = 0; i < FSM_DeviceSettingTreeSize; i++) { + if((FSMDevSetTree[i].id == to_dt->IDDevice) && (FSMDevSetTree[i].reg == 1)) + { + memcpy(FSMDevSetTree[i].fsm_tr_temp,fsmtans->Data,fsmtans->size); + FSMDevSetTree[i].fsm_tr_size =fsmtans->size; + return; + } + } + break; + } +} +EXPORT_SYMBOL(FSM_TreeRecive); + +void +FSM_SettingTreeControlDeviceRecive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + + struct FSM_SendCmdTS* fscts = (struct FSM_SendCmdTS*)data; + int i; + // printk( KERN_INFO "FSM SIOCTL,%u \n",fscts->opcode ); + + switch(data[0]) { + case RegDevice: + FSM_Statstic_SetStatus(to_dt, "ok"); + break; + case SendCmdToServer: ///< Отправка команды серверу + break; + case PacketFromUserSpace: ///< Отправка команды серверу + switch(fscts->cmd) + { + case FSM_DevTreeSetGet: + i = ((struct FSM_SetTreeGetList*)fscts->Data)->IDDevice; + memcpy(fscts->Data,&FSMDevSetTree[i].fsmdtl[(((struct FSM_SetTreeGetList*)fscts->Data)->iid)],sizeof(struct FSM_SetTreeElementFS)); + break; + case FSM_DevTreeSetGetCount: + for(i = 0; i < FSM_DeviceSettingTreeSize; i++) { + if((FSMDevSetTree[i].id == ((unsigned short*)fscts->Data)[0]) && (FSMDevSetTree[i].reg == 1)) { + ((struct FSM_SetTreeGetListCount*)fscts->Data)->IDDevice=i; + ((struct FSM_SetTreeGetListCount*)fscts->Data)->count=FSMDevSetTree[i].type; + return; + } + } + break; + case FSM_DevTreeSetWrite: + FSMDevSet_fsmtset.IDDevice=((struct FSM_SetTreeWriteElement*)fscts->Data)->id; + FSMDevSet_fsmtset.opcode=FSM_Setting_Write; + strcpy(FSMDevSet_fsmtset.name,((struct FSM_SetTreeWriteElement*)fscts->Data)->name); + memcpy(FSMDevSet_fsmtset.Data,((struct FSM_SetTreeWriteElement*)fscts->Data)->Data,((struct FSM_SetTreeWriteElement*)fscts->Data)->len); + FSMDevSet_dftv = FSM_FindDevice(FSMDevSet_fsmtset.IDDevice); + if(FSMDevSet_dftv == 0) { + printk(KERN_INFO "Eror \n"); + return; + } + FSMDevSet_dftv->TrDev->dt->Proc((char*)&FSMDevSet_fsmtset,sizeof(struct FSM_SetSetting),FSMDevSet_dftv->TrDev,FSMDevSet_dftv); + break; + + case FSM_DevTreeSetReadReqest: + FSMDevSet_fsmtget.IDDevice=((struct FSM_SetTreeReadElement*)fscts->Data)->id; + FSMDevSet_fsmtget.opcode=FSM_Setting_Read; + strcpy(FSMDevSet_fsmtget.name,((struct FSM_SetTreeReadElement *)fscts->Data)->name); + FSMDevSet_dftv = FSM_FindDevice(FSMDevSet_fsmtset.IDDevice); + if(FSMDevSet_dftv == 0) { + printk(KERN_INFO "Eror \n"); + return; + } + FSMDevSet_dftv->TrDev->dt->Proc((char*)&FSMDevSet_fsmtset,sizeof(struct FSM_SetSetting),FSMDevSet_dftv->TrDev,FSMDevSet_dftv); + break; + + case FSM_DevTreeSetReadRead: + for(i = 0; i < FSM_DeviceSettingTreeSize; i++) + { + if((FSMDevSetTree[i].id == ((unsigned short*)fscts->Data)[0]) && (FSMDevSetTree[i].reg == 1)) { + if(FSMDevSetTree[i].fsm_tr_size>0) + { + fscts->countparam=FSMDevSetTree[i].fsm_tr_size; + memcpy(fscts->Data,FSMDevSetTree[i].fsm_tr_temp,FSMDevSetTree[i].fsm_tr_size); + } + else fscts->countparam=0; + return; + } + } + break; + } + break; + + + } +} + +static int __init FSMSetControlDevice_init(void) +{ + struct FSM_DeviceRegistr regp; + FSMDevSet_dft.aplayp = 0; + FSMDevSet_dft.type = (unsigned char)StatisticandConfig; + FSMDevSet_dft.VidDevice = (unsigned char)FSMDeviceConfig; + FSMDevSet_dft.PodVidDevice = (unsigned char)FSM_SettingTree_D; + FSMDevSet_dft.KodDevice = (unsigned char)CTL_FSM_SettingTree_D; + FSMDevSet_dft.Proc = FSM_SettingTreeControlDeviceRecive; + FSMDevSet_dft.config_len = 0; + FSM_DeviceClassRegister(FSMDevSet_dft); + + regp.IDDevice = FSM_TreeSettingID; + regp.VidDevice = FSMDevSet_dft.VidDevice; + regp.PodVidDevice = FSMDevSet_dft.PodVidDevice; + regp.KodDevice = FSMDevSet_dft.KodDevice; + regp.type = FSMDevSet_dft.type; + regp.opcode = RegDevice; + regp.CRC = 0; + FSM_DeviceRegister(regp); + printk(KERN_INFO "FSM Set ControlDevice loaded\n"); + return 0; +} +static void __exit FSMSetControlDevice_exit(void) +{ + FSM_ClassDeRegister(FSMDevSet_dft); + printk(KERN_INFO "FSM Set ControlDevice module unloaded\n"); +} + +module_init(FSMSetControlDevice_init); +module_exit(FSMSetControlDevice_exit); \ No newline at end of file diff --git a/FSM/FSM_AudioStream.c b/FSM/FSM_AudioStream.c new file mode 100644 index 00000000000000..e55f855bb83e94 --- /dev/null +++ b/FSM/FSM_AudioStream.c @@ -0,0 +1,166 @@ +/*! +\file +\brief Модуль управления аудиопотоками +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +FSM_ADSendEthPack FSM_AudioStream_sendpkt; + + +struct FSM_AudioStream FSMASDB[FSM_AudioStreamDeviceTreeSize]; +/* + *unsigned int FSM_AudioStrean_Send_Ethernet_Package(void * data, int len, struct fsm_ethernet_dev *fsmdev) +{ + return FSM_Send_Ethernet_Package2(data,len,fsmdev); +} + */ +int FSM_AudioStreamRegistr(struct FSM_AudioStream fsmas) +{ + int i; + + for(i = 0; i < FSM_AudioStreamDeviceTreeSize; i++) { + if(FSMASDB[i].reg == 0) { + FSMASDB[i].reg = 1; + FSMASDB[i].iddev = fsmas.iddev; + FSMASDB[i].ToProcess = fsmas.ToProcess; + + FSMASDB[i].TransportDevice = fsmas.TransportDevice; + FSMASDB[i].TransportDeviceType = fsmas.TransportDeviceType; + FSMASDB[i].Data = fsmas.Data; + FSMASDB[i].IDConnection = 0xffff; + FSM_AudioStream_sendpkt = FSM_GetAudioStreamCallback(); + switch(fsmas.TransportDeviceType) { + case FSM_EthernetID2: + FSMASDB[i].ToUser = (FSM_StreamProcessUser)FSM_AudioStream_sendpkt; + break; + case FSM_FifoID: + FSMASDB[i].ToUser = fsmas.ToUser; + break; + } + printk(KERN_INFO "Registred Stream %u", i); + + return i; + } + } + return -1; +} +EXPORT_SYMBOL(FSM_AudioStreamRegistr); + +void FSM_AudioStreamUnRegistr(int id) +{ + FSMASDB[id].reg = 0; +} +EXPORT_SYMBOL(FSM_AudioStreamUnRegistr); + +unsigned short FSM_AudioStreamGETIDConnect(int id) +{ + return FSMASDB[id].IDConnection; +} +EXPORT_SYMBOL(FSM_AudioStreamGETIDConnect); + +void FSM_AudioStreamSetIDConnect(int id, unsigned short idcon, char type) +{ + FSMASDB[id].IDConnection = idcon; + FSMASDB[id].typcon = type; +} +EXPORT_SYMBOL(FSM_AudioStreamSetIDConnect); + +char FSM_AudioStreamGETTypeConnect(int id) +{ + return FSMASDB[id].typcon; +} +EXPORT_SYMBOL(FSM_AudioStreamGETTypeConnect); + +void FSM_AudioStreamToUser(int id, char* Data, short len) +{ + if(id == -1) + return; + if(((char*)&FSMASDB[id])[0] == 0) { + // printk( KERN_INFO "NotStreamID TUn" ); + return; + } + if((((char*)&FSMASDB[id])[0] != 0) && (FSMASDB[id].ToUser != 0)) + FSMASDB[id].ToUser(Data, len, FSMASDB[id].TransportDevice); +} +EXPORT_SYMBOL(FSM_AudioStreamToUser); + +void FSM_AudioStreamSetToProcess(int id, FSM_StreamProcessProcess fsmtu) +{ + FSMASDB[id].ToProcess = fsmtu; +} +EXPORT_SYMBOL(FSM_AudioStreamSetToProcess); + +void FSM_AudioStreamToProcess(int id, char* Data, short len) +{ + + if(id == -1) + return; + if(((char*)&FSMASDB[id])[0] == 0) { + // printk( KERN_INFO "NotStreamID TP\n" ); + return; + } + if(FSMASDB[id].ToProcess == 0) + return; + FSMASDB[id].ToProcess(Data, len); +} +EXPORT_SYMBOL(FSM_AudioStreamToProcess); + +int FSM_AudioStreamGetEthernetDevice(int id) +{ + return FSMASDB[id].TransportDevice; +} +EXPORT_SYMBOL(FSM_AudioStreamGetEthernetDevice); + +void FSM_AudioStreamSetEthernetDevice(int id, struct fsm_ethernet_dev* edev) +{ + FSMASDB[id].TransportDevice = edev->numdev; + FSMASDB[id].TransportDeviceType = FSM_EthernetID2; +} +EXPORT_SYMBOL(FSM_AudioStreamSetEthernetDevice); + +void FSM_AudioStreamSetFIFODevice(int id, int edev) +{ + FSMASDB[id].TransportDevice = edev; + FSMASDB[id].TransportDeviceType = FSM_FifoID; +} +EXPORT_SYMBOL(FSM_AudioStreamSetFIFODevice); + +int FSM_AudioStreamGetFIFODevice(int id) +{ + return FSMASDB[id].TransportDevice; +} +EXPORT_SYMBOL(FSM_AudioStreamGetFIFODevice); + +void* FSM_AudioStreamData(int id) +{ + return FSMASDB[id].Data; +} +EXPORT_SYMBOL(FSM_AudioStreamData); + +static int __init FSM_AudioStream_init(void) +{ + + FSM_RegisterAudioStreamCallback((FSM_StreamProcessSend)FSM_AudioStreamToProcess); + memset(FSMASDB, 0, sizeof(FSMASDB)); + printk(KERN_INFO "FSM Audio Stream Module loaded\n"); + + return 0; +} + +static void __exit FSM_AudioStream_exit(void) +{ + printk(KERN_INFO "FSM Audio Stream Module unloaded\n"); +} + +module_init(FSM_AudioStream_init); +module_exit(FSM_AudioStream_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM Audio Stream Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_Beep.c b/FSM/FSM_Beep.c new file mode 100644 index 00000000000000..f3537b3d245617 --- /dev/null +++ b/FSM/FSM_Beep.c @@ -0,0 +1,56 @@ +#include +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +static struct timer_list FSM_Beep_timer; + +void FSM_Beep_timer_callback(unsigned long data) +{ + FSM_Beep(0, 0); +} + +void FSM_Beep(int value, int msec) +{ + unsigned int count = 0; + unsigned long flags; + if(value > 20 && value < 32767) + count = PIT_TICK_RATE / value; + + raw_spin_lock_irqsave(&i8253_lock, flags); + + if(count) { + /* set command for counter 2, 2 byte write */ + outb_p(0xB6, 0x43); + /* select desired HZ */ + outb_p(count & 0xff, 0x42); + outb((count >> 8) & 0xff, 0x42); + /* enable counter 2 */ + outb_p(inb_p(0x61) | 3, 0x61); + mod_timer(&FSM_Beep_timer, jiffies + msecs_to_jiffies(msec)); + } else { + /* disable counter 2 */ + outb(inb_p(0x61) & 0xFC, 0x61); + } + + raw_spin_unlock_irqrestore(&i8253_lock, flags); +} +EXPORT_SYMBOL(FSM_Beep); + +static int __init FSM_Beep_init(void) +{ + setup_timer(&FSM_Beep_timer, FSM_Beep_timer_callback, 0); + + printk(KERN_INFO "FSM Beep loaded\n"); + return 0; +} +static void __exit FSM_Beep_exit(void) +{ + del_timer(&FSM_Beep_timer); + printk(KERN_INFO "FSM Beep unloaded\n"); +} + +MODULE_LICENSE("GPL"); +module_init(FSM_Beep_init); +module_exit(FSM_Beep_exit); \ No newline at end of file diff --git a/FSM/FSM_CCKControl.c b/FSM/FSM_CCKControl.c new file mode 100644 index 00000000000000..7f17b3b5a8607e --- /dev/null +++ b/FSM/FSM_CCKControl.c @@ -0,0 +1,109 @@ +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +struct FSM_DeviceFunctionTree FSMCCK_dft; +struct CCKDeviceInfo FSMCCK_CCKDev[FSM_CCKTreeSize]; + +void FSM_CCKControlDeviceRecive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + // struct fsm_devices_config* fsmset; + // struct FSM_DeviceTree* fsdt; + // int i,j; + // short hlen; + // unsigned short tmp; + struct FSM_SendCmdTS* fscts = (struct FSM_SendCmdTS*)data; + // printk( KERN_INFO "FSM SIOCTL,%u \n",fscts->opcode ); + + switch(data[0]) { + case RegDevice: + FSM_Statstic_SetStatus(to_dt, "ok"); + break; + case SendCmdToServer: ///< Отправка команды серверу + switch(fscts->cmd) { + } + break; + case PacketFromUserSpace: ///< Отправка команды серверу + switch(fscts->cmd) { + case FSM_CCKGetInfo: + memcpy(fscts->Data, &FSMCCK_CCKDev, sizeof(FSMCCK_CCKDev)); + // printk( KERN_INFO "FSM CCK RC\n" ); + break; + } + break; + } +} + +void FSMCCK_AddDeviceInfo(struct CCKDeviceInfo* CCK) +{ + int i; + for(i = 0; i < FSM_CCKTreeSize; i++) { + if((FSMCCK_CCKDev[i].id == CCK->id) && (FSMCCK_CCKDev[i].reg == 1)) { + FSMCCK_CCKDev[i].ip[0] = CCK->ip[0]; + FSMCCK_CCKDev[i].ip[1] = CCK->ip[1]; + FSMCCK_CCKDev[i].ip[2] = CCK->ip[2]; + FSMCCK_CCKDev[i].ip[3] = CCK->ip[3]; + FSMCCK_CCKDev[i].Position = CCK->Position; + FSMCCK_CCKDev[i].type = CCK->type; + FSMCCK_CCKDev[i].crc32 = CCK->crc32; + FSMCCK_CCKDev[i].ramstate = CCK->ramstate; + FSMCCK_CCKDev[i].dstlen = CCK->dstlen; + return; + } + } + for(i = 0; i < FSM_CCKTreeSize; i++) { + if(FSMCCK_CCKDev[i].reg == 0) { + FSMCCK_CCKDev[i].reg = 1; + FSMCCK_CCKDev[i].n = i; + FSMCCK_CCKDev[i].id = CCK->id; + FSMCCK_CCKDev[i].ip[0] = CCK->ip[0]; + FSMCCK_CCKDev[i].ip[1] = CCK->ip[1]; + FSMCCK_CCKDev[i].ip[2] = CCK->ip[2]; + FSMCCK_CCKDev[i].ip[3] = CCK->ip[3]; + FSMCCK_CCKDev[i].Position = CCK->Position; + FSMCCK_CCKDev[i].type = CCK->type; + FSMCCK_CCKDev[i].crc32 = CCK->crc32; + FSMCCK_CCKDev[i].ramstate = CCK->ramstate; + FSMCCK_CCKDev[i].dstlen = CCK->dstlen; + // printk( KERN_INFO "FSM CCK Device Added\n" ); + return; + } + } +} +EXPORT_SYMBOL(FSMCCK_AddDeviceInfo); + +static int __init FSMCCKControlDevice_init(void) +{ + struct FSM_DeviceRegistr regp; + FSMCCK_dft.aplayp = 0; + FSMCCK_dft.type = (unsigned char)AudioDevice; + FSMCCK_dft.VidDevice = (unsigned char)CommunicationDevice; + FSMCCK_dft.PodVidDevice = (unsigned char)ControlCCK; + FSMCCK_dft.KodDevice = (unsigned char)ControlCCKServer; + FSMCCK_dft.Proc = FSM_CCKControlDeviceRecive; + FSMCCK_dft.config_len = 0; + FSM_DeviceClassRegister(FSMCCK_dft); + + regp.IDDevice = FSM_CCKControlID; + regp.VidDevice = FSMCCK_dft.VidDevice; + regp.PodVidDevice = FSMCCK_dft.PodVidDevice; + regp.KodDevice = FSMCCK_dft.KodDevice; + regp.type = FSMCCK_dft.type; + regp.opcode = RegDevice; + regp.CRC = 0; + FSM_DeviceRegister(regp); + printk(KERN_INFO "FSM CCK ControlDevice loaded\n"); + return 0; +} +static void __exit FSMCCKControlDevice_exit(void) +{ + FSM_ClassDeRegister(FSMCCK_dft); + printk(KERN_INFO "FSM CCK ControlDevice module unloaded\n"); +} + +module_init(FSMCCKControlDevice_init); +module_exit(FSMCCKControlDevice_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM CCK ControlDevice Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_CRC.c b/FSM/FSM_CRC.c new file mode 100644 index 00000000000000..3d674622f16e98 --- /dev/null +++ b/FSM/FSM_CRC.c @@ -0,0 +1,36 @@ +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +unsigned int FSM_crc32NT(unsigned int crc, unsigned char *buf,unsigned int len) { + unsigned int i,mask; + + crc = ~crc; + while (len--) { + crc = crc ^ (*buf++); // process next byte + i=8; + while (i--) { // process 8 bits + mask = -(crc & 1); + crc = (crc >> 1) ^ (0xEDB88320 & mask); + } + } + return ~crc; +} +EXPORT_SYMBOL(FSM_crc32NT); + +static int __init FSM_CRC_init(void) +{ + printk(KERN_INFO "FSM CRC loaded\n"); + return 0; +} +static void __exit FSM_CRC_exit(void) +{ + printk(KERN_INFO "FSM CRC module unloaded\n"); +} +module_init(FSM_CRC_init); +module_exit(FSM_CRC_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM CRC Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_Client.c b/FSM/FSM_Client.c new file mode 100644 index 00000000000000..cdf5ab50d29cfa --- /dev/null +++ b/FSM/FSM_Client.c @@ -0,0 +1,470 @@ +/*! +\file +\brief Модуль взаимодествия с Ethernet +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" +#include "FSM/FSM_Client/FSM_client.h" +#include +struct fsm_client_struct fsmlcs[FSM_ClientTreeSize]; +struct fsm_server_connection fsmcon; +struct fsm_event_struct fsmes[FSM_EventTreeSize]; + + +static int packet_direct_xmit(struct sk_buff* skb) +{ + struct net_device* dev = skb->dev; + netdev_features_t features; + struct netdev_queue* txq; + int ret = NETDEV_TX_BUSY; + + if(unlikely(!netif_running(dev) || !netif_carrier_ok(dev))) + goto drop; + + features = netif_skb_features(skb); + if(skb_needs_linearize(skb, features) && __skb_linearize(skb)) + goto drop; + + txq = skb_get_tx_queue(dev, skb); + + local_bh_disable(); + + HARD_TX_LOCK(dev, txq, smp_processor_id()); + if(!netif_xmit_frozen_or_drv_stopped(txq)) + ret = netdev_start_xmit(skb, dev, txq, false); + HARD_TX_UNLOCK(dev, txq); + + local_bh_enable(); + + if(!dev_xmit_complete(ret)) + kfree_skb(skb); + + return ret; +drop: + atomic_long_inc(&dev->tx_dropped); + kfree_skb(skb); + return NET_XMIT_DROP; +} + +unsigned int FSM_Send_Ethernet(void* data, int len, struct fsm_server_connection* fsmdev) +{ + + struct net_device* dev = fsmdev->dev; + struct sk_buff* skb; + int hlen = LL_RESERVED_SPACE(dev); + int tlen = dev->needed_tailroom; + + if(fsmdev == 0) + return 1; + // skb = alloc_skb(len + hlen + tlen, GFP_ATOMIC); + skb = dev_alloc_skb(len + hlen + tlen); + if(skb == NULL) { + printk(KERN_INFO "SKB Eror\n"); + goto out; + } + skb_reserve(skb, hlen); + skb->dev = dev; + // skb->protocol = fsmdev.eth.h_proto; + skb_reset_network_header(skb); + memcpy(skb_put(skb, len), data, len); + if(dev_hard_header(skb, dev, __constant_htons(FSM_PROTO_ID_R), fsmdev->destmac, dev->dev_addr, skb->len) < 0) + goto out; + packet_direct_xmit(skb); +//надо чистить буфер + return 0; + +out: + + kfree_skb(skb); + return 0; +} +EXPORT_SYMBOL(FSM_Send_Ethernet); + +unsigned int FSM_Send_Ethernet_TS(void* data, int len) +{ + if(fsmcon.coonect == 1) { + FSM_Send_Ethernet(data, len, &fsmcon); + return 0; + } + return 1; +} +EXPORT_SYMBOL(FSM_Send_Ethernet_TS); + +int FSM_RegisterServer(unsigned short id, + unsigned char type, + unsigned char VidDevice, + unsigned char PodVidDevice, + unsigned char KodDevice) +{ + struct FSM_DeviceRegistr regp; + struct fsm_server_connection fsmdev; + memset(&fsmdev, 0, sizeof(fsmdev)); + regp.IDDevice = id; + regp.VidDevice = VidDevice; + regp.PodVidDevice = PodVidDevice; + regp.KodDevice = KodDevice; + regp.type = type; + regp.opcode = RegDevice; + regp.CRC = 0; + memset(fsmdev.destmac, 0xFF, 6); + fsmcon.id = id; + fsmcon.VidDevice = VidDevice; + fsmcon.PodVidDevice = PodVidDevice; + fsmcon.KodDevice = KodDevice; + fsmcon.type = type; + + fsmdev.dev = first_net_device(&init_net); + + while(fsmdev.dev) { + FSM_Send_Ethernet(®p, sizeof(regp), &fsmdev); + fsmdev.dev = next_net_device(fsmdev.dev); + } + return 2; +} +EXPORT_SYMBOL(FSM_RegisterServer); + +struct fsm_event_struct* FSM_RegisterEvent(unsigned int id, EventClientProcess Handler) +{ + int i; + for(i = 0; i < FSM_EventTreeSize; i++) { + if(fsmes[i].reg == 0) { + fsmes[i].reg = 1; + fsmes[i].id = id; + fsmes[i].Handler = Handler; + return &fsmes[i]; + } + } + return 0; +} +EXPORT_SYMBOL(FSM_RegisterEvent); + +struct fsm_event_struct* FSM_FindEvent(unsigned int id) +{ + int i; + for(i = 0; i < FSM_EventTreeSize; i++) { + if((fsmes[i].reg == 1) && (fsmes[i].id == id)) { + return &fsmes[i]; + } + } + return 0; +} +EXPORT_SYMBOL(FSM_FindEvent); + +void FSM_DeleteEvent(unsigned int id) +{ + struct fsm_event_struct* evnt = FSM_FindEvent(id); + if(evnt != 0) + evnt->reg = 0; +} +EXPORT_SYMBOL(FSM_DeleteEvent); + +int FSM_RegisterDevice(unsigned short id, + unsigned char type, + unsigned char VidDevice, + unsigned char PodVidDevice, + unsigned char KodDevice, + DeviceClientProcess Handler) +{ + int i; + struct FSM_DeviceRegistr regp; + int time = 9000000; + while(time) { + time--; + if(fsmcon.coonect == 1) + break; + } + // if(fsmcon.coonect == 0) + // return -1; + + for(i = 0; i < FSM_ClientTreeSize; i++) { + if(((fsmlcs[i].reg == 1)&&(fsmlcs[i].id == id))) + { + goto fsm_reg; + } + } + + for(i = 0; i < FSM_ClientTreeSize; i++) { + if(fsmlcs[i].reg == 0) { + fsmlcs[i].Handler = Handler; + fsmlcs[i].reg = 1; + fsmlcs[i].id = id; + fsmlcs[i].VidDevice = VidDevice; + fsmlcs[i].PodVidDevice = PodVidDevice; + fsmlcs[i].KodDevice = KodDevice; + fsmlcs[i].type = type; + break; + } + } + +fsm_reg: + if(fsmcon.coonect == 0) return -1; + printk(KERN_INFO "SR"); + regp.IDDevice = id; + regp.VidDevice = VidDevice; + regp.PodVidDevice = PodVidDevice; + regp.KodDevice = KodDevice; + regp.type = type; + regp.opcode = RegDevice; + regp.CRC = 0; + FSM_Send_Ethernet(®p, sizeof(regp), &fsmcon); + + return 0; +} +EXPORT_SYMBOL(FSM_RegisterDevice); + +struct fsm_client_struct* FSM_FindHandlerDevice(unsigned short id) +{ + int i; + + // if(fsmcon.coonect == 1) { + for(i = 0; i < FSM_ClientTreeSize; i++) { + if((fsmlcs[i].reg == 1) && (fsmlcs[i].id == id)) { + return &fsmlcs[i]; + } + } + //} + + return 0; +} +EXPORT_SYMBOL(FSM_FindHandlerDevice); + +int FSM_DeleteDevice(unsigned short id) +{ + struct FSM_DeviceDelete delp; + struct fsm_client_struct* strdev; + + if(fsmcon.coonect == 1) { + delp.IDDevice = id; + delp.opcode = DelLisr; + delp.CRC = 0; + FSM_Send_Ethernet(&delp, sizeof(delp), &fsmcon); + strdev = FSM_FindHandlerDevice(id); + if(strdev == 0) + return -1; + strdev->reg = 0; + } + + return 1; +} + +EXPORT_SYMBOL(FSM_DeleteDevice); + +void FSM_DeregisterServer(void) +{ + struct FSM_DeviceDelete delp; + + if(fsmcon.coonect == 1) { + delp.IDDevice = fsmcon.id; + delp.opcode = DelLisr; + delp.CRC = 0; + fsmcon.coonect = 0; + FSM_Send_Ethernet(&delp, sizeof(delp), &fsmcon); + } +} +EXPORT_SYMBOL(FSM_DeregisterServer); + +int FSMClient_pack_rcv(struct sk_buff* skb, struct net_device* dev, struct packet_type* pt, struct net_device* odev) +{ + char dats = ((char*)skb->data)[0]; + struct ethhdr* eth = eth_hdr(skb); + struct fsm_client_struct* clstr; + struct fsm_event_struct* evstr; + + if(skb->pkt_type == PACKET_OTHERHOST || skb->pkt_type == PACKET_LOOPBACK) + goto clear; + + switch(dats) { + case RegDevice: ///< Регистрация устройства + + break; + case AnsRegDevice: ///< Подтверждение регистрации + if(fsmcon.id == ((struct FSM_AnsDeviceRegistr*)(skb->data))->IDDevice) { + printk(KERN_INFO "ER"); + memcpy(fsmcon.destmac, eth->h_source, 6); + fsmcon.dev = dev; + fsmcon.coonect = 1; + + } else { + clstr = FSM_FindHandlerDevice(((struct FSM_AnsDeviceRegistr*)(skb->data))->IDDevice); + if(clstr == 0) + goto clear; + clstr->Handler(skb->data, sizeof(struct FSM_AnsDeviceRegistr), clstr); + } + break; + case DelLisr: ///< Удаление устройства из списка + break; + case AnsDelList: ///< Подтверждение удаления устройства из списка + if(fsmcon.id == ((struct FSM_AnsDeviceDelete*)(skb->data))->IDDevice) { + fsmcon.coonect = 0; + } else { + clstr = FSM_FindHandlerDevice(((struct FSM_AnsDeviceDelete*)(skb->data))->IDDevice); + if(clstr == 0) + goto clear; + clstr->Handler(skb->data, sizeof(struct FSM_AnsDeviceDelete), clstr); + } + break; + case AnsPing: ///< Пинг + break; + case SendCmdToDevice: ///< Отправка команды устройству + if(fsmcon.id == ((struct FSM_SendCmd*)(skb->data))->IDDevice) { + } else { + clstr = FSM_FindHandlerDevice(((struct FSM_SendCmd*)(skb->data))->IDDevice); + if(clstr == 0) + goto clear; + clstr->Handler(skb->data, sizeof(struct FSM_SendCmd), clstr); + } + break; + case AnsSendCmdToDevice: ///< Подтверждение приёма команды устройством + break; + case RqToDevice: ///< Ответ на команду устройством + break; + case AnsRqToDevice: ///< Подтверждение приёма команды сервером + break; + case SendCmdToServer: ///< Отправка команды серверу + break; + case SendTxtMassage: ///< Отправка текстового сообщения + break; + case AnsSendTxtMassage: ///< Подтверждение приёма текстового сообщения + break; + case SendTxtEncMassage: ///< Отправка зашифрованного текстового сообщения + break; + case AnsSendTxtEncMassage: ///< Подтверждение приёма зашифрованного текстового сообщения + break; + case SendAudio: ///< Передача аудио данных + goto clear; + break; + case SendVideo: ///< Передача видео данных + break; + case SendBinData: ///< Передача бинарных данных + break; + case AnsSendBinData: ///< Подтверждение приёма бинарных данных + break; + case SendSMS: ///< Отправить СМС + break; + case SendAnsSMS: ///< Подтверждение СМС + break; + case SendSMStoDev: ///< Передача СМС устройству + break; + case SendAnsSMStoDev: ///< Подтверждение СМС устройством + break; + case SendEncSMS: ///< Отправить зашифрованного СМС + break; + case SendAnsEncSMS: ///<Подтверждение зашифрованного СМС + break; + case SendEncSMStoDev: ///< Отправить зашифрованного СМС устройству + break; + case SendAnsEncSMStoDev: ///< Подтверждение зашифрованного СМС устройства + break; + case SendEmail: ///< Отправка email + break; + case AnsEmail: ///<Подтверждение email + break; + case SendEmailtoDevice: ///<Передача email устройству + break; + case AnsSendEmailtoDevice: ///<Подтверждение email устройством + break; + case SendEncEmail: ///<Отправить зашифрованного email + break; + case AnsEncEmail: ///<Подтверждение зашифрованного email + break; + case SendEncEmailtoDev: ///< Отправить зашифрованного email устройству + break; + case AnsEncEmailtoDev: ///< Подтверждение зашифрованного email устройства + break; + case SocSend: ///< Отправка сообщение в социальную сеть + break; + case AnsSocSend: ///< Подтверждение сообщения в социальную сеть + break; + case SocSendtoDev: ///< Передача сообщения в социальную сеть устройству + break; + case AnsSocSendtoDev: ///< Подтверждение сообщения в социальную сеть устройством + break; + case SocEncSend: ///< Отправить зашифрованного сообщения в социальную сеть + break; + case AnsSocEncSend: ///< Подтверждение зашифрованного сообщения в социальную сеть + break; + case SocEncSendtoDev: ///< Отправить зашифрованного сообщения в социальную сеть устройству + break; + case AnsSocEncSendtoDev: ///< Подтверждение зашифрованного сообщения в социальную сеть устройства + break; + case Alern: ///<Тревога + break; + case Warning: ///<Предупреждение + break; + case Trouble: ///<Сбой + break; + case Beep: ///<Звук + break; + case PacketFromUserSpace: + if(fsmcon.id == ((struct FSM_SendCmdUserspace*)(skb->data))->IDDevice) { + } else { + clstr = FSM_FindHandlerDevice(((struct FSM_SendCmdUserspace*)(skb->data))->IDDevice); + if(clstr == 0) + goto clear; + clstr->Handler(skb->data, sizeof(struct FSM_SendCmdUserspace), clstr); + } + break; + case SysEvent: + evstr = FSM_FindEvent(((struct FSM_EventSignal*)(skb->data))->ID); + if(evstr == 0) + goto clear; + evstr->Handler(skb->data, sizeof(struct FSM_SendCmdUserspace), evstr); + break; + case SendCmdGlobalcmdToClient: + switch(((struct FSM_SendCmdTS*)skb->data)->cmd) { + case FSMNotRegistred: + if(((struct FSM_SendCmd*)skb->data)->IDDevice == fsmcon.id) { + FSM_RegisterServer(fsmcon.id, fsmcon.type, fsmcon.VidDevice, fsmcon.PodVidDevice, fsmcon.KodDevice); + } else { + clstr = FSM_FindHandlerDevice(((struct FSM_SendCmd*)(skb->data))->IDDevice); + if(clstr == 0) + goto clear; + clstr->Handler(skb->data, sizeof(struct FSM_SendCmd), clstr); + } + break; + } + break; + } + +clear: + kfree_skb(skb); + return skb->len; +}; + +static struct packet_type FSMClient_proto = { + .type = cpu_to_be16(FSM_PROTO_ID), // may be: __constant_htons( TEST_PROTO_ID ), + .func = FSMClient_pack_rcv, +}; + +void FSM_EthernetEventLoaded(char* Data, short len, struct fsm_event_struct* cl_str) +{ + FSM_RegisterServer(fsmcon.id, fsmcon.type, fsmcon.VidDevice, fsmcon.PodVidDevice, fsmcon.KodDevice); +} + +static int __init FSMClient_init(void) +{ + + memset(&fsmcon, 0, sizeof(fsmcon)); + dev_add_pack(&FSMClient_proto); + printk(KERN_INFO "FSMClient module loaded\n"); + FSM_RegisterEvent(FSM_ControlDeviceRun, FSM_EthernetEventLoaded); + return 0; +} + +static void __exit FSMClient_exit(void) +{ + dev_remove_pack(&FSMClient_proto); + printk(KERN_INFO "FSMClient module unloaded\n"); +} + +module_init(FSMClient_init); +module_exit(FSMClient_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM Protocol Module"); +MODULE_LICENSE("GPL"); diff --git a/FSM/FSM_Commutator.c b/FSM/FSM_Commutator.c new file mode 100644 index 00000000000000..385b23ea2039e5 --- /dev/null +++ b/FSM/FSM_Commutator.c @@ -0,0 +1,84 @@ +/*! +\file +\brief Модуль коммутатор +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +struct FSM_P2P_abonent FSM_P2P_fsmabon[FSM_P2P_abonent_count]; + +unsigned short FSM_P2P_Connect(unsigned short id1, unsigned short id2) +{ + int i = 0; + + for(i = 0; i < FSM_P2P_abonent_count; i++) { + if(FSM_P2P_fsmabon[i].reg == 0) { + FSM_P2P_fsmabon[i].reg = 1; + FSM_P2P_fsmabon[i].idstream1 = id1; + FSM_P2P_fsmabon[i].idstream2 = id2; + FSM_P2P_fsmabon[i].idcon = i; + FSM_AudioStreamSetIDConnect(id1, i, p2p); + FSM_AudioStreamSetToProcess(id1, FSM_Commutator_Process); + FSM_AudioStreamSetIDConnect(id2, i, p2p); + FSM_AudioStreamSetToProcess(id2, FSM_Commutator_Process); + return i; + } + } + + return 0xffff; +} +EXPORT_SYMBOL(FSM_P2P_Connect); +void FSM_P2P_Disconnect(unsigned short idcon) +{ + FSM_P2P_fsmabon[idcon].reg = 0; +} +EXPORT_SYMBOL(FSM_P2P_Disconnect); +void FSM_Commutator_Process(char* data, short len) +{ + struct FSM_SendAudioData* FSMAPk = (struct FSM_SendAudioData*)data; + unsigned short idcon; + + idcon = FSM_AudioStreamGETIDConnect(FSMAPk->IDDevice); + if(idcon == 0xffff) + return; + + switch(FSM_AudioStreamGETTypeConnect(FSMAPk->IDDevice)) { + case p2p: + if(FSMAPk->IDDevice == FSM_P2P_fsmabon[idcon].idstream1) { + FSMAPk->IDDevice = FSM_P2P_fsmabon[idcon].idstream2; + FSM_AudioStreamToUser( + FSM_P2P_fsmabon[idcon].idstream2, data, sizeof(struct FSM_SendAudioData) - sizeof(FSMAPk->Data) + FSMAPk->len); + } else { + FSMAPk->IDDevice = FSM_P2P_fsmabon[idcon].idstream1; + FSM_AudioStreamToUser(FSM_P2P_fsmabon[idcon].idstream1, + (char*)FSMAPk, + sizeof(struct FSM_SendAudioData) - sizeof(FSMAPk->Data) + FSMAPk->len); + } + break; + } + // fsmabon[idcon].idcon +} +EXPORT_SYMBOL(FSM_Commutator_Process); + +static int __init FSM_Commutator_init(void) +{ + printk(KERN_INFO "FSM Commutator Module loaded\n"); + return 0; +} + +static void __exit FSM_Commutator_exit(void) +{ + printk(KERN_INFO "FSM Commutator Module unloaded\n"); +} + +module_init(FSM_Commutator_init); +module_exit(FSM_Commutator_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM Commutator Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_Commutator.h b/FSM/FSM_Commutator.h new file mode 100644 index 00000000000000..c3088c636fdc65 --- /dev/null +++ b/FSM/FSM_Commutator.h @@ -0,0 +1,5 @@ +#ifndef FSM_Commutator +#define FSM_Commutator + + +#endif \ No newline at end of file diff --git a/FSM/FSM_ControlDevice.c b/FSM/FSM_ControlDevice.c new file mode 100644 index 00000000000000..117130ba8e0e78 --- /dev/null +++ b/FSM/FSM_ControlDevice.c @@ -0,0 +1,24 @@ +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" +#include "FSM/FSM_Client/FSM_client.h" + +static int __init FSMControlDevice_init(void) +{ + FSM_RegisterServer(27, ControlMachine, Computer, PC, ARM); + printk(KERN_INFO "FSM ControlDevice loaded\n"); + + return 0; +} +static void __exit FSMControlDevice_exit(void) +{ + FSM_DeregisterServer(); + printk(KERN_INFO "FSM ControlDevice module unloaded\n"); +} + +module_init(FSMControlDevice_init); +module_exit(FSMControlDevice_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM Control Device Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_ControlDeviceClass.c b/FSM/FSM_ControlDeviceClass.c new file mode 100644 index 00000000000000..0070b76cacbcfd --- /dev/null +++ b/FSM/FSM_ControlDeviceClass.c @@ -0,0 +1,31 @@ +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +struct FSM_DeviceFunctionTree FSMControlDevice_dft; + +void FSM_ControlDeviceRecive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ +} +static int __init FSMControlDevice_init(void) +{ + FSMControlDevice_dft.aplayp = 0; + FSMControlDevice_dft.type = (unsigned char)ControlMachine; + FSMControlDevice_dft.VidDevice = (unsigned char)Computer; + FSMControlDevice_dft.PodVidDevice = (unsigned char)PC; + FSMControlDevice_dft.KodDevice = (unsigned char)ARM; + FSMControlDevice_dft.Proc = FSM_ControlDeviceRecive; + FSMControlDevice_dft.config_len = 0; + FSM_DeviceClassRegister(FSMControlDevice_dft); + printk(KERN_INFO "FSM ControlDevice loaded\n"); + FSM_SendEventToAllDev(FSM_ControlDeviceRun); + return 0; +} +static void __exit FSMControlDevice_exit(void) +{ + FSM_ClassDeRegister(FSMControlDevice_dft); + printk(KERN_INFO "FSM ControlDevice module unloaded\n"); +} + +module_init(FSMControlDevice_init); +module_exit(FSMControlDevice_exit); \ No newline at end of file diff --git a/FSM/FSM_Crypt.c b/FSM/FSM_Crypt.c new file mode 100644 index 00000000000000..259e822a022cd3 --- /dev/null +++ b/FSM/FSM_Crypt.c @@ -0,0 +1,70 @@ +#include +#include +#include +#include "FSM/FSMDevice/fcmprotocol.h" +#include "FSM/FSMSetting/FSM_settings.h" +#include "FSM/FSMCrypto/FSM_crypt.h" + +struct FSM_cryptalg FSMCA[FSM_CryptoAlgoritmNum]; + +int FSMCrypt_Register(FunctionEncDec Encode, FunctionEncDec Decode, char id) +{ + FSMCA[(int)id].reg = 1; + FSMCA[(int)id].Encode = Encode; + FSMCA[(int)id].Decode = Decode; + return 0; +} +EXPORT_SYMBOL(FSMCrypt_Register); + +int FSMCrypt_UnRegister(FunctionEncDec Encode, FunctionEncDec Decode, char id) +{ + FSMCA[(int)id].reg = 0; + FSMCA[(int)id].Encode = 0; + FSMCA[(int)id].Decode = 0; + return 0; +} +EXPORT_SYMBOL(FSMCrypt_UnRegister); +void FSMEncrypt(char id, char* dst, char* src, short len) +{ + if(FSMCA[(int)id].reg == 1) + FSMCA[(int)id].Encode(dst, src, len); +} +EXPORT_SYMBOL(FSMEncrypt); +void FSMDecrypt(char id, char* dst, char* src, short len) +{ + if(FSMCA[(int)id].reg == 1) + FSMCA[(int)id].Decode(dst, src, len); +} +EXPORT_SYMBOL(FSMDecrypt); +void FSMSetKey(char id, void* key) +{ + if(FSMCA[(int)id].reg == 1) + FSMCA[(int)id].Keys = key; +} +EXPORT_SYMBOL(FSMSetKey); +void* FSMGetKey(char id) +{ + if(FSMCA[(int)id].reg == 1) + return FSMCA[(int)id].Keys; + else + return 0; +} +EXPORT_SYMBOL(FSMGetKey); + +static int __init FSMCrypto_init(void) +{ + printk(KERN_INFO "FSMCrypto module loaded\n"); + return 0; +} + +static void __exit FSMCrypto_exit(void) +{ + printk(KERN_INFO "FSMCrypto module unloaded\n"); +} + +module_init(FSMCrypto_init); +module_exit(FSMCrypto_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM Crypto Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_DeviceProcess.c b/FSM/FSM_DeviceProcess.c new file mode 100644 index 00000000000000..1c885085840e18 --- /dev/null +++ b/FSM/FSM_DeviceProcess.c @@ -0,0 +1,362 @@ +/*! +\file +\brief Процессс работы с устроствами +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" +/*! +\brief Список классов устройств + */ +struct FSM_DeviceFunctionTree fsm_dft[FSM_DeviceFunctionTreeSize]; +/*! +\brief Список устройств + */ +struct FSM_DeviceTree fsm_dt[FSM_DeviceTreeSize]; +struct fsm_statusstruct fsm_str; +struct fsm_devices_config fsm_set; + +static int __init FSMDeviceProcess_init(void) +{ + memset(fsm_dft, 0, sizeof(fsm_dft)); + memset(fsm_dt, 0, sizeof(fsm_dt)); + FSM_SendEventToAllDev(FSM_ServerStarted); + printk(KERN_INFO "FSMDeviceProcess module loaded\n"); + return 0; +} +static void __exit FSMDeviceProcess_exit(void) +{ + + memset(fsm_dft, 0, sizeof(fsm_dft)); + memset(fsm_dt, 0, sizeof(fsm_dt)); + printk(KERN_INFO "FSMDeviceProcess module unloaded\n"); +} + +void FSM_ToProcess(int id, char* Data, short len, struct FSM_DeviceTree* from_dt) +{ + if(fsm_dt[id].registr == 1) { + fsm_dt[id].dt->Proc(Data, len, &fsm_dt[id], from_dt); + } +} +EXPORT_SYMBOL(FSM_ToProcess); + +int FSM_ToCmdStream(struct FSM_DeviceTree* pdt) +{ + return pdt->id; +} +EXPORT_SYMBOL(FSM_ToCmdStream); + +void FSM_SendEventToDev(enum FSM_eventlist idevent, struct FSM_DeviceTree* TransportDevice) +{ + struct FSM_EventSignal fsm_event; + fsm_event.ID = idevent; + fsm_event.opcode = SysEvent; + fsm_event.IDDevice = 0; + fsm_event.CRC = 0; + TransportDevice->dt->Proc((char*)&fsm_event, sizeof(struct FSM_EventSignal), 0, TransportDevice); +} +EXPORT_SYMBOL(FSM_SendEventToDev); +void FSM_SendEventToAllDev(enum FSM_eventlist idevent) +{ + struct FSM_DeviceTree* TransportDevice; + TransportDevice = FSM_FindDevice(FSM_EthernetID2); + if(TransportDevice != 0) + FSM_SendEventToDev(idevent, TransportDevice); +} +EXPORT_SYMBOL(FSM_SendEventToAllDev); +/*! +\brief Получение статистики +\return Структуру статистики +*/ +struct fsm_statusstruct* FSM_GetStatistic(void) +{ + int i, j; + int m = 0; + + memset(&fsm_str, 0, sizeof(fsm_str)); + for(i = 0; i < srow_cnt; i++) { + for(j = 0; j < scolumn_cnt; j++) { + if((fsm_dt[m].IDDevice != 0) && (fsm_dt[m].registr == 1)) { + fsm_str.statel[i][j].devid = fsm_dt[m].IDDevice; + strcpy(fsm_str.statel[i][j].state, fsm_dt[m].state); + sprintf(fsm_str.statel[i][j].fsmdevcode, + "t%uv%upv%uk%u", + fsm_dt[m].dt->type, + fsm_dt[m].dt->VidDevice, + fsm_dt[m].dt->PodVidDevice, + fsm_dt[m].dt->KodDevice); + fsm_str.statel[i][j].row = i; + fsm_str.statel[i][j].column = j; + } + m++; + } + } + + return &fsm_str; +} +EXPORT_SYMBOL(FSM_GetStatistic); + +struct fsm_devices_config* FSM_GetSetting(void) +{ + int i, j; + int m = 0; + + memset(&fsm_set, 0, sizeof(fsm_set)); + for(i = 0; i < srow_cnt; i++) { + for(j = 0; j < scolumn_cnt; j++) { + if((fsm_dt[m].IDDevice != 0) && (fsm_dt[m].registr == 1)) { + fsm_set.setel[i][j].IDDevice = fsm_dt[m].IDDevice; + fsm_set.setel[i][j].Len = fsm_dt[m].dt->config_len; + memcpy(fsm_set.setel[i][j].config, fsm_dt[m].config, fsm_set.setel[i][j].Len); + fsm_set.setel[i][j].row = i; + fsm_set.setel[i][j].column = j; + m++; + } + } + } + + return &fsm_set; +} +EXPORT_SYMBOL(FSM_GetSetting); + +void FSM_Setting_Set(struct FSM_DeviceTree* fdt, void* set) +{ + + fdt->config = set; + FSM_SendEventToAllDev(FSM_ServerConfigChanged); +} +EXPORT_SYMBOL(FSM_Setting_Set); + +void FSM_Setting_Applay(struct FSM_DeviceTree* fdt, void* set) +{ + + if(fdt == 0) + return; + memcpy(fdt->config, set, fdt->dt->config_len); + if(fdt->debug) + printk(KERN_INFO "FSMAP %i\n", fdt->IDDevice); + if(fdt->dt->aplayp != 0) + fdt->dt->aplayp(fdt->TrDev, fdt); + + FSM_SendEventToAllDev(FSM_ServerConfigChanged); +} +EXPORT_SYMBOL(FSM_Setting_Applay); + +void FSM_Statstic_SetStatus(struct FSM_DeviceTree* fdt, char* status) +{ + + strcpy(fdt->state, status); + FSM_SendEventToAllDev(FSM_ServerStatisticChanged); +} +EXPORT_SYMBOL(FSM_Statstic_SetStatus); +/*! +\brief Регистрация класса устройств +\param[in] dft Пакет класса устроства +\return Код ошибки +*/ +unsigned char FSM_DeviceClassRegister(struct FSM_DeviceFunctionTree dft) +{ + int i; + + + if(FSM_FindDeviceClass2(dft) != 0) + return 2; + for(i = 0; i < FSM_DeviceFunctionTreeSize; i++) { + if(fsm_dft[i].registr == 0) { + fsm_dft[i].registr = 1; + fsm_dft[i].type = dft.type; + fsm_dft[i].VidDevice = dft.VidDevice; + fsm_dft[i].PodVidDevice = dft.PodVidDevice; + fsm_dft[i].KodDevice = dft.KodDevice; + fsm_dft[i].Proc = dft.Proc; + fsm_dft[i].config_len = dft.config_len; + fsm_dft[i].aplayp = dft.aplayp; + + FSM_SendEventToAllDev(FSM_ServerConfigChanged); + FSM_SendEventToAllDev(FSM_ServerStatisticChanged); + printk(KERN_INFO "DeviceClassRegistred: Type:%u; Vid:%u; PodVid:%u; KodDevice: %u \n", + dft.type, + dft.VidDevice, + dft.PodVidDevice, + dft.KodDevice); + return 0; + } + } + + return 1; +} +EXPORT_SYMBOL(FSM_DeviceClassRegister); +/*! +\brief Регистрация устройства +\param[in] dt Пакет регистрации +\return Код ошибки +*/ +unsigned char FSM_DeviceRegister(struct FSM_DeviceRegistr dt) +{ + int i; + struct FSM_DeviceFunctionTree* classf; + struct FSM_DeviceTree* dtsc; + + dtsc = FSM_FindDevice(dt.IDDevice); + if(dtsc != 0) + dtsc->registr = 0; + + for(i = 0; i < FSM_DeviceTreeSize; i++) { + if(fsm_dt[i].registr == 0) { + classf = FSM_FindDeviceClass(dt); + if(classf != 0) { + fsm_dt[i].registr = 1; + fsm_dt[i].IDDevice = dt.IDDevice; + fsm_dt[i].dt = classf; + fsm_dt[i].id = i; + fsm_dt[i].debug = 0; + FSM_SendEventToAllDev(FSM_ServerConfigChanged); + FSM_SendEventToAllDev(FSM_ServerStatisticChanged); + printk(KERN_INFO "DeviceRegistred: ID: %u Type:%u; Vid:%u; PodVid:%u; KodDevice: %u \n", + dt.IDDevice, + dt.type, + dt.VidDevice, + dt.PodVidDevice, + dt.KodDevice); + + return 0; + } + } + } + + return 1; +} +EXPORT_SYMBOL(FSM_DeviceRegister); +/*! +\brief Поиск класса устроства +\param[in] dt Пакет регистрации +\return Код ошибки +*/ +struct FSM_DeviceFunctionTree* FSM_FindDeviceClass(struct FSM_DeviceRegistr dt) +{ + int i; + + for(i = 0; i < FSM_DeviceFunctionTreeSize; i++) { + if((fsm_dft[i].KodDevice == dt.KodDevice) && (fsm_dft[i].VidDevice == dt.VidDevice) && + (fsm_dft[i].PodVidDevice == dt.PodVidDevice) && (fsm_dft[i].type == dt.type) && (fsm_dft[i].registr == 1)) { + return &fsm_dft[i]; + } + } + + return 0; +} +EXPORT_SYMBOL(FSM_FindDeviceClass); +/*! +\brief Поиск класса устроства +\param[in] dft Пакет класса устроства +\return Ссылку на класс устроства +*/ +struct FSM_DeviceFunctionTree* FSM_FindDeviceClass2(struct FSM_DeviceFunctionTree dft) +{ + int i; + + for(i = 0; i < FSM_DeviceFunctionTreeSize; i++) { + if((fsm_dft[i].KodDevice == dft.KodDevice) && (fsm_dft[i].VidDevice == dft.VidDevice) && + (fsm_dft[i].PodVidDevice == dft.PodVidDevice) && (fsm_dft[i].type == dft.type) && + (fsm_dft[i].registr == 1)) { + return &fsm_dft[i]; + } + } + + return 0; +} +EXPORT_SYMBOL(FSM_FindDeviceClass2); +/*! +\brief Поиск устроства +\param[in] id ID +\return Ссылку на класс устроства +*/ +struct FSM_DeviceTree* FSM_FindDevice(unsigned short id) +{ + int i; + + for(i = 0; i < FSM_DeviceTreeSize; i++) { + // if(fsm_dt[i].IDDevice!=0) printk( KERN_INFO "DeviceNotFindScan: ID: %u - %u \n", + // fsm_dt[i].IDDevice,fsm_dt[i].registr); + if((fsm_dt[i].IDDevice == id) && (fsm_dt[i].registr == 1)) { + + return &fsm_dt[i]; + } + } + printk(KERN_INFO "DeviceNotFind: ID: %u \n", id); + + return 0; +} +EXPORT_SYMBOL(FSM_FindDevice); +/*! +\brief Удаление из списка устроства +\param[in] fdd Пакет удаления устройства +\return Ссылку на устроство +*/ +void FSM_DeRegister(struct FSM_DeviceDelete fdd) +{ + + struct FSM_DeviceTree* dt = FSM_FindDevice(fdd.IDDevice); + + if(dt != 0) + dt->registr = 0; + + FSM_SendEventToAllDev(FSM_ServerConfigChanged); + FSM_SendEventToAllDev(FSM_ServerStatisticChanged); + printk(KERN_INFO "DeviceDeRegistred: ID: %u \n", fdd.IDDevice); +} +EXPORT_SYMBOL(FSM_DeRegister); +/*! +\brief Удаление из списка классов устроства +\param[in] dft Пакет класса устроства +*/ +void FSM_ClassDeRegister(struct FSM_DeviceFunctionTree dfti) +{ + struct FSM_DeviceFunctionTree* dft = FSM_FindDeviceClass2(dfti); + + if(dft != 0) + dft->registr = 0; + + FSM_SendEventToAllDev(FSM_ServerConfigChanged); + FSM_SendEventToAllDev(FSM_ServerStatisticChanged); + printk(KERN_INFO "DeviceClassDeregistred: Type:%u; Vid:%u; PodVid:%u; KodDevice: %u \n", + dfti.type, + dfti.VidDevice, + dfti.PodVidDevice, + dfti.KodDevice); +} +EXPORT_SYMBOL(FSM_ClassDeRegister); + +int FSM_AddProperty(char* PropertyCode, + void* Property, + unsigned short pr_size, + UpdateDataProperty udp, + struct FSM_DeviceTree* dt) +{ + dt->pdl[dt->pdl_count].devid = dt->IDDevice; + strcpy(dt->pdl[dt->pdl_count].PropertyCode, PropertyCode); + dt->pdl[dt->pdl_count].Property = Property; + dt->pdl[dt->pdl_count].pr_size = pr_size; + dt->pdl[dt->pdl_count].udp = udp; + sprintf(dt->pdl[dt->pdl_count].fsmdevcode, + "t%uv%upv%uk%u", + dt->dt->type, + dt->dt->VidDevice, + dt->dt->PodVidDevice, + dt->dt->KodDevice); + dt->pdl_count++; + return dt->pdl_count - 1; +} +EXPORT_SYMBOL(FSM_AddProperty); + +module_init(FSMDeviceProcess_init); +module_exit(FSMDeviceProcess_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM Flash Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_E1CAS1.c b/FSM/FSM_E1CAS1.c new file mode 100644 index 00000000000000..28ceced725542e --- /dev/null +++ b/FSM/FSM_E1CAS1.c @@ -0,0 +1,64 @@ +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" +#include + +struct FSME1CAS fsmcas[FSM_E1CasTreeSize]; + +void FSMCASHandler(char* Data, short len) +{ + +// struct FSM_SendAudioData* indat=(struct FSM_SendAudioData*) Data; +// struct FSME1CAS* casdata =(struct FSME1CAS*)FSM_AudioStreamData(indat->IDDevice); + +} + +int32_t FSMCASRegister(void) +{ + int i; + struct FSM_AudioStream fsmas; + + for(i = 0; i < FSM_E1CasTreeSize; i++) { + if(fsmcas[i].reg == 0) { + fsmcas[i].reg = 1; + fsmas.ToProcess = FSMCASHandler; + fsmas.TransportDevice = 0; + fsmas.TransportDeviceType = FSM_FifoID; + fsmas.Data = &fsmcas[i]; + fsmcas[i].idstream = FSM_AudioStreamRegistr(fsmas); + return i; + } + } + return -1; +} + +void FSMCASUnRegister(uint16_t idcon) +{ + fsmcas[idcon].reg = 0; +} + +uint16_t FSM_CAS_GetStream(uint16_t idcon) +{ + return fsmcas[idcon].idstream; +} + +static int __init FSME1CAS1Protocol_init(void) +{ + + memset(&fsmcas, 0, sizeof(fsmcas)); + printk(KERN_INFO "FSME1CAS1 module loaded\n"); + return 0; +} + +static void __exit FSME1CAS1Protocol_exit(void) +{ + printk(KERN_INFO "FSME1CAS1 module unloaded\n"); +} + +module_init(FSME1CAS1Protocol_init); +module_exit(FSME1CAS1Protocol_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM E1 Protocol Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_E1Device.c b/FSM/FSM_E1Device.c new file mode 100644 index 00000000000000..591870e9511374 --- /dev/null +++ b/FSM/FSM_E1Device.c @@ -0,0 +1,241 @@ +/*! +\file +\brief Драйвер E1 +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +struct FSM_DeviceFunctionTree FSME1_dft; +struct FSM_E1Device FSME1Dev[FSM_E1DeviceTreeSize]; +struct FSM_SendAudioData FSME1_sade1; +struct FSM_SendCmd FSME1_sendcmd; + +char E1AnalisPAcket(char ch0, struct FSM_E1Device* e1dev) +{ + e1dev->pkg_count++; + // printk( KERN_INFO "E1 Test: %u\n",ch0); + if((ch0 & 0x40) == 0) { + if(e1dev->bit_ch == 0) { + // printk( KERN_INFO "E1 Analiz: Error SH C: %i - %i -%x \n",e1dev->e1_eror_ch,e1dev->pkg_count,ch0); + e1dev->e1_eror_ch++; + } + e1dev->bit_ch = 0; + //чётный + if((ch0 & 0x3f) == 0x1b) { + return 0; + } else { + // printk( KERN_INFO "E1 Analiz: Error C \n"); + return -1; + } + } else { + if(e1dev->bit_ch == 1) { + // printk( KERN_INFO "E1 Analiz: Error SH NC: %i - %i -%x \n",e1dev->e1_eror_ch,e1dev->pkg_count,ch0); + e1dev->e1_eror_ch++; + } + e1dev->bit_ch = 1; + if((ch0 & 0x20) == 0x20) { + printk(KERN_INFO "E1 Analiz: Error NC Avaria CS\n"); + return -2; + } + if((ch0 & 0x04) == 0x04) { + // printk( KERN_INFO "E1 Analiz: Error NC Ostatohnie Zatuchania\n"); + return 0; + } + //нечётны + } + return 0; +} + +void FSM_E1RecivePacket(char* data, short len) +{ + int i = 0; + int j = 0; + unsigned short st; + unsigned short* E1SI; + struct FSM_SendAudioData* FSMAPk = (struct FSM_SendAudioData*)data; + struct FSME1Pkt* pkt = (struct FSME1Pkt*)FSMAPk->Data; + struct FSME1Pkt* pktout = (struct FSME1Pkt*)FSME1_sade1.Data; + char* datar = pktout->Data; + unsigned short size = 0; + struct FSM_E1Device* fsmdat = FSM_AudioStreamData(FSMAPk->IDDevice); + + if(fsmdat != 0) { + E1SI = fsmdat->streams_id; + } else { + return; + } + + // printk( KERN_INFO "Stream Recived %u \n",pkt->channels); + + for(i = 0; i < pkt->count; i++) { + E1AnalisPAcket(*(pkt->Data + (pkt->channels * i)), fsmdat); + for(j = 0; j < pkt->channels - 1; j++) { + st = E1SI[j]; + FSM_FIFOAudioStreamWrite((pkt->Data + (pkt->channels * i) + j + 1), 1, st); + } + } + + FSME1_sade1.IDDevice = FSMAPk->IDDevice; + pktout->count = pkt->count; + pktout->channels = pkt->channels; + for(i = 0; i < pktout->count; i++) { + + *datar = fsmdat->cht; + fsmdat->cht++; + datar++; + size++; + + for(j = 0; j < pktout->channels - 1; j++) { + if(size >= 1024) + break; + FSM_FIFOAudioStreamRead(datar, 1, E1SI[j]); + datar++; + size++; + } + } + FSME1_sade1.len = size + 2; + FSM_AudioStreamToUser( + FSMAPk->IDDevice, (char*)&FSME1_sade1, sizeof(struct FSM_SendAudioData) - sizeof(FSME1_sade1.Data) + FSME1_sade1.len); +} + +void FSM_E1SendStreaminfo(unsigned short id, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + short plen; + + memset(&FSME1_sendcmd, 0, sizeof(struct FSM_SendCmd)); + FSME1_sendcmd.opcode = SendCmdToDevice; + FSME1_sendcmd.IDDevice = from_dt->IDDevice; + FSME1_sendcmd.cmd = FSME1SendStream; + FSME1_sendcmd.countparam = 1; + ((unsigned short*)FSME1_sendcmd.Data)[0] = id; + FSME1_sendcmd.CRC = 0; + plen = sizeof(struct FSM_SendCmd) - sizeof(FSME1_sendcmd.Data) + 2; + if(to_dt != 0) + to_dt->dt->Proc((char*)&FSME1_sendcmd, plen, to_dt, from_dt); +} + +void FSM_E1Recive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + int i, j; + struct FSM_AudioStream fsmas; + + switch(data[0]) { + + case RegDevice: ///< Регистрация устройства + FSM_Statstic_SetStatus(to_dt, "ok"); + for(i = 0; i < FSM_E1DeviceTreeSize; i++) { + if(FSME1Dev[i].iddev == to_dt->IDDevice) { + FSM_E1SendStreaminfo(FSME1Dev[i].idstream, from_dt, to_dt); + FSME1Dev[i].bit_ch = 1; + FSME1Dev[i].e1_eror_ch = 0; + FSME1Dev[i].cht = 0; + return; + } + } + for(i = 0; i < FSM_E1DeviceTreeSize; i++) { + if(FSME1Dev[i].reg == 0) { + FSME1Dev[i].reg = 1; + FSME1Dev[i].ethdev = FSM_FindEthernetDevice(to_dt->IDDevice); + fsmas.iddev = to_dt->IDDevice; + + fsmas.ToProcess = FSM_E1RecivePacket; + // fsmas.ToUser=FSM_E1SendPacket; + fsmas.TransportDevice = FSME1Dev[i].ethdev->numdev; + fsmas.TransportDeviceType = FSM_EthernetID2; + fsmas.Data = &FSME1Dev[i]; + FSME1Dev[i].idstream = FSM_AudioStreamRegistr(fsmas); + FSME1Dev[i].iddev = to_dt->IDDevice; + FSME1Dev[i].bit_ch = 1; + FSME1Dev[i].e1_eror_ch = 0; + FSME1Dev[i].cht = 0; + fsmas.ToProcess = 0; + fsmas.TransportDevice = 0; + fsmas.TransportDeviceType = FSM_FifoID; + to_dt->data = &FSME1Dev[i]; + for(j = 0; j < 32; j++) { + FSM_FIFOAudioStreamRegistr(fsmas, &(FSME1Dev[i].streams_id[j])); + // printk( KERN_INFO "FSM %u \n",FSME1Dev[i].streams_id[j]); + } + FSM_E1SendStreaminfo(FSME1Dev[i].idstream, from_dt, to_dt); + printk(KERN_INFO "FSME1 Device Added %u \n", to_dt->IDDevice); + + break; + } + } + break; + case DelLisr: + for(i = 0; i < FSM_E1DeviceTreeSize; i++) { + if((FSME1Dev[i].reg == 1) && (FSME1Dev[i].iddev == to_dt->IDDevice)) { + + FSM_AudioStreamUnRegistr(FSME1Dev[i].idstream); + FSME1Dev[i].reg = 0; + printk(KERN_INFO "FSME1 Device Deleted %u \n", to_dt->IDDevice); + break; + } + } + break; + case AnsPing: ///< Пинг + break; + case SendCmdToServer: ///< Отправка команды серверу + break; + case SendTxtMassage: ///< Отправка текстового сообщения + break; + case Alern: ///<Тревога + break; + case Warning: ///<Предупреждение + break; + case Trouble: ///<Сбой + break; + case Beep: ///<Звук + break; + default: + break; + } + printk(KERN_INFO "RPack %u \n", len); +} +EXPORT_SYMBOL(FSM_E1Recive); + +static int __init FSME1Protocol_init(void) +{ + +#ifdef DEBUG_CALL_STACK + DEBUG_CALL_STACK_GLOBSET + DEBUG_CALL_STACK_SetStack | (init_on); +#endif + + memset(&FSME1Dev, 0, sizeof(FSME1Dev)); + FSME1_sade1.codec = 0; + FSME1_sade1.CRC = 0; + FSME1_sade1.len = 160; + FSME1_sade1.opcode = SendAudio; + FSME1_dft.type = (unsigned char)AudioDevice; + FSME1_dft.VidDevice = (unsigned char)CommunicationDevice; + FSME1_dft.PodVidDevice = (unsigned char)CCK; + FSME1_dft.KodDevice = (unsigned char)MN524; + FSME1_dft.Proc = FSM_E1Recive; + FSME1_dft.config_len = 0; + FSM_DeviceClassRegister(FSME1_dft); + // fsme1pkt2.channels=7 + + printk(KERN_INFO "FSME1Protocol module loaded\n"); + return 0; +} + +static void __exit FSME1Protocol_exit(void) +{ + FSM_ClassDeRegister(FSME1_dft); + printk(KERN_INFO "FSME1Protocol module unloaded\n"); +} + +module_init(FSME1Protocol_init); +module_exit(FSME1Protocol_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM E1 Protocol Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_Flash.c b/FSM/FSM_Flash.c new file mode 100644 index 00000000000000..75813102645ce0 --- /dev/null +++ b/FSM/FSM_Flash.c @@ -0,0 +1,240 @@ +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" +#include + +struct FSM_DeviceFunctionTree FSMFlash_dft; +struct FSM_DeviceTree* FSMFlash_dftv; +struct FSM_SendCmd FSMFlash_fsmsc; +struct FSMFlash_Control FSMFlash_flctl[FSM_FlasherSize]; +int FSM_FlashFirmwareOpen(struct FSM_DeviceTree* to_dt,int n) +{ + struct file *f; + int numb; + char filename[100]; + printk( KERN_INFO "Firmware Open" ); + sprintf(filename,"/fsm/firmware/t%uv%upv%uk%u.fsmflash", + to_dt->dt->type, + to_dt->dt->VidDevice, + to_dt->dt->PodVidDevice, + to_dt->dt->KodDevice); + f = filp_open( filename, O_RDONLY, 0 ); + if( IS_ERR( f ) ) { + printk( KERN_INFO "Firmware not found" ); + return -1; + } + numb = kernel_read( f, 0, (char*)&FSMFlash_flctl[n].firm, sizeof(struct FSMFirmware) ); + filp_close( f, NULL ); + if(!(numb)) return -2; + + return 0; +} +int FSM_FlashCheckData(int n) +{ + int i=0; + if(FSMFlash_flctl[n].firm.evec.crc32 != FSMFlash_flctl[n].firm.svec.crc32) return -1; + if(FSMFlash_flctl[n].firm.evec.size != FSMFlash_flctl[n].firm.svec.size) return -2; + for(i=0;i<128;i++) + { + if(FSM_crc32NT(0,FSMFlash_flctl[n].firm.dvec[i].Data,1024)!=FSMFlash_flctl[n].firm.dvec[i].crc32) + { + return -3-i; + } + if(FSMFlash_flctl[n].firm.dvec[i].num!=i) + { + return -3-i; + } + + } + return 0; +} +void FSM_FlashStart(struct FSM_DeviceTree* to_dt) +{ int i=0; + for(i=0;iIDDevice==to_dt->IDDevice) return; + } + for(i=0;iIDDevice; + memcpy(FSMFlash_fsmsc.Data,(char*)&FSMFlash_flctl[i].firm.svec,sizeof(struct FSMFlahData_StartVector)); + to_dt->TrDev->dt->Proc((char*)&FSMFlash_fsmsc,FSMH_Header_Size_SendCmd+sizeof(struct FSMFlahData_StartVector),to_dt->TrDev,to_dt); + break; + } + } + + +} +EXPORT_SYMBOL(FSM_FlashStart); + + +void FSM_FlashRecive(char* data, short len, struct FSM_DeviceTree* to_dt) +{ + int i; + + switch(((struct FSM_SendCmdTS*)data)->cmd) + { + case FSMFlash_Start: + printk( KERN_INFO "Firmware Flash Start" ); + FSMFlash_fsmsc.cmd=FSMFlash_Data; + FSMFlash_fsmsc.IDDevice=to_dt->IDDevice; + for(i=0;iIDDevice==to_dt->IDDevice) + { + memcpy(FSMFlash_fsmsc.Data,(char*)&FSMFlash_flctl[i].firm.dvec[0],sizeof(struct FSMFlahData_DataVector)); + to_dt->TrDev->dt->Proc((char*)&FSMFlash_fsmsc,FSMH_Header_Size_SendCmd+sizeof(struct FSMFlahData_DataVector),to_dt->TrDev,to_dt); + FSMFlash_flctl[i].state = (char)FSM_Flash_S_Data; + return; + } + } + + break; + case FSMFlash_Execute: + printk( KERN_ERR "Firmware Flash Execute" ); + FSMFlash_fsmsc.cmd=FSMFlash_Confirm; + FSMFlash_fsmsc.IDDevice=to_dt->IDDevice; + for(i=0;iIDDevice==to_dt->IDDevice) + { + if(FSMFlash_flctl[i].firm.evec.crc32!=((struct FSMFlahData_DataVerifeVector*)(((struct FSM_SendCmdTS*)data)->Data))->crc32) + { + FSMFlash_fsmsc.cmd=FSMFlash_Confirm; + to_dt->TrDev->dt->Proc((char*)&FSMFlash_fsmsc,FSMH_Header_Size_SendCmd,to_dt->TrDev,to_dt); + FSMFlash_flctl[i].reg=0; + FSMFlash_flctl[i].state = (char)FSM_Flash_S_End; + } + else + { + FSMFlash_fsmsc.cmd=FSMFlash_Execute; + memcpy(FSMFlash_fsmsc.Data,(char*)&FSMFlash_flctl[i].firm.evec,sizeof(struct FSMFlahData_EndVector)); + to_dt->TrDev->dt->Proc((char*)&FSMFlash_fsmsc,FSMH_Header_Size_SendCmd+sizeof(struct FSMFlahData_EndVector),to_dt->TrDev,to_dt); + } + return; + } + } + break; + case FSMFlash_Confirm: + + break; + case FSMFlash_Data: + printk( KERN_INFO "Firmware Flash Data %u,", ((struct FSMFlahData_DataVerifeVector*)(((struct FSM_SendCmdTS*)data)->Data))->num); + FSMFlash_fsmsc.cmd=FSMFlash_Data; + FSMFlash_fsmsc.IDDevice=to_dt->IDDevice; + for(i=0;iIDDevice==to_dt->IDDevice) + { + if(FSMFlash_flctl[i].firm.dvec[((struct FSMFlahData_DataVerifeVector*)(((struct FSM_SendCmdTS*)data)->Data))->num].crc32!=((struct FSMFlahData_DataVerifeVector*)(((struct FSM_SendCmdTS*)data)->Data))->crc32) + { + memcpy(FSMFlash_fsmsc.Data,(char*)&FSMFlash_flctl[i].firm.dvec[((struct FSMFlahData_DataVerifeVector*)(((struct FSM_SendCmdTS*)data)->Data))->num],sizeof(struct FSMFlahData_DataVector)); + printk( KERN_INFO "Firmware CRC Eror 0x%08x , 0x%08x",FSMFlash_flctl[i].firm.dvec[((struct FSMFlahData_DataVerifeVector*)(((struct FSM_SendCmdTS*)data)->Data))->num].crc32, ((struct FSMFlahData_DataVerifeVector*)(((struct FSM_SendCmdTS*)data)->Data))->crc32); + } + else + { + if(((struct FSMFlahData_DataVerifeVector*)(((struct FSM_SendCmdTS*)data)->Data))->num == 127) + { + FSMFlash_fsmsc.cmd=FSMFlash_Execute; + memcpy(FSMFlash_fsmsc.Data,(char*)&FSMFlash_flctl[i].firm.evec,sizeof(struct FSMFlahData_EndVector)); + to_dt->TrDev->dt->Proc((char*)&FSMFlash_fsmsc,FSMH_Header_Size_SendCmd+sizeof(struct FSMFlahData_EndVector),to_dt->TrDev,to_dt); + + return; + } + else + { + memcpy(FSMFlash_fsmsc.Data,(char*)&FSMFlash_flctl[i].firm.dvec[((struct FSMFlahData_DataVerifeVector*)(((struct FSM_SendCmdTS*)data)->Data))->num+1],sizeof(struct FSMFlahData_DataVector)); + } + } + to_dt->TrDev->dt->Proc((char*)&FSMFlash_fsmsc,FSMH_Header_Size_SendCmd+sizeof(struct FSMFlahData_DataVector),to_dt->TrDev,to_dt); + return; + } + } + break; + } +} +EXPORT_SYMBOL(FSM_FlashRecive); + +void +FSM_FlashDeviceRecive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + + struct FSM_SendCmdTS* fscts = (struct FSM_SendCmdTS*)data; + //int i; + // printk( KERN_INFO "FSM SIOCTL,%u \n",fscts->opcode ); + + switch(data[0]) { + case RegDevice: + FSM_Statstic_SetStatus(to_dt, "ok"); + break; + case SendCmdToServer: ///< Отправка команды серверу + break; + case PacketFromUserSpace: ///< Отправка команды серверу + switch(fscts->cmd) + { + case FSM_Flash_CTL_Flash: + printk( KERN_INFO "Firmware Find" ); + FSMFlash_dftv = FSM_FindDevice(((unsigned short*)fscts->Data)[0]); + if(FSMFlash_dftv == 0) { + return; + printk( KERN_INFO "Firmware ID Dev not Find" ); + } + FSM_FlashStart(FSMFlash_dftv); + break; + case FSM_Flash_CTL_GetStatus: + fscts->Data[0]=FSMFlash_flctl[fscts->Data[0]].state; + break; + } + break; + + + } +} + +static int __init FSMFlash_init(void) +{ + struct FSM_DeviceRegistr regp; + FSMFlash_dft.aplayp = 0; + FSMFlash_dft.type = (unsigned char)StatisticandConfig; + FSMFlash_dft.VidDevice = (unsigned char)FSMDeviceConfig; + FSMFlash_dft.PodVidDevice = (unsigned char)FSM_Flash; + FSMFlash_dft.KodDevice = (unsigned char)CTL_FSM_Flash; + FSMFlash_dft.Proc = FSM_FlashDeviceRecive; + FSMFlash_dft.config_len = 0; + FSM_DeviceClassRegister(FSMFlash_dft); + + regp.IDDevice = FSM_FlashID; + regp.VidDevice = FSMFlash_dft.VidDevice; + regp.PodVidDevice = FSMFlash_dft.PodVidDevice; + regp.KodDevice = FSMFlash_dft.KodDevice; + regp.type = FSMFlash_dft.type; + regp.opcode = RegDevice; + regp.CRC = 0; + FSM_DeviceRegister(regp); + + FSMFlash_fsmsc.opcode=SendCmdGlobalcmdToClient; + FSMFlash_fsmsc.countparam=1; + FSMFlash_fsmsc.CRC=0; + printk(KERN_INFO "FSM Flash loaded\n"); + return 0; +} +static void __exit FSMFlash_exit(void) +{ + FSM_ClassDeRegister(FSMFlash_dft); + printk(KERN_INFO "FSM Flash module unloaded\n"); +} +module_init(FSMFlash_init); +module_exit(FSMFlash_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM Flash Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_GPIO.c b/FSM/FSM_GPIO.c new file mode 100644 index 00000000000000..c171a06eb8904c --- /dev/null +++ b/FSM/FSM_GPIO.c @@ -0,0 +1,283 @@ +#include +#include +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" +struct i2c_adapter* FSM_GPIO_adapter = NULL; +struct i2c_board_info FSM_GPIO_info; +struct i2c_client* FSM_GPIO_gpioclient; +struct FSM_DeviceFunctionTree FSM_GPIO_dft; +static struct timer_list FSM_GPIO_Reset_timer; +static struct timer_list FSM_GPIO_Impulse_timer; +unsigned char fsm_gpio_eror = 0; +#define GPIO_RESET_PIN FSM_GPIO_Bit_1 +#define GPIO_EROR_PIN FSM_GPIO_Bit_0 + +void FSM_GPIO_SetBit(enum FSM_GPIO_Bit_Enum Pin) +{ + int data = 0; + +#ifdef FSM_GPIO_BLOCK + return; +#endif + data = i2c_smbus_read_byte_data(FSM_GPIO_gpioclient, 1); + printk(KERN_INFO "FSM GPIO Read %u \n", data); + data |= Pin; + i2c_smbus_write_byte_data(FSM_GPIO_gpioclient, 1, data); + printk(KERN_INFO "FSM GPIO Write %u \n", data); +} +EXPORT_SYMBOL(FSM_GPIO_SetBit); + +void FSM_GPIO_ReSetBit(enum FSM_GPIO_Bit_Enum Pin) +{ + + int data = 0; + +#ifdef FSM_GPIO_BLOCK + return; +#endif + + data = i2c_smbus_read_byte_data(FSM_GPIO_gpioclient, 1); + printk(KERN_INFO "FSM GPIO Read %u \n", data); + data &= ~Pin; + i2c_smbus_write_byte_data(FSM_GPIO_gpioclient, 1, data); + printk(KERN_INFO "FSM GPIO Write %u \n", data); +} +EXPORT_SYMBOL(FSM_GPIO_ReSetBit); + +void FSM_GPIO_Set_Input(enum FSM_GPIO_Bit_Enum Pin) +{ + int data = 0; + +#ifdef FSM_GPIO_BLOCK + return; +#endif + + data = i2c_smbus_read_byte_data(FSM_GPIO_gpioclient, 3); + data |= Pin; + i2c_smbus_write_byte_data(FSM_GPIO_gpioclient, 3, data); +} +EXPORT_SYMBOL(FSM_GPIO_Set_Input); + +void FSM_GPIO_Set_Output(enum FSM_GPIO_Bit_Enum Pin) +{ + int data = 0; + +#ifdef FSM_GPIO_BLOCK + return; +#endif + + data = i2c_smbus_read_byte_data(FSM_GPIO_gpioclient, 3); + data &= ~Pin; + i2c_smbus_write_byte_data(FSM_GPIO_gpioclient, 3, data); +} +EXPORT_SYMBOL(FSM_GPIO_Set_Output); + +unsigned char FSM_GPIO_Get_Status(enum FSM_GPIO_Bit_Enum Pin) +{ + + int data = 0; + +#ifdef FSM_GPIO_BLOCK + return 0; +#endif + + data = i2c_smbus_read_byte_data(FSM_GPIO_gpioclient, 3); + data &= Pin; + return data; +} +EXPORT_SYMBOL(FSM_GPIO_Get_Status); + +void FSM_GPIO_Reset_timer_callback(unsigned long data) +{ + FSM_GPIO_ReSetBit(GPIO_RESET_PIN); +} +EXPORT_SYMBOL(FSM_GPIO_Reset_timer_callback); + +void FSM_GPIO_Impulse_timer_callback(unsigned long data) +{ + if(fsm_gpio_eror) + FSM_GPIO_ReSetBit(GPIO_EROR_PIN); + else + FSM_GPIO_SetBit(GPIO_EROR_PIN); +} +EXPORT_SYMBOL(FSM_GPIO_Impulse_timer_callback); + +void FSM_GPIO_Reset(void) +{ + +#ifdef FSM_GPIO_BLOCK + return; +#endif + + FSM_GPIO_SetBit(GPIO_RESET_PIN); + mod_timer(&FSM_GPIO_Reset_timer, jiffies + msecs_to_jiffies(100)); +} +EXPORT_SYMBOL(FSM_GPIO_Reset); + +void FSM_GPIO_EventEror(void) +{ + +#ifdef FSM_GPIO_BLOCK + return; +#endif + + FSM_GPIO_ReSetBit(GPIO_EROR_PIN); + mod_timer(&FSM_GPIO_Impulse_timer, jiffies + msecs_to_jiffies(1000)); +} +EXPORT_SYMBOL(FSM_GPIO_EventEror); + +void FSM_GPIODeviceRecive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + // struct fsm_devices_config* fsmset; + // struct FSM_DeviceTree* fsdt; + // int i,j; + // short hlen; + // unsigned short tmp; + struct FSM_SendCmdTS* fscts = (struct FSM_SendCmdTS*)data; + + switch(data[0]) { + case RegDevice: + FSM_Statstic_SetStatus(to_dt, "ok"); + break; + case SendCmdToServer: ///< Отправка команды серверу + switch(fscts->cmd) { + } + break; + case PacketFromUserSpace: ///< Отправка команды серверу + switch(fscts->cmd) { + case FSM_OFF_Bit: + FSM_GPIO_SetBit(fscts->Data[0]); + break; + case FSM_ON_Bit: + FSM_GPIO_ReSetBit(fscts->Data[0]); + break; + case FSM_Reset_Bit: + FSM_GPIO_Reset(); + break; + case FSM_Event_Bit: + FSM_GPIO_EventEror(); + break; + case FSM_Eror_ON_Bit: + FSM_GPIO_ReSetBit(GPIO_EROR_PIN); + fsm_gpio_eror = 1; + break; + case FSM_Eror_OFF_Bit: + FSM_GPIO_SetBit(GPIO_EROR_PIN); + fsm_gpio_eror = 0; + break; + } + break; + } +} + +static int __init FSM_GPIO_init(void) +{ + + struct FSM_DeviceRegistr regp; + + int i = 0, found = 0; + +#ifdef FSM_GPIO_BLOCK + goto fail; +#endif + + memset(&FSM_GPIO_info, 0, sizeof(struct i2c_board_info)); + FSM_GPIO_adapter = i2c_get_adapter(i++); + + while(FSM_GPIO_adapter) { + printk(KERN_ERR "Scan %s", FSM_GPIO_adapter->name); + if(strncmp(FSM_GPIO_adapter->name, "SMBus", 5) == 0) { + found = 1; + break; + } + FSM_GPIO_adapter = i2c_get_adapter(i++); + } + if(!found) + goto fail; + + FSM_GPIO_info.addr = 0x72; + FSM_GPIO_info.platform_data = "fsm_pca9538"; + strncpy(FSM_GPIO_info.type, "fsm_pca9538", I2C_NAME_SIZE); + FSM_GPIO_gpioclient = i2c_new_device(FSM_GPIO_adapter, &FSM_GPIO_info); + + if(FSM_GPIO_gpioclient == NULL) { + printk(KERN_ERR "failed to attach GPIO\n"); + goto fail; + } + + i2c_smbus_write_byte_data(FSM_GPIO_gpioclient, 3, 0); + + FSM_GPIO_Set_Output(FSM_GPIO_Bit_0); + FSM_GPIO_Set_Output(FSM_GPIO_Bit_1); + + FSM_GPIO_Set_Output(FSM_GPIO_Bit_2); + FSM_GPIO_Set_Output(FSM_GPIO_Bit_3); + + FSM_GPIO_Set_Output(FSM_GPIO_Bit_4); + FSM_GPIO_Set_Output(FSM_GPIO_Bit_5); + + FSM_GPIO_Set_Output(FSM_GPIO_Bit_6); + FSM_GPIO_Set_Output(FSM_GPIO_Bit_7); + + FSM_GPIO_ReSetBit(FSM_GPIO_Bit_0); + FSM_GPIO_ReSetBit(FSM_GPIO_Bit_1); + + FSM_GPIO_ReSetBit(FSM_GPIO_Bit_2); + FSM_GPIO_ReSetBit(FSM_GPIO_Bit_3); + + FSM_GPIO_ReSetBit(FSM_GPIO_Bit_4); + FSM_GPIO_ReSetBit(FSM_GPIO_Bit_5); + + FSM_GPIO_ReSetBit(FSM_GPIO_Bit_6); + FSM_GPIO_ReSetBit(FSM_GPIO_Bit_7); + + FSM_GPIO_dft.aplayp = 0; + FSM_GPIO_dft.type = (unsigned char)ControlMachine; + FSM_GPIO_dft.VidDevice = (unsigned char)Device; + FSM_GPIO_dft.PodVidDevice = (unsigned char)GPIO; + FSM_GPIO_dft.KodDevice = (unsigned char)Bit_8; + FSM_GPIO_dft.Proc = FSM_GPIODeviceRecive; + FSM_GPIO_dft.config_len = 0; + FSM_DeviceClassRegister(FSM_GPIO_dft); + + regp.IDDevice = FSM_GPIOID; + regp.VidDevice = FSM_GPIO_dft.VidDevice; + regp.PodVidDevice = FSM_GPIO_dft.PodVidDevice; + regp.KodDevice = FSM_GPIO_dft.KodDevice; + regp.type = FSM_GPIO_dft.type; + regp.opcode = RegDevice; + regp.CRC = 0; + FSM_DeviceRegister(regp); + + setup_timer(&FSM_GPIO_Reset_timer, FSM_GPIO_Reset_timer_callback, 0); + setup_timer(&FSM_GPIO_Impulse_timer, FSM_GPIO_Impulse_timer_callback, 0); + fsm_gpio_eror = 0; + FSM_GPIO_Reset(); + FSM_GPIO_EventEror(); + + printk(KERN_INFO "FSM GPIO loaded\n"); + return 0; + +fail: + printk(KERN_ERR "Fail to fount GPIO\n"); + return 0; +} + +static void __exit FSM_GPIO_exit(void) +{ + FSM_ClassDeRegister(FSM_GPIO_dft); + i2c_unregister_device(FSM_GPIO_gpioclient); + del_timer(&FSM_GPIO_Reset_timer); + del_timer(&FSM_GPIO_Impulse_timer); + printk(KERN_INFO "FSM GPIO unloaded\n"); +} + + +module_init(FSM_GPIO_init); +module_exit(FSM_GPIO_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM GPIO Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_MN111Device.c b/FSM/FSM_MN111Device.c new file mode 100644 index 00000000000000..6f6254f025680e --- /dev/null +++ b/FSM/FSM_MN111Device.c @@ -0,0 +1,310 @@ +/*! +\file +\brief Модуль взаимодествия с пультом MN111 +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +struct FSM_DeviceFunctionTree FSMMN111_dft; +struct FSM_MN111Device FSMMN111Dev[FSM_MN111DeviceTreeSize]; +struct FSM_SendCmd FSMMN111_sendcmd; +struct FSM_AudioStream FSMMN111_fsmas; + +static struct timer_list FSM_MN111_timer; + +void FSM_MN111SendStreaminfo(unsigned short id, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + short plen; + + memset(&FSMMN111_sendcmd, 0, sizeof(struct FSM_SendCmd)); + FSMMN111_sendcmd.opcode = SendCmdToDevice; + FSMMN111_sendcmd.IDDevice = from_dt->IDDevice; + FSMMN111_sendcmd.cmd = FSMPO06SendStream; + FSMMN111_sendcmd.countparam = 1; + ((unsigned short*)FSMMN111_sendcmd.Data)[0] = id; + if(to_dt->debug) + printk(KERN_INFO "FSM Send %u ,%u \n", FSMMN111_sendcmd.Data[0], FSMMN111_sendcmd.Data[1]); + FSMMN111_sendcmd.CRC = 0; + plen = sizeof(struct FSM_SendCmd) - sizeof(FSMMN111_sendcmd.Data) + 2; + if(to_dt != 0) + to_dt->dt->Proc((char*)&FSMMN111_sendcmd, plen, to_dt, from_dt); +} + +void FSM_TestVoltage(struct FSM_DeviceTree* to_dt, unsigned short cmd) +{ + FSMMN111_sendcmd.opcode = PacketToDevice; + FSMMN111_sendcmd.IDDevice = to_dt->IDDevice; + FSMMN111_sendcmd.cmd = cmd; + to_dt->dt->Proc((char*)&FSMMN111_sendcmd, sizeof(struct FSM_SendCmd), to_dt, to_dt); +} +void FSM_Test_Callback(unsigned long data) +{ + int i; + for(i = 0; i < FSM_MN111DeviceTreeSize; i++) { + if(FSMMN111Dev[i].reg == 0) + break; + switch(FSMMN111Dev[i].vst.sel) { + case 0: + FSM_TestVoltage(FSMMN111Dev[i].fsms, FSM_Get_MN111_Power_5V); + break; + case 1: + FSM_TestVoltage(FSMMN111Dev[i].fsms, FSM_Get_MN111_Power_n5V); + break; + case 2: + FSM_TestVoltage(FSMMN111Dev[i].fsms, FSM_Get_MN111_Power_n60V); + break; + case 3: + FSM_TestVoltage(FSMMN111Dev[i].fsms, FSM_Get_MN111_Power_90V); + break; + case 4: + FSM_TestVoltage(FSMMN111Dev[i].fsms, FSM_Get_MN111_Power_220V); + break; + } + FSMMN111Dev[i].vst.sel++; + if(FSMMN111Dev[i].vst.sel >= 5) + FSMMN111Dev[i].vst.sel = 0; + } + mod_timer(&FSM_MN111_timer, jiffies + msecs_to_jiffies(1000)); +} +void FSM_MN111Recive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + int i; + + struct FSM_SendCmdTS* scmd = (struct FSM_SendCmdTS*)data; + struct FSM_MN111Device* mn111 = (struct FSM_MN111Device*)to_dt->data; +// char datas[2]; + + switch(data[0]) { + + case RegDevice: ///< Регистрация устройства + FSM_Statstic_SetStatus(to_dt, "ok"); + for(i = 0; i < FSM_MN111DeviceTreeSize; i++) { + if(FSMMN111Dev[i].iddev == to_dt->IDDevice) { + FSM_MN111SendStreaminfo(FSMMN111Dev[i].idstream, from_dt, to_dt); + // FSM_TestVoltage(to_dt); + return; + } + } + for(i = 0; i < FSM_MN111DeviceTreeSize; i++) { + if(FSMMN111Dev[i].reg == 0) { + FSMMN111Dev[i].reg = 1; + FSMMN111Dev[i].ethdev = FSM_FindEthernetDevice(to_dt->IDDevice); + FSMMN111_fsmas.iddev = to_dt->IDDevice; + // fsmas.ToProcess=FSM_PO06RecivePacket; + // fsmas.ToUser=FSM_E1SendPacket; + FSMMN111_fsmas.TransportDevice = FSMMN111Dev[i].ethdev->numdev; + FSMMN111_fsmas.TransportDeviceType = FSM_EthernetID2; + FSMMN111_fsmas.Data = &FSMMN111Dev[i]; + FSMMN111Dev[i].idstream = FSM_AudioStreamRegistr(FSMMN111_fsmas); + FSMMN111Dev[i].iddev = to_dt->IDDevice; + to_dt->TrDev = from_dt; + to_dt->data = &FSMMN111Dev[i]; + to_dt->config = &FSMMN111Dev[i].mn111set; + FSM_MN111SendStreaminfo(FSMMN111Dev[i].idstream, from_dt, to_dt); + if(to_dt->debug) + printk(KERN_INFO "FSM MN111 Device Added %u \n", to_dt->IDDevice); + FSMMN111Dev[i].fsms = to_dt; + // FSM_TestVoltage(to_dt); + + // datas[0]=0xd0; + // datas[1]=0xd1; + // FSM_AudioStreamToUser(0,datas,2); + break; + } + } + + break; + case DelLisr: + for(i = 0; i < FSM_MN111DeviceTreeSize; i++) { + if((FSMMN111Dev[i].reg == 1) && (FSMMN111Dev[i].iddev == to_dt->IDDevice)) { + + FSM_AudioStreamUnRegistr(FSMMN111Dev[i].idstream); + FSMMN111Dev[i].reg = 0; + if(to_dt->debug) + printk(KERN_INFO "FSM MN111 Device Deleted %u \n", to_dt->IDDevice); + break; + } + } + break; + case AnsPing: ///< Пинг + break; + case SendCmdToServer: ///< Отправка команды серверу + switch(scmd->cmd) { + case FSM_Ans_Get_MN111_Power_5V: + mn111->vst.MN111_Power_5V.value = ((unsigned short*)scmd->Data)[0]; + mn111->vst.MN111_Power_5V.newdata = 1; + printk(KERN_WARNING "MN111 %u: 5V: %u \n", scmd->IDDevice, ((unsigned short*)scmd->Data)[0]); + break; + + case FSM_Ans_Get_MN111_Power_n5V: + mn111->vst.MN111_Power_n5V.value = ((unsigned short*)scmd->Data)[0]; + mn111->vst.MN111_Power_n5V.newdata = 1; + printk(KERN_WARNING "MN111 %u: -5V: %u \n", scmd->IDDevice, ((unsigned short*)scmd->Data)[0]); + break; + case FSM_Ans_Get_MN111_Power_n60V: + mn111->vst.MN111_Power_n60V.value = ((unsigned short*)scmd->Data)[0]; + mn111->vst.MN111_Power_n60V.newdata = 1; + printk(KERN_WARNING "MN111 %u: -60V: %u \n", scmd->IDDevice, ((unsigned short*)scmd->Data)[0]); + break; + case FSM_Ans_Get_MN111_Power_90V: + mn111->vst.MN111_Power_90V.value = ((unsigned short*)scmd->Data)[0]; + mn111->vst.MN111_Power_90V.newdata = 1; + printk(KERN_WARNING "MN111 %u: 90V: %u \n", scmd->IDDevice, ((unsigned short*)scmd->Data)[0]); + break; + case FSM_Ans_Get_MN111_Power_220V: + mn111->vst.MN111_Power_220V.value = ((unsigned short*)scmd->Data)[0]; + mn111->vst.MN111_Power_220V.newdata = 1; + printk(KERN_WARNING "MN111 %u: 220V: %u \n", scmd->IDDevice, ((unsigned short*)scmd->Data)[0]); + break; + } + + break; + case SendTxtMassage: ///< Отправка текстового сообщения + break; + case Alern: ///<Тревога + switch(((struct FSM_AlernSignal*)data)->ID) { + } + break; + case Warning: ///<Предупреждение + switch(((struct FSM_WarningSignal*)data)->ID) { + case FSM_CCK_Server_Connect_Error: + printk(KERN_WARNING "MN111 %u: Server Not Connect \n", ((struct FSM_Header*)(data))->IDDevice); + break; + case FSM_MN111_Power_5V_Error: + printk(KERN_WARNING "MN111 %u: 5V Error \n", ((struct FSM_Header*)(data))->IDDevice); + break; + case FSM_MN111_Power_n5V_Error: + printk(KERN_WARNING "MN111 %u: -5V Error \n", ((struct FSM_Header*)(data))->IDDevice); + break; + case FSM_MN111_Power_n60V_Error: + printk(KERN_WARNING "MN111 %u: -60V Error \n", ((struct FSM_Header*)(data))->IDDevice); + break; + case FSM_MN111_Power_90V_Error: + printk(KERN_WARNING "MN111 %u: 90V Error \n", ((struct FSM_Header*)(data))->IDDevice); + break; + case FSM_MN111_Power_220V_Error: + printk(KERN_WARNING "MN111 %u: 220V Error \n", ((struct FSM_Header*)(data))->IDDevice); + break; + } + break; + case Trouble: ///<Сбой + switch(((struct FSM_TroubleSignal*)data)->ID) { + case FSM_CCK_Memory_Test_Filed: + printk(KERN_ERR "MN111 %u: Memory Error \n", ((struct FSM_Header*)(data))->IDDevice); + break; + } + break; + case Beep: ///<Звук + break; + case PacketFromUserSpace: + switch(scmd->cmd) { + + case FSM_Get_MN111_Power_5V: + case FSM_Get_MN111_Power_n5V: + case FSM_Get_MN111_Power_n60V: + case FSM_Get_MN111_Power_90V: + case FSM_Get_MN111_Power_220V: + scmd->IDDevice = to_dt->IDDevice; + scmd->opcode = SendCmdToDevice; + to_dt->TrDev->dt->Proc((char*)scmd, FSMH_Header_Size_SendCmd, to_dt->TrDev, to_dt); + // printk( KERN_ERR "MN111 %u: Reqest\n",((struct FSM_Header*)(data))->IDDevice); + break; + case FSM_Read_MN111_Power_5V: + ((unsigned short*)scmd->Data)[0] = mn111->vst.MN111_Power_5V.value; + break; + case FSM_Read_MN111_Power_n5V: + ((unsigned short*)scmd->Data)[0] = mn111->vst.MN111_Power_n5V.value; + break; + case FSM_Read_MN111_Power_n60V: + ((unsigned short*)scmd->Data)[0] = mn111->vst.MN111_Power_n60V.value; + break; + case FSM_Read_MN111_Power_90V: + ((unsigned short*)scmd->Data)[0] = mn111->vst.MN111_Power_90V.value; + break; + case FSM_Read_MN111_Power_220V: + ((unsigned short*)scmd->Data)[0] = mn111->vst.MN111_Power_220V.value; + break; + case FSM_Read_MN111_AutoReqest: + mod_timer(&FSM_MN111_timer, jiffies + msecs_to_jiffies(1000)); + break; + } + break; + case PacketToDevice: + switch(scmd->cmd) { + + case FSM_Get_MN111_Power_5V: + case FSM_Get_MN111_Power_n5V: + case FSM_Get_MN111_Power_n60V: + case FSM_Get_MN111_Power_90V: + case FSM_Get_MN111_Power_220V: + scmd->IDDevice = to_dt->IDDevice; + scmd->opcode = SendCmdToDevice; + to_dt->TrDev->dt->Proc((char*)scmd, FSMH_Header_Size_SendCmd, to_dt->TrDev, to_dt); + break; + } + break; + default: + break; + } + if(to_dt->debug) + printk(KERN_INFO "RPack %u \n", len); +} +EXPORT_SYMBOL(FSM_MN111Recive); +void ApplaySettingMN111(struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + memset(&FSMMN111_sendcmd, 0, sizeof(FSMMN111_sendcmd)); + if(to_dt->debug) + printk(KERN_INFO "FSM_Set\n"); + FSMMN111_sendcmd.cmd = SetSettingClientMN111; + FSMMN111_sendcmd.countparam = 1; + FSMMN111_sendcmd.IDDevice = to_dt->IDDevice; + FSMMN111_sendcmd.CRC = 0; + FSMMN111_sendcmd.opcode = SendCmdToDevice; + memcpy(&FSMMN111_sendcmd.Data, + &(((struct FSM_MN111Device*)to_dt->data)->mn111set.fsm_mn111_su_s), + sizeof(struct fsm_mn111_subscriber)); + from_dt->dt->Proc((char*)&FSMMN111_sendcmd, + sizeof(struct FSM_SendCmd) - sizeof(FSMMN111_sendcmd.Data) + sizeof(struct fsm_mn111_subscriber), + from_dt, + to_dt); +} + +static int __init FSM_MN111_init(void) +{ + + + FSMMN111_dft.aplayp = ApplaySettingMN111; + FSMMN111_dft.type = (unsigned char)AudioDevice; + FSMMN111_dft.VidDevice = (unsigned char)CommunicationDevice; + FSMMN111_dft.PodVidDevice = (unsigned char)CCK; + FSMMN111_dft.KodDevice = (unsigned char)MN111; + FSMMN111_dft.Proc = FSM_MN111Recive; + FSMMN111_dft.config_len = sizeof(struct fsm_mn111_setting); + FSM_DeviceClassRegister(FSMMN111_dft); + printk(KERN_INFO "FSM MN111 Module loaded\n"); + FSM_SendEventToAllDev(FSM_CCK_MN111_Started); + setup_timer(&FSM_MN111_timer, FSM_Test_Callback, 0); + + return 0; +} + +static void __exit FSM_MN111_exit(void) +{ + FSM_ClassDeRegister(FSMMN111_dft); + del_timer(&FSM_MN111_timer); + + printk(KERN_INFO "FSM MN111 Module unloaded\n"); +} + +module_init(FSM_MN111_init); +module_exit(FSM_MN111_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM MN111 Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_MN825Device.c b/FSM/FSM_MN825Device.c new file mode 100644 index 00000000000000..01c4c0ec928ec5 --- /dev/null +++ b/FSM/FSM_MN825Device.c @@ -0,0 +1,227 @@ +/*! +\file +\brief Модуль взаимодествия с пультом ПО-06 +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#include +#include +#include + +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +struct CCKDeviceInfo FSMMN825_CCKDevE; +struct FSM_DeviceFunctionTree FSMMN825_dft; +struct FSM_MN825Device FSMMN825Dev[FSM_MN825DeviceTreeSize]; +struct FSM_SendCmd FSMMN825_sendcmd; +struct FSM_AudioStream FSMMN825_fsmas; + +void FSM_MN825SendStreaminfo(unsigned short id, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + short plen; + + + memset(&FSMMN825_sendcmd, 0, sizeof(struct FSM_SendCmd)); + FSMMN825_sendcmd.opcode = SendCmdToDevice; + FSMMN825_sendcmd.IDDevice = from_dt->IDDevice; + FSMMN825_sendcmd.cmd = FSMPO06SendStream; + FSMMN825_sendcmd.countparam = 1; + ((unsigned short*)FSMMN825_sendcmd.Data)[0] = id; + if(to_dt->debug) + printk(KERN_INFO "FSM Send %u ,%u \n", FSMMN825_sendcmd.Data[0], FSMMN825_sendcmd.Data[1]); + FSMMN825_sendcmd.CRC = 0; + plen = sizeof(struct FSM_SendCmd) - sizeof(FSMMN825_sendcmd.Data) + 2; + if(to_dt != 0) + to_dt->dt->Proc((char*)&FSMMN825_sendcmd, plen, to_dt, from_dt); +} + +void FSM_MN825Recive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + int i; + + struct FSM_SendCmdTS* scmd = (struct FSM_SendCmdTS*)data; +// char datas[2]; + + switch(data[0]) { + + case RegDevice: ///< Регистрация устройства + FSM_Statstic_SetStatus(to_dt, "ok"); + for(i = 0; i < FSM_MN825DeviceTreeSize; i++) { + if(FSMMN825Dev[i].iddev == to_dt->IDDevice) { + FSM_MN825SendStreaminfo(FSMMN825Dev[i].idstream, from_dt, to_dt); + return; + } + } + for(i = 0; i < FSM_MN825DeviceTreeSize; i++) { + if(FSMMN825Dev[i].reg == 0) { + FSMMN825Dev[i].reg = 1; + FSMMN825Dev[i].ethdev = FSM_FindEthernetDevice(to_dt->IDDevice); + FSMMN825_fsmas.iddev = to_dt->IDDevice; + // fsmas.ToProcess=FSM_PO06RecivePacket; + // fsmas.ToUser=FSM_E1SendPacket; + FSMMN825_fsmas.TransportDevice = FSMMN825Dev[i].ethdev->numdev; + FSMMN825_fsmas.TransportDeviceType = FSM_EthernetID2; + FSMMN825_fsmas.Data = &FSMMN825Dev[i]; + FSMMN825Dev[i].idstream = FSM_AudioStreamRegistr(FSMMN825_fsmas); + FSMMN825Dev[i].iddev = to_dt->IDDevice; + to_dt->data = &FSMMN825Dev[i]; + to_dt->config = &FSMMN825Dev[i].mn825set; + FSM_MN825SendStreaminfo(FSMMN825Dev[i].idstream, from_dt, to_dt); + if(to_dt->debug) + printk(KERN_INFO "FSM MN825 Device Added %u \n", to_dt->IDDevice); + ; + + // datas[0]=0xd0; + // datas[1]=0xd1; + // FSM_AudioStreamToUser(0,datas,2); + break; + } + } + break; + case DelLisr: + for(i = 0; i < FSM_MN825DeviceTreeSize; i++) { + if((FSMMN825Dev[i].reg == 1) && (FSMMN825Dev[i].iddev == to_dt->IDDevice)) { + + FSM_AudioStreamUnRegistr(FSMMN825Dev[i].idstream); + FSMMN825Dev[i].reg = 0; + if(to_dt->debug) + printk(KERN_INFO "FSM MN825 Device Deleted %u \n", to_dt->IDDevice); + break; + } + } + break; + case AnsPing: ///< Пинг + break; + case SendCmdToServer: ///< Отправка команды серверу + switch(scmd->cmd) { + case FSMMN825ConnectToDevE1: + // ((struct FSM_PO06Device*)((FSM_FindDevice(scmd->IDDevice))->data))->idcon=FSM_P2P_Connect(((struct + // FSM_PO06Device*)((FSM_FindDevice(scmd->IDDevice))->data))->idstream, ((struct + // FSM_E1Device*)(FSM_FindDevice(((struct FSMPO06CommCons*)scmd->Data)->id)->data))->streams_id[((struct + // FSMPO06CommCons*)scmd->Data)->channel]); + break; + case FSMMN825DisConnectToDevE1: + FSM_P2P_Disconnect(((struct FSM_PO06Device*)(to_dt->data))->idcon); + break; + case AnsGetSettingClientMN825: + if(to_dt->debug) + printk(KERN_INFO "FSM_Set Recv %i\n", scmd->IDDevice); + memcpy(&((struct fsm_po06_setting*)(to_dt->config))->fsm_p006_su_s, scmd->Data, to_dt->dt->config_len); + break; + case FSMMN825SendIP: + FSMMN825_CCKDevE.id = scmd->IDDevice; + FSMMN825_CCKDevE.ip[0] = scmd->Data[0]; + FSMMN825_CCKDevE.ip[1] = scmd->Data[1]; + FSMMN825_CCKDevE.ip[2] = scmd->Data[2]; + FSMMN825_CCKDevE.ip[3] = scmd->Data[3]; + FSMMN825_CCKDevE.type = MN825; + FSMMN825_CCKDevE.Position = scmd->Data[4]; + FSMCCK_AddDeviceInfo(&FSMMN825_CCKDevE); + if(to_dt->debug) + printk(KERN_INFO "FSM ID%i Asterisk IP %i.%i.%i.%i\n ", + scmd->IDDevice, + scmd->Data[0], + scmd->Data[1], + scmd->Data[2], + scmd->Data[3]); + break; + } + + break; + case SendTxtMassage: ///< Отправка текстового сообщения + break; + case Alern: ///<Тревога + switch(((struct FSM_AlernSignal*)data)->ID) { + } + break; + case Warning: ///<Предупреждение + switch(((struct FSM_WarningSignal*)data)->ID) { + case FSM_CCK_Server_Connect_Error: + printk(KERN_WARNING "MN825 %u: Server Not Connect \n", ((struct FSM_Header*)(data))->IDDevice); + break; + } + break; + case Trouble: ///<Сбой + switch(((struct FSM_TroubleSignal*)data)->ID) { + case FSM_CCK_Memory_Test_Filed: + printk(KERN_ERR "MN825 %u: Memory Error \n", ((struct FSM_Header*)(data))->IDDevice); + break; + } + break; + case Beep: ///<Звук + break; + case PacketFromUserSpace: + switch(scmd->cmd) { + case FSMMN825AudioRun: + case FSMMN825Reset: + case FSMMN825Reregister: + case FSMMN825SetTangenta: + scmd->IDDevice = to_dt->IDDevice; + scmd->opcode = SendCmdToDevice; + to_dt->TrDev->dt->Proc((char*)scmd, FSMH_Header_Size_SendCmd, to_dt->TrDev, to_dt); + break; + case FSMMN825GetCRC: + + break; + } + break; + default: + break; + } + + if(to_dt->debug) + printk(KERN_INFO "RPack %u \n", len); +} +EXPORT_SYMBOL(FSM_MN825Recive); +void ApplaySettingMN825(struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + + memset(&FSMMN825_sendcmd, 0, sizeof(FSMMN825_sendcmd)); + if(to_dt->debug) + printk(KERN_INFO "FSM_Set\n"); + FSMMN825_sendcmd.cmd = SetSettingClientMN825; + FSMMN825_sendcmd.countparam = 1; + FSMMN825_sendcmd.IDDevice = to_dt->IDDevice; + FSMMN825_sendcmd.CRC = 0; + FSMMN825_sendcmd.opcode = SendCmdToDevice; + memcpy(&FSMMN825_sendcmd.Data, + &(((struct FSM_MN825Device*)to_dt->data)->mn825set.fsm_mn825_su_s), + sizeof(struct fsm_mn825_subscriber)); + from_dt->dt->Proc((char*)&FSMMN825_sendcmd, + sizeof(struct FSM_SendCmd) - sizeof(FSMMN825_sendcmd.Data) + sizeof(struct fsm_mn825_subscriber), + from_dt, + to_dt); +} + +static int __init FSM_MN825_init(void) +{ + + + FSMMN825_dft.aplayp = ApplaySettingMN825; + FSMMN825_dft.type = (unsigned char)AudioDevice; + FSMMN825_dft.VidDevice = (unsigned char)CommunicationDevice; + FSMMN825_dft.PodVidDevice = (unsigned char)CCK; + FSMMN825_dft.KodDevice = (unsigned char)MN825; + FSMMN825_dft.Proc = FSM_MN825Recive; + FSMMN825_dft.config_len = sizeof(struct fsm_mn825_setting); + FSM_DeviceClassRegister(FSMMN825_dft); + printk(KERN_INFO "FSM MN825 Module loaded\n"); + FSM_SendEventToAllDev(FSM_CCK_MN845_Started); + + return 0; +} + +static void __exit FSM_MN825_exit(void) +{ + FSM_ClassDeRegister(FSMMN825_dft); + printk(KERN_INFO "FSM MN825 Module unloaded\n"); +} + +module_init(FSM_MN825_init); +module_exit(FSM_MN825_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM MN825 Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_MN921Device.c b/FSM/FSM_MN921Device.c new file mode 100644 index 00000000000000..b93ae88066a679 --- /dev/null +++ b/FSM/FSM_MN921Device.c @@ -0,0 +1,236 @@ +/*! +\file +\brief Модуль взаимодествия с пультом ПО-06 +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +struct CCKDeviceInfo FSMMN921_CCKDevE; +struct FSM_DeviceFunctionTree FSMMN921_dft; +struct FSM_MN921Device FSMMN921Dev[FSM_MN921DeviceTreeSize]; +struct FSM_SendCmd FSMMN921_sendcmd; +struct FSM_AudioStream FSMMN921_fsmas; + + +void FSM_MN921SendStreaminfo(unsigned short id, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + short plen; + + memset(&FSMMN921_sendcmd, 0, sizeof(struct FSM_SendCmd)); + FSMMN921_sendcmd.opcode = SendCmdToDevice; + FSMMN921_sendcmd.IDDevice = from_dt->IDDevice; + FSMMN921_sendcmd.cmd = FSMPO06SendStream; + FSMMN921_sendcmd.countparam = 1; + ((unsigned short*)FSMMN921_sendcmd.Data)[0] = id; + if(to_dt->debug) + printk(KERN_INFO "FSM Send %u ,%u \n", FSMMN921_sendcmd.Data[0], FSMMN921_sendcmd.Data[1]); + FSMMN921_sendcmd.CRC = 0; + plen = sizeof(struct FSM_SendCmd) - sizeof(FSMMN921_sendcmd.Data) + 2; + if(to_dt != 0) + to_dt->dt->Proc((char*)&FSMMN921_sendcmd, plen, to_dt, from_dt); +} + +void FSM_MN921Recive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + int i; + unsigned char fsm_mn_crc32[4]; + unsigned char fsm_mn_ramst[2]; + struct FSM_SendCmdTS* scmd = (struct FSM_SendCmdTS*)data; +// char datas[2]; + + switch(data[0]) { + + case RegDevice: ///< Регистрация устройства + FSM_Statstic_SetStatus(to_dt, "ok"); + FSM_SetTreeAdd(to_dt); + for(i = 0; i < FSM_MN921DeviceTreeSize; i++) { + if(FSMMN921Dev[i].iddev == to_dt->IDDevice) { + FSM_MN921SendStreaminfo(FSMMN921Dev[i].idstream, from_dt, to_dt); + return; + } + } + for(i = 0; i < FSM_MN921DeviceTreeSize; i++) { + if(FSMMN921Dev[i].reg == 0) { + FSMMN921Dev[i].reg = 1; + FSMMN921Dev[i].ethdev = FSM_FindEthernetDevice(to_dt->IDDevice); + FSMMN921_fsmas.iddev = to_dt->IDDevice; + // fsmas.ToProcess=FSM_PO06RecivePacket; + // fsmas.ToUser=FSM_E1SendPacket; + FSMMN921_fsmas.TransportDevice = FSMMN921Dev[i].ethdev->numdev; + FSMMN921_fsmas.TransportDeviceType = FSM_EthernetID2; + FSMMN921_fsmas.Data = &FSMMN921Dev[i]; + FSMMN921Dev[i].idstream = FSM_AudioStreamRegistr(FSMMN921_fsmas); + FSMMN921Dev[i].iddev = to_dt->IDDevice; + to_dt->data = &FSMMN921Dev[i]; + to_dt->config = &FSMMN921Dev[i].mn921set; + FSM_MN921SendStreaminfo(FSMMN921Dev[i].idstream, from_dt, to_dt); + if(to_dt->debug) + printk(KERN_INFO "FSM MN921 Device Added %u \n", to_dt->IDDevice); + ; + + // datas[0]=0xd0; + // datas[1]=0xd1; + // FSM_AudioStreamToUser(0,datas,2); + break; + } + } + break; + case DelLisr: + for(i = 0; i < FSM_MN921DeviceTreeSize; i++) { + if((FSMMN921Dev[i].reg == 1) && (FSMMN921Dev[i].iddev == to_dt->IDDevice)) { + + FSM_AudioStreamUnRegistr(FSMMN921Dev[i].idstream); + FSMMN921Dev[i].reg = 0; + if(to_dt->debug) + printk(KERN_INFO "FSM MN921 Device Deleted %u \n", to_dt->IDDevice); + break; + } + } + break; + case AnsPing: ///< Пинг + break; + case SendCmdToServer: ///< Отправка команды серверу + switch(scmd->cmd) { + case FSMMN921ConnectToDevE1: + // ((struct FSM_PO06Device*)((FSM_FindDevice(scmd->IDDevice))->data))->idcon=FSM_P2P_Connect(((struct + // FSM_PO06Device*)((FSM_FindDevice(scmd->IDDevice))->data))->idstream, ((struct + // FSM_E1Device*)(FSM_FindDevice(((struct FSMPO06CommCons*)scmd->Data)->id)->data))->streams_id[((struct + // FSMPO06CommCons*)scmd->Data)->channel]); + break; + case FSMMN921DisConnectToDevE1: + FSM_P2P_Disconnect(((struct FSM_PO06Device*)(to_dt->data))->idcon); + break; + case AnsGetSettingClientMN921: + if(to_dt->debug) + printk(KERN_INFO "FSM_Set Recv %i\n", scmd->IDDevice); + memcpy(&((struct fsm_po06_setting*)(to_dt->config))->fsm_p006_su_s, scmd->Data, to_dt->dt->config_len); + break; + case FSMMN921SendIP: + FSMMN921_CCKDevE.id = scmd->IDDevice; + FSMMN921_CCKDevE.ip[0] = scmd->Data[0]; + FSMMN921_CCKDevE.ip[1] = scmd->Data[1]; + FSMMN921_CCKDevE.ip[2] = scmd->Data[2]; + FSMMN921_CCKDevE.ip[3] = scmd->Data[3]; + FSMMN921_CCKDevE.type = MN921; + FSMMN921_CCKDevE.Position = scmd->Data[4]; + fsm_mn_crc32[0] = scmd->Data[5]; + fsm_mn_crc32[1] = scmd->Data[6]; + fsm_mn_crc32[2] = scmd->Data[7]; + fsm_mn_crc32[3] = scmd->Data[8]; + FSMMN921_CCKDevE.crc32=((unsigned int*)fsm_mn_crc32)[0]; + fsm_mn_ramst[0] = scmd->Data[9]; + fsm_mn_ramst[1] = scmd->Data[10]; + FSMMN921_CCKDevE.dstlen=((unsigned short*)fsm_mn_ramst)[0]; + FSMMN921_CCKDevE.dstlen=scmd->Data[11]; + FSMCCK_AddDeviceInfo(&FSMMN921_CCKDevE); + if(to_dt->debug) + printk(KERN_INFO "FSM MN921 ID%i Asterisk IP %i.%i.%i.%i\n ", + scmd->IDDevice, + scmd->Data[0], + scmd->Data[1], + scmd->Data[2], + scmd->Data[3]); + break; + } + + break; + case SendTxtMassage: ///< Отправка текстового сообщения + break; + case PacketFromUserSpace: + switch(scmd->cmd) { + case FSMMN921AudioRun: + case FSMMN921Reset: + case FSMMN921Reregister: + scmd->IDDevice = to_dt->IDDevice; + scmd->opcode = SendCmdToDevice; + to_dt->TrDev->dt->Proc((char*)scmd, FSMH_Header_Size_SendCmd, to_dt->TrDev, to_dt); + break; + case FSMMN921GetCRC: + + break; + } + break; + case Alern: ///<Тревога + switch(((struct FSM_AlernSignal*)data)->ID) { + } + break; + case Warning: ///<Предупреждение + switch(((struct FSM_WarningSignal*)data)->ID) { + case FSM_CCK_Server_Connect_Error: + printk(KERN_WARNING "MN921 %u: Server Not Connect \n", ((struct FSM_Header*)(data))->IDDevice); + break; + } + break; + case Trouble: ///<Сбой + switch(((struct FSM_TroubleSignal*)data)->ID) { + case FSM_CCK_Memory_Test_Filed: + printk(KERN_ERR "MN921 %u: Memory Error \n", ((struct FSM_Header*)(data))->IDDevice); + break; + } + break; + case Beep: ///<Звук + break; + default: + break; + } + + if(to_dt->debug) + printk(KERN_INFO "RPack %u \n", len); +} +EXPORT_SYMBOL(FSM_MN921Recive); +void ApplaySettingMN921(struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + memset(&FSMMN921_sendcmd, 0, sizeof(FSMMN921_sendcmd)); + if(to_dt->debug) + printk(KERN_INFO "FSM_Set\n"); + FSMMN921_sendcmd.cmd = SetSettingClientMN921; + FSMMN921_sendcmd.countparam = 1; + FSMMN921_sendcmd.IDDevice = to_dt->IDDevice; + FSMMN921_sendcmd.CRC = 0; + FSMMN921_sendcmd.opcode = SendCmdToDevice; + memcpy(&FSMMN921_sendcmd.Data, + &(((struct FSM_MN921Device*)to_dt->data)->mn921set.fsm_mn921_su_s), + sizeof(struct fsm_mn921_subscriber)); + from_dt->dt->Proc((char*)&FSMMN921_sendcmd, + sizeof(struct FSM_SendCmd) - sizeof(FSMMN921_sendcmd.Data) + sizeof(struct fsm_mn921_subscriber), + from_dt, + to_dt); + +} + +static int __init FSM_MN921_init(void) +{ + + FSMMN921_dft.aplayp = ApplaySettingMN921; + FSMMN921_dft.type = (unsigned char)AudioDevice; + FSMMN921_dft.VidDevice = (unsigned char)CommunicationDevice; + FSMMN921_dft.PodVidDevice = (unsigned char)CCK; + FSMMN921_dft.KodDevice = (unsigned char)MN921; + FSMMN921_dft.Proc = FSM_MN921Recive; + FSMMN921_dft.config_len = sizeof(struct fsm_mn921_setting); + FSM_DeviceClassRegister(FSMMN921_dft); + printk(KERN_INFO "FSM MN921 Module loaded\n"); + FSM_SendEventToAllDev(FSM_CCK_MN921_Started); + + return 0; +} + +static void __exit FSM_MN921_exit(void) +{ + + FSM_ClassDeRegister(FSMMN921_dft); + printk(KERN_INFO "FSM MN921 Module unloaded\n"); +} + +module_init(FSM_MN921_init); +module_exit(FSM_MN921_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM MN921 Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_PO06Device.c b/FSM/FSM_PO06Device.c new file mode 100644 index 00000000000000..61ed3e6aaadf8b --- /dev/null +++ b/FSM/FSM_PO06Device.c @@ -0,0 +1,203 @@ +/*! +\file +\brief Модуль взаимодествия с пультом ПО-06 +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#include +#include +#include + +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +struct CCKDeviceInfo FSMPO06_CCKDevE; +struct FSM_DeviceFunctionTree FSMPO06_dft; +struct FSM_PO06Device FSMPO06Dev[FSM_PO06DeviceTreeSize]; +struct FSM_SendCmd FSMPO06_sendcmd; +struct FSM_AudioStream FSMPO06_fsmas; + + +void FSM_PO06SendStreaminfo(unsigned short id, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + short plen; + + + + memset(&FSMPO06_sendcmd, 0, sizeof(struct FSM_SendCmd)); + FSMPO06_sendcmd.opcode = SendCmdToDevice; + FSMPO06_sendcmd.IDDevice = from_dt->IDDevice; + FSMPO06_sendcmd.cmd = FSMPO06SendStream; + FSMPO06_sendcmd.countparam = 1; + ((unsigned short*)FSMPO06_sendcmd.Data)[0] = id; + if(to_dt->debug) + printk(KERN_INFO "FSM Send %u ,%u \n", FSMPO06_sendcmd.Data[0], FSMPO06_sendcmd.Data[1]); + FSMPO06_sendcmd.CRC = 0; + plen = sizeof(struct FSM_SendCmd) - sizeof(FSMPO06_sendcmd.Data) + 2; + if(to_dt != 0) + to_dt->dt->Proc((char*)&FSMPO06_sendcmd, plen, to_dt, from_dt); +} + +void FSM_PO06Recive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + int i; + + struct FSM_SendCmdTS* scmd = (struct FSM_SendCmdTS*)data; +// char datas[2]; + + switch(data[0]) { + + case RegDevice: ///< Регистрация устройства + FSM_Statstic_SetStatus(to_dt, "ok"); + for(i = 0; i < FSM_PO06DeviceTreeSize; i++) { + if(FSMPO06Dev[i].iddev == to_dt->IDDevice) { + FSM_PO06SendStreaminfo(FSMPO06Dev[i].idstream, from_dt, to_dt); + return; + } + } + for(i = 0; i < FSM_PO06DeviceTreeSize; i++) { + if(FSMPO06Dev[i].reg == 0) { + FSMPO06Dev[i].reg = 1; + FSMPO06Dev[i].ethdev = FSM_FindEthernetDevice(to_dt->IDDevice); + FSMPO06_fsmas.iddev = to_dt->IDDevice; + // fsmas.ToProcess=FSM_PO06RecivePacket; + // fsmas.ToUser=FSM_E1SendPacket; + FSMPO06_fsmas.TransportDevice = FSMPO06Dev[i].ethdev->numdev; + FSMPO06_fsmas.TransportDeviceType = FSM_EthernetID2; + FSMPO06_fsmas.Data = &FSMPO06Dev[i]; + FSMPO06Dev[i].idstream = FSM_AudioStreamRegistr(FSMPO06_fsmas); + FSMPO06Dev[i].iddev = to_dt->IDDevice; + to_dt->data = &FSMPO06Dev[i]; + to_dt->config = &FSMPO06Dev[i].po06set; + FSM_PO06SendStreaminfo(FSMPO06Dev[i].idstream, from_dt, to_dt); + printk(KERN_INFO "FSMPO06 Device Added %u \n", to_dt->IDDevice); + + FSM_P2P_Connect(FSMPO06Dev[i].idstream, 2); + + // datas[0]=0xd0; + // datas[1]=0xd1; + // FSM_AudioStreamToUser(0,datas,2); + break; + } + } + break; + case DelLisr: + for(i = 0; i < FSM_PO06DeviceTreeSize; i++) { + if((FSMPO06Dev[i].reg == 1) && (FSMPO06Dev[i].iddev == to_dt->IDDevice)) { + + FSM_AudioStreamUnRegistr(FSMPO06Dev[i].idstream); + FSMPO06Dev[i].reg = 0; + if(to_dt->debug) + printk(KERN_INFO "FSMPO06 Device Deleted %u \n", to_dt->IDDevice); + break; + } + } + break; + case AnsPing: ///< Пинг + break; + case SendCmdToServer: ///< Отправка команды серверу + switch(scmd->cmd) { + case FSMPO06ConnectToDevE1: + // ((struct FSM_PO06Device*)((FSM_FindDevice(scmd->IDDevice))->data))->idcon=FSM_P2P_Connect(((struct + // FSM_PO06Device*)((FSM_FindDevice(scmd->IDDevice))->data))->idstream, ((struct + // FSM_E1Device*)(FSM_FindDevice(((struct FSMPO06CommCons*)scmd->Data)->id)->data))->streams_id[((struct + // FSMPO06CommCons*)scmd->Data)->channel]); + break; + case FSMPO06DisConnectToDevE1: + FSM_P2P_Disconnect(((struct FSM_PO06Device*)((FSM_FindDevice(scmd->IDDevice))->data))->idcon); + break; + case AnsGetSettingClientPo06: + if(to_dt->debug) + printk(KERN_INFO "FSM_Set Recv %i\n", scmd->IDDevice); + memcpy(&((struct fsm_po06_setting*)(FSM_FindDevice(scmd->IDDevice)->config))->fsm_p006_su_s, + scmd->Data, + FSM_FindDevice(scmd->IDDevice)->dt->config_len); + break; + case FSMPo06SendIP: + FSMPO06_CCKDevE.id = scmd->IDDevice; + FSMPO06_CCKDevE.ip[0] = scmd->Data[0]; + FSMPO06_CCKDevE.ip[1] = scmd->Data[1]; + FSMPO06_CCKDevE.ip[2] = scmd->Data[2]; + FSMPO06_CCKDevE.ip[3] = scmd->Data[3]; + FSMPO06_CCKDevE.type = PO06; + FSMPO06_CCKDevE.Position = scmd->Data[4]; + FSMCCK_AddDeviceInfo(&FSMPO06_CCKDevE); + if(to_dt->debug) + printk(KERN_INFO "FSM PO06 ID%i Asterisk IP %i.%i.%i.%i\n ", + scmd->IDDevice, + scmd->Data[0], + scmd->Data[1], + scmd->Data[2], + scmd->Data[3]); + break; + } + + break; + case SendTxtMassage: ///< Отправка текстового сообщения + break; + case Alern: ///<Тревога + break; + case Warning: ///<Предупреждение + break; + case Trouble: ///<Сбой + break; + case Beep: ///<Звук + break; + default: + break; + } + + if(to_dt->debug) + printk(KERN_INFO "RPack %u \n", len); +} +EXPORT_SYMBOL(FSM_PO06Recive); + +void ApplaySettingPO06(struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + + + memset(&FSMPO06_sendcmd, 0, sizeof(FSMPO06_sendcmd)); + if(to_dt->debug) + printk(KERN_INFO "FSM_Set\n"); + FSMPO06_sendcmd.cmd = SetSettingClientPo06; + FSMPO06_sendcmd.countparam = 1; + FSMPO06_sendcmd.IDDevice = to_dt->IDDevice; + FSMPO06_sendcmd.CRC = 0; + FSMPO06_sendcmd.opcode = SendCmdToDevice; + memcpy(&FSMPO06_sendcmd.Data, + &(((struct FSM_PO06Device*)to_dt->data)->po06set.fsm_p006_su_s), + sizeof(struct fsm_po06_subscriber)); + from_dt->dt->Proc((char*)&FSMPO06_sendcmd, + sizeof(struct FSM_SendCmd) - sizeof(FSMPO06_sendcmd.Data) + sizeof(struct fsm_po06_subscriber), + from_dt, + to_dt); +} + +static int __init FSM_PO06_init(void) +{ + FSMPO06_dft.aplayp = ApplaySettingPO06; + FSMPO06_dft.type = (unsigned char)AudioDevice; + FSMPO06_dft.VidDevice = (unsigned char)CommunicationDevice; + FSMPO06_dft.PodVidDevice = (unsigned char)CCK; + FSMPO06_dft.KodDevice = (unsigned char)PO06; + FSMPO06_dft.Proc = FSM_PO06Recive; + FSMPO06_dft.config_len = sizeof(struct fsm_po06_setting); + FSM_DeviceClassRegister(FSMPO06_dft); + printk(KERN_INFO "FSM PO06 Module loaded\n"); + return 0; +} + +static void __exit FSM_PO06_exit(void) +{ + + FSM_ClassDeRegister(FSMPO06_dft); + printk(KERN_INFO "FSM PO06 Module unloaded\n"); +} + +module_init(FSM_PO06_init); +module_exit(FSM_PO06_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM PO06 Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_PO07Device.c b/FSM/FSM_PO07Device.c new file mode 100644 index 00000000000000..199af75e77f8bb --- /dev/null +++ b/FSM/FSM_PO07Device.c @@ -0,0 +1,227 @@ +/*! +\file +\brief Модуль взаимодествия с пультом ПО-06 +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +struct CCKDeviceInfo FSMPO07_CCKDevE; +struct FSM_DeviceFunctionTree FSMPO07_dft; +struct FSM_PO07Device FSMPO07Dev[FSM_PO07DeviceTreeSize]; +struct FSM_SendCmd FSMPO07_sendcmd; +struct FSM_AudioStream FSMPO07_fsmas; + +void FSM_PO07SendStreaminfo(unsigned short id, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + short plen; + + memset(&FSMPO07_sendcmd, 0, sizeof(struct FSM_SendCmd)); + FSMPO07_sendcmd.opcode = SendCmdToDevice; + FSMPO07_sendcmd.IDDevice = from_dt->IDDevice; + FSMPO07_sendcmd.cmd = FSMPO07SendStream; + FSMPO07_sendcmd.countparam = 1; + ((unsigned short*)FSMPO07_sendcmd.Data)[0] = id; + if(to_dt->debug) + printk(KERN_INFO "FSM Send %u ,%u \n", FSMPO07_sendcmd.Data[0], FSMPO07_sendcmd.Data[1]); + FSMPO07_sendcmd.CRC = 0; + plen = sizeof(struct FSM_SendCmd) - sizeof(FSMPO07_sendcmd.Data) + 2; + if(to_dt != 0) + to_dt->dt->Proc((char*)&FSMPO07_sendcmd, plen, to_dt, from_dt); +} + +void FSM_PO07Recive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + int i; + + struct FSM_SendCmdTS* scmd = (struct FSM_SendCmdTS*)data; +// struct FSM_SendMessage* sctt=(struct FSM_SendMessage*)data; +// char datas[2]; + + switch(data[0]) { + + case RegDevice: ///< Регистрация устройства + FSM_Statstic_SetStatus(to_dt, "ok"); + for(i = 0; i < FSM_PO07DeviceTreeSize; i++) { + if(FSMPO07Dev[i].iddev == to_dt->IDDevice) { + FSM_PO07SendStreaminfo(FSMPO07Dev[i].idstream, from_dt, to_dt); + return; + } + } + for(i = 0; i < FSM_PO07DeviceTreeSize; i++) { + if(FSMPO07Dev[i].reg == 0) { + FSMPO07Dev[i].reg = 1; + FSMPO07Dev[i].ethdev = FSM_FindEthernetDevice(to_dt->IDDevice); + FSMPO07_fsmas.iddev = to_dt->IDDevice; + // fsmas.ToProcess=FSM_PO06RecivePacket; + // fsmas.ToUser=FSM_E1SendPacket; + FSMPO07_fsmas.TransportDevice = FSMPO07Dev[i].ethdev->numdev; + FSMPO07_fsmas.TransportDeviceType = FSM_EthernetID2; + FSMPO07_fsmas.Data = &FSMPO07Dev[i]; + FSMPO07Dev[i].idstream = FSM_AudioStreamRegistr(FSMPO07_fsmas); + FSMPO07Dev[i].iddev = to_dt->IDDevice; + to_dt->data = &FSMPO07Dev[i]; + to_dt->config = &FSMPO07Dev[i].po07set; + FSM_PO07SendStreaminfo(FSMPO07Dev[i].idstream, from_dt, to_dt); + if(to_dt->debug) + printk(KERN_INFO "FSM PO07 Device Added %u \n", to_dt->IDDevice); + ; + + // datas[0]=0xd0; + // datas[1]=0xd1; + // FSM_AudioStreamToUser(0,datas,2); + break; + } + } + break; + case DelLisr: + for(i = 0; i < FSM_PO07DeviceTreeSize; i++) { + if((FSMPO07Dev[i].reg == 1) && (FSMPO07Dev[i].iddev == to_dt->IDDevice)) { + + FSM_AudioStreamUnRegistr(FSMPO07Dev[i].idstream); + FSMPO07Dev[i].reg = 0; + if(to_dt->debug) + printk(KERN_INFO "FSM PO07 Device Deleted %u \n", to_dt->IDDevice); + break; + } + } + break; + case AnsPing: ///< Пинг + break; + case SendCmdToServer: ///< Отправка команды серверу + switch(scmd->cmd) { + case FSMPO07ConnectToDevE1: + // ((struct FSM_PO06Device*)((FSM_FindDevice(scmd->IDDevice))->data))->idcon=FSM_P2P_Connect(((struct + // FSM_PO06Device*)((FSM_FindDevice(scmd->IDDevice))->data))->idstream, ((struct + // FSM_E1Device*)(FSM_FindDevice(((struct FSMPO06CommCons*)scmd->Data)->id)->data))->streams_id[((struct + // FSMPO06CommCons*)scmd->Data)->channel]); + break; + case FSMPO07DisConnectToDevE1: + FSM_P2P_Disconnect(((struct FSM_PO06Device*)(to_dt->data))->idcon); + break; + case AnsGetSettingClientPO07: + if(to_dt->debug) + printk(KERN_INFO "FSM_Set Recv %i\n", scmd->IDDevice); + memcpy(&((struct fsm_po07_setting*)(to_dt->config))->fsm_p007_su_s, scmd->Data, to_dt->dt->config_len); + break; + case FSMPo07SendIP: + FSMPO07_CCKDevE.id = scmd->IDDevice; + FSMPO07_CCKDevE.ip[0] = scmd->Data[0]; + FSMPO07_CCKDevE.ip[1] = scmd->Data[1]; + FSMPO07_CCKDevE.ip[2] = scmd->Data[2]; + FSMPO07_CCKDevE.ip[3] = scmd->Data[3]; + FSMPO07_CCKDevE.type = PO07; + FSMPO07_CCKDevE.Position = scmd->Data[4]; + FSMCCK_AddDeviceInfo(&FSMPO07_CCKDevE); + if(to_dt->debug) + printk(KERN_INFO "FSM PO07 ID%i Asterisk IP %i.%i.%i.%i\n ", + scmd->IDDevice, + scmd->Data[0], + scmd->Data[1], + scmd->Data[2], + scmd->Data[3]); + break; + } + + break; + case SendTxtMassage: ///< Отправка текстового сообщения + // printk( KERN_INFO "%s",sctt->Data ); + + break; + case PacketFromUserSpace: + switch(scmd->cmd) { + case FSMPo07AudioRun: + case FSMPo07Reset: + case FSMPo07Reregister: + scmd->IDDevice = to_dt->IDDevice; + scmd->opcode = SendCmdToDevice; + to_dt->TrDev->dt->Proc((char*)scmd, FSMH_Header_Size_SendCmd, to_dt->TrDev, to_dt); + break; + case FSMPo07GetCRC: + + break; + } + break; + case Alern: ///<Тревога + switch(((struct FSM_AlernSignal*)data)->ID) { + } + break; + case Warning: ///<Предупреждение + switch(((struct FSM_WarningSignal*)data)->ID) { + case FSM_CCK_Server_Connect_Error: + printk(KERN_WARNING "PO07 %u: Server Not Connect \n", ((struct FSM_Header*)(data))->IDDevice); + break; + } + break; + case Trouble: ///<Сбой + switch(((struct FSM_TroubleSignal*)data)->ID) { + case FSM_CCK_Memory_Test_Filed: + printk(KERN_ERR "PO07 %u: Memory Error \n", ((struct FSM_Header*)(data))->IDDevice); + break; + } + break; + case Beep: ///<Звук + break; + default: + break; + } + + + if(to_dt->debug) + printk(KERN_INFO "RPack %u \n", len); +} +EXPORT_SYMBOL(FSM_PO07Recive); +void ApplaySettingPO07(struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + + + memset(&FSMPO07_sendcmd, 0, sizeof(FSMPO07_sendcmd)); + printk(KERN_INFO "FSM_Set\n"); + FSMPO07_sendcmd.cmd = SetSettingClientPO07; + FSMPO07_sendcmd.countparam = 1; + FSMPO07_sendcmd.IDDevice = to_dt->IDDevice; + FSMPO07_sendcmd.CRC = 0; + FSMPO07_sendcmd.opcode = SendCmdToDevice; + memcpy(&FSMPO07_sendcmd.Data, + &(((struct FSM_PO07Device*)to_dt->data)->po07set.fsm_p007_su_s), + sizeof(struct fsm_po07_subscriber)); + from_dt->dt->Proc((char*)&FSMPO07_sendcmd, + sizeof(struct FSM_SendCmd) - sizeof(FSMPO07_sendcmd.Data) + sizeof(struct fsm_po07_subscriber), + from_dt, + to_dt); + +} + +static int __init FSM_PO07_init(void) +{ + + FSMPO07_dft.aplayp = ApplaySettingPO07; + FSMPO07_dft.type = (unsigned char)AudioDevice; + FSMPO07_dft.VidDevice = (unsigned char)CommunicationDevice; + FSMPO07_dft.PodVidDevice = (unsigned char)CCK; + FSMPO07_dft.KodDevice = (unsigned char)PO07; + FSMPO07_dft.Proc = FSM_PO07Recive; + FSMPO07_dft.config_len = sizeof(struct fsm_po07_setting); + FSM_DeviceClassRegister(FSMPO07_dft); + printk(KERN_INFO "FSM PO07 Module loaded\n"); + FSM_SendEventToAllDev(FSM_CCK_MN845_Started); + return 0; +} + +static void __exit FSM_PO07_exit(void) +{ + FSM_ClassDeRegister(FSMPO07_dft); + printk(KERN_INFO "FSM PO07 Module unloaded\n"); +} + +module_init(FSM_PO07_init); +module_exit(FSM_PO07_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM PO07 Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_PO08Device.c b/FSM/FSM_PO08Device.c new file mode 100644 index 00000000000000..06374d5c81ba5f --- /dev/null +++ b/FSM/FSM_PO08Device.c @@ -0,0 +1,226 @@ +/*! +\file +\brief Модуль взаимодествия с пультом ПО-06 +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +struct CCKDeviceInfo FSMPO08_CCKDevE; +struct FSM_DeviceFunctionTree FSMPO08_dft; +struct FSM_PO08Device FSMPO08Dev[FSM_PO08DeviceTreeSize]; +struct FSM_SendCmd FSMPO08_sendcmd; +struct FSM_AudioStream FSMPO08_fsmas; + +void FSM_PO08SendStreaminfo(unsigned short id, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + short plen; + + memset(&FSMPO08_sendcmd, 0, sizeof(struct FSM_SendCmd)); + FSMPO08_sendcmd.opcode = SendCmdToDevice; + FSMPO08_sendcmd.IDDevice = from_dt->IDDevice; + FSMPO08_sendcmd.cmd = FSMPO08SendStream; + FSMPO08_sendcmd.countparam = 1; + ((unsigned short*)FSMPO08_sendcmd.Data)[0] = id; + if(to_dt->debug) + printk(KERN_INFO "FSM Send %u ,%u \n", FSMPO08_sendcmd.Data[0], FSMPO08_sendcmd.Data[1]); + FSMPO08_sendcmd.CRC = 0; + plen = sizeof(struct FSM_SendCmd) - sizeof(FSMPO08_sendcmd.Data) + 2; + if(to_dt != 0) + to_dt->dt->Proc((char*)&FSMPO08_sendcmd, plen, to_dt, from_dt); + +} + +void FSM_PO08Recive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + int i; + + struct FSM_SendCmdTS* scmd = (struct FSM_SendCmdTS*)data; +// char datas[2]; + + switch(data[0]) { + + case RegDevice: ///< Регистрация устройства + FSM_Statstic_SetStatus(to_dt, "ok"); + for(i = 0; i < FSM_PO08DeviceTreeSize; i++) { + if(FSMPO08Dev[i].iddev == to_dt->IDDevice) { + FSM_PO08SendStreaminfo(FSMPO08Dev[i].idstream, from_dt, to_dt); + return; + } + } + for(i = 0; i < FSM_PO08DeviceTreeSize; i++) { + if(FSMPO08Dev[i].reg == 0) { + FSMPO08Dev[i].reg = 1; + FSMPO08Dev[i].ethdev = FSM_FindEthernetDevice(to_dt->IDDevice); + FSMPO08_fsmas.iddev = to_dt->IDDevice; + // fsmas.ToProcess=FSM_PO06RecivePacket; + // fsmas.ToUser=FSM_E1SendPacket; + FSMPO08_fsmas.TransportDevice = FSMPO08Dev[i].ethdev->numdev; + FSMPO08_fsmas.TransportDeviceType = FSM_EthernetID2; + FSMPO08_fsmas.Data = &FSMPO08Dev[i]; + FSMPO08Dev[i].idstream = FSM_AudioStreamRegistr(FSMPO08_fsmas); + FSMPO08Dev[i].iddev = to_dt->IDDevice; + to_dt->data = &FSMPO08Dev[i]; + to_dt->config = &FSMPO08Dev[i].po08set; + FSM_PO08SendStreaminfo(FSMPO08Dev[i].idstream, from_dt, to_dt); + if(to_dt->debug) + printk(KERN_INFO "FSM PO08 Device Added %u \n", to_dt->IDDevice); + ; + + // datas[0]=0xd0; + // datas[1]=0xd1; + // FSM_AudioStreamToUser(0,datas,2); + break; + } + } + break; + case DelLisr: + for(i = 0; i < FSM_PO08DeviceTreeSize; i++) { + if((FSMPO08Dev[i].reg == 1) && (FSMPO08Dev[i].iddev == to_dt->IDDevice)) { + + FSM_AudioStreamUnRegistr(FSMPO08Dev[i].idstream); + FSMPO08Dev[i].reg = 0; + if(to_dt->debug) + printk(KERN_INFO "FSM PO08 Device Deleted %u \n", to_dt->IDDevice); + break; + } + } + break; + case AnsPing: ///< Пинг + break; + case SendCmdToServer: ///< Отправка команды серверу + switch(scmd->cmd) { + case FSMPO08ConnectToDevE1: + // ((struct FSM_PO06Device*)((FSM_FindDevice(scmd->IDDevice))->data))->idcon=FSM_P2P_Connect(((struct + // FSM_PO06Device*)((FSM_FindDevice(scmd->IDDevice))->data))->idstream, ((struct + // FSM_E1Device*)(FSM_FindDevice(((struct FSMPO06CommCons*)scmd->Data)->id)->data))->streams_id[((struct + // FSMPO06CommCons*)scmd->Data)->channel]); + break; + case FSMPO08DisConnectToDevE1: + FSM_P2P_Disconnect(((struct FSM_PO06Device*)(to_dt->data))->idcon); + break; + case AnsGetSettingClientPO08: + if(to_dt->debug) + printk(KERN_INFO "FSM_Set Recv %i\n", scmd->IDDevice); + memcpy(&((struct fsm_po08_setting*)(to_dt->config))->fsm_p008_su_s, scmd->Data, to_dt->dt->config_len); + break; + case FSMPo08SendIP: + FSMPO08_CCKDevE.id = scmd->IDDevice; + FSMPO08_CCKDevE.ip[0] = scmd->Data[0]; + FSMPO08_CCKDevE.ip[1] = scmd->Data[1]; + FSMPO08_CCKDevE.ip[2] = scmd->Data[2]; + FSMPO08_CCKDevE.ip[3] = scmd->Data[3]; + FSMPO08_CCKDevE.type = PO08; + FSMPO08_CCKDevE.Position = scmd->Data[4]; + FSMCCK_AddDeviceInfo(&FSMPO08_CCKDevE); + if(to_dt->debug) + printk(KERN_INFO "FSM PO08 ID%i Asterisk IP %i.%i.%i.%i\n ", + scmd->IDDevice, + scmd->Data[0], + scmd->Data[1], + scmd->Data[2], + scmd->Data[3]); + break; + } + + break; + case SendTxtMassage: ///< Отправка текстового сообщения + break; + case PacketFromUserSpace: + switch(scmd->cmd) { + case FSMPo08AudioRun: + case FSMPo08Reset: + case FSMPo08Reregister: + scmd->IDDevice = to_dt->IDDevice; + scmd->opcode = SendCmdToDevice; + to_dt->TrDev->dt->Proc((char*)scmd, FSMH_Header_Size_SendCmd, to_dt->TrDev, to_dt); + break; + case FSMPo08GetCRC: + + break; + } + break; + case Alern: ///<Тревога + switch(((struct FSM_AlernSignal*)data)->ID) { + } + break; + case Warning: ///<Предупреждение + switch(((struct FSM_WarningSignal*)data)->ID) { + case FSM_CCK_Server_Connect_Error: + printk(KERN_WARNING "PO08 %u: Server Not Connect \n", ((struct FSM_Header*)(data))->IDDevice); + break; + } + break; + case Trouble: ///<Сбой + switch(((struct FSM_TroubleSignal*)data)->ID) { + case FSM_CCK_Memory_Test_Filed: + printk(KERN_ERR "PO08 %u: Memory Error \n", ((struct FSM_Header*)(data))->IDDevice); + break; + } + break; + case Beep: ///<Звук + break; + default: + break; + } + + + if(to_dt->debug) + printk(KERN_INFO "RPack %u \n", len); +} +EXPORT_SYMBOL(FSM_PO08Recive); +void ApplaySettingPO08(struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + + memset(&FSMPO08_sendcmd, 0, sizeof(FSMPO08_sendcmd)); + if(to_dt->debug) + printk(KERN_INFO "FSM_Set\n"); + FSMPO08_sendcmd.cmd = SetSettingClientPO08; + FSMPO08_sendcmd.countparam = 1; + FSMPO08_sendcmd.IDDevice = to_dt->IDDevice; + FSMPO08_sendcmd.CRC = 0; + FSMPO08_sendcmd.opcode = SendCmdToDevice; + memcpy(&FSMPO08_sendcmd.Data, + &(((struct FSM_PO08Device*)to_dt->data)->po08set.fsm_p008_su_s), + sizeof(struct fsm_po08_subscriber)); + from_dt->dt->Proc((char*)&FSMPO08_sendcmd, + sizeof(struct FSM_SendCmd) - sizeof(FSMPO08_sendcmd.Data) + sizeof(struct fsm_po08_subscriber), + from_dt, + to_dt); +} + +static int __init FSM_PO08_init(void) +{ + + FSMPO08_dft.aplayp = ApplaySettingPO08; + FSMPO08_dft.type = (unsigned char)AudioDevice; + FSMPO08_dft.VidDevice = (unsigned char)CommunicationDevice; + FSMPO08_dft.PodVidDevice = (unsigned char)CCK; + FSMPO08_dft.KodDevice = (unsigned char)PO08; + FSMPO08_dft.Proc = FSM_PO08Recive; + FSMPO08_dft.config_len = sizeof(struct fsm_po08_setting); + FSM_DeviceClassRegister(FSMPO08_dft); + printk(KERN_INFO "FSM PO08 Module loaded\n"); + FSM_SendEventToAllDev(FSM_CCK_MN845_Started); + + return 0; +} + +static void __exit FSM_PO08_exit(void) +{ + + FSM_ClassDeRegister(FSMPO08_dft); + printk(KERN_INFO "FSM PO08 Module unloaded\n"); +} + +module_init(FSM_PO08_init); +module_exit(FSM_PO08_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM PO08 Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_SendSignalToPipe.c b/FSM/FSM_SendSignalToPipe.c new file mode 100644 index 00000000000000..8a647498185620 --- /dev/null +++ b/FSM/FSM_SendSignalToPipe.c @@ -0,0 +1,82 @@ +#include +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" +#include "FSM/FSM_Client/FSM_client.h" + +pid_t FSM_SSTP_PID = 0; +struct siginfo FSM_SSTP_info; +struct task_struct* FSM_SSTP_task; +struct SendSignalStruct FSM_SSTP_signstr; +void FSM_EventIOCtl(char* Data, short len, struct fsm_ioctl_struct* ioctl) +{ + struct FSM_SendCmdUserspace* fsm_scus = (struct FSM_SendCmdUserspace*)Data; + switch(fsm_scus->cmd) { + case FSM_SSTP_SetPid: + FSM_SSTP_info.si_signo = SIGUSR1; + FSM_SSTP_info.si_errno = 0; + FSM_SSTP_info.si_code = SI_USER; + FSM_SSTP_PID = ((pid_t*)fsm_scus->Data)[0]; + printk(KERN_INFO "FSM Set Setting %u, ", FSM_SSTP_PID); + // task = pid_task(find_pid_ns(FSM_SSTP_PID, &init_pid_ns), PIDTYPE_PID); + // task = pid_task(find_vpid(FSM_SSTP_PID),PIDTYPE_PID); + FSM_SSTP_task = pid_task(find_vpid(FSM_SSTP_PID), PIDTYPE_PID); + break; + case FSM_SSTP_GetEvent: + memcpy(fsm_scus->Data, &FSM_SSTP_signstr, sizeof(struct SendSignalStruct)); + printk(KERN_INFO "GEvent"); + break; + } +} +int FSM_SendSignalToPipe_thread(void* Data) +{ + char id[10]; + struct SendSignalStruct* datas = (struct SendSignalStruct*)Data; + char* envp[] = { NULL }; + char* argv[4]; + sprintf(id, "%u", datas->id); + argv[0] = "fsmsstd"; + argv[1] = datas->pipe; + argv[2] = id; + argv[3] = NULL; + + call_usermodehelper("/bin/fsmsstd", argv, envp, UMH_WAIT_EXEC); + return 0; +} + +int FSM_SendSignalToPipe(char* pipe, int signal) +{ + + FSM_SSTP_signstr.id = signal; + strcpy(FSM_SSTP_signstr.pipe, pipe); + if(FSM_SSTP_PID) + send_sig_info(SIGUSR1, &FSM_SSTP_info, FSM_SSTP_task); + // send_sig_info( SIGUSR1, FSM_SSTP_PID, 0 ); + // pid = kthread_run(FSM_SendSignalToPipe_thread, &signstr, "FSM_SendSignalToPipe" ); /* запускаем новый поток */ + // FSM_SendSignalToPipe_thread(&signstr); + return 0; +} +EXPORT_SYMBOL(FSM_SendSignalToPipe); + +static int __init FSMSendSigTP_init(void) +{ + FSM_RegisterIOCtl(FSM_EventIOCtlId, FSM_EventIOCtl); + call_usermodehelper("/bin/fsmced", 0, 0, UMH_WAIT_EXEC); + FSM_SendSignalToPipe("fsmstat", 2); + printk(KERN_INFO "FSM Send Signal To Pipe loaded\n"); + + return 0; +} +static void __exit FSMSendSigTP_exit(void) +{ + FSM_DeleteIOCtl(FSM_EventIOCtlId); + printk(KERN_INFO "FSM Send Signal To Pipe unloaded\n"); +} + +module_init(FSMSendSigTP_init); +module_exit(FSMSendSigTP_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM Send Signal To Pipe Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_SettingClient.c b/FSM/FSM_SettingClient.c new file mode 100644 index 00000000000000..3beba94dc1cac2 --- /dev/null +++ b/FSM/FSM_SettingClient.c @@ -0,0 +1,182 @@ +/*! +\file +\brief Модуль клиент конфигурирования +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#define SUCCESS 0 + +#include +#include +#include +#include + +#include "FSM/FSMAudio/FSM_AudioStream.h" +#include +#include "FSM/FSMDevice/fcmprotocol.h" +#include "FSM/FSMDevice/fcm_audiodeviceclass.h" +#include "FSM/FSMDevice/FSM_DeviceProcess.h" +#include "FSM/FSMSetting/FSM_settings.h" +#include "FSM/FSMDevice/fsm_statusstruct.h" +#include "FSM/FSM_Client/FSM_client.h" +struct fsm_devices_config fsm_ds; +struct FSMSSetconfigParam fsmspar; +unsigned short FSM_SC_setservid; + +int FSMSet_rcv(char* Data, short len, struct fsm_client_struct* dev) +{ + char dats = Data[0]; + struct FSM_SendCmd* fscts = (struct FSM_SendCmd*)Data; + // struct FSM_AnsDeviceRegistr* fscar= (struct FSM_AnsDeviceRegistr*)Data; + switch(dats) { + case RegDevice: ///< Регистрация устройства + break; + case AnsRegDevice: + break; + case AnsDelList: ///< Подтверждение удаления устройства из списка + break; + case AnsPing: ///< Пинг + break; + case SendCmdToDevice: ///< Отправка команды устройству + switch(fscts->cmd) { + case AnsGetSet: + // printk( KERN_INFO "FSM Cmd %u\n",fscts->cmd); + memcpy(&fsm_ds.setel[((struct fsm_device_config*)fscts->Data)->row][((struct fsm_device_config*)fscts->Data) + ->column], + fscts->Data, + sizeof(struct fsm_device_config)); + break; + + + + case SetSettingClient: + printk(KERN_INFO "FSM_Setting_Applay\n"); + FSM_DeleteDevice(FSM_SettingID); + FSM_SC_setservid = ((struct fsm_ClientSetting_Setting*)fscts->Data)->id; + FSM_RegisterDevice(FSM_SettingID, + StatisticandConfig, + FSMDeviceConfig, + ComputerStatistic, + PCx86, + (DeviceClientProcess)FSMSet_rcv); + break; + } + case SendCmdGlobalcmdToClient: ///< Отправка команды устройству + switch(fscts->cmd) { + case FSMNotRegistred: + printk(KERN_INFO "Device FSR\n"); + FSM_RegisterDevice(FSM_SettingID, + StatisticandConfig, + FSMDeviceConfig, + ComputerStatistic, + PCx86, + (DeviceClientProcess)FSMSet_rcv); + break; + } + break; + case AnsSendCmdToDevice: ///< Подтверждение приёма команды устройством + break; + case RqToDevice: ///< Ответ на команду устройством + break; + case AnsRqToDevice: ///< Подтверждение приёма команды сервером + break; + case SendCmdToServer: ///< Отправка команды серверу + break; + case SendTxtMassage: ///< Отправка текстового сообщения + break; + case AnsSendTxtMassage: ///< Подтверждение приёма текстового сообщения + break; + case SendTxtEncMassage: ///< Отправка зашифрованного текстового сообщения + break; + case AnsSendTxtEncMassage: ///< Подтверждение приёма зашифрованного текстового сообщения + break; + case SendAudio: ///< Передача аудио данных + break; + case SendVideo: ///< Передача видео данных + break; + case SendBinData: ///< Передача бинарных данных + break; + case AnsSendBinData: ///< Подтверждение приёма бинарных данных + break; + case SendSMS: ///< Отправить СМС + break; + case SendAnsSMS: ///< Подтверждение СМС + break; + case SendSMStoDev: ///< Передача СМС устройству + break; + case SendAnsSMStoDev: ///< Подтверждение СМС устройством + break; + case SendEncSMS: ///< Отправить зашифрованного СМС + break; + case SendAnsEncSMS: ///<Подтверждение зашифрованного СМС + break; + case SendEncSMStoDev: ///< Отправить зашифрованного СМС устройству + break; + case SendAnsEncSMStoDev: ///< Подтверждение зашифрованного СМС устройства + break; + case SendEmail: ///< Отправка email + break; + case AnsEmail: ///<Подтверждение email + break; + case SendEmailtoDevice: ///<Передача email устройству + break; + case AnsSendEmailtoDevice: ///<Подтверждение email устройством + break; + case SendEncEmail: ///<Отправить зашифрованного email + break; + case AnsEncEmail: ///<Подтверждение зашифрованного email + break; + case SendEncEmailtoDev: ///< Отправить зашифрованного email устройству + break; + case AnsEncEmailtoDev: ///< Подтверждение зашифрованного email устройства + break; + case SocSend: ///< Отправка сообщение в социальную сеть + break; + case AnsSocSend: ///< Подтверждение сообщения в социальную сеть + break; + case SocSendtoDev: ///< Передача сообщения в социальную сеть устройству + break; + case AnsSocSendtoDev: ///< Подтверждение сообщения в социальную сеть устройством + break; + case SocEncSend: ///< Отправить зашифрованного сообщения в социальную сеть + break; + case AnsSocEncSend: ///< Подтверждение зашифрованного сообщения в социальную сеть + break; + case SocEncSendtoDev: ///< Отправить зашифрованного сообщения в социальную сеть устройству + break; + case AnsSocEncSendtoDev: ///< Подтверждение зашифрованного сообщения в социальную сеть устройства + break; + case Alern: ///<Тревога + break; + case Warning: ///<Предупреждение + break; + case Trouble: ///<Сбой + break; + case Beep: ///<Звук + break; + } + return 0; +}; + +static int __init FSM_Client_Setting_init(void) +{ + FSM_SC_setservid = 22; + FSM_RegisterDevice( + FSM_SettingID, StatisticandConfig, FSMDeviceConfig, ComputerStatistic, PCx86, (DeviceClientProcess)FSMSet_rcv); + printk(KERN_INFO "FSM Setting module loaded\n"); + return 0; +} + +static void __exit FSM_Client_Setting_exit(void) +{ + FSM_DeleteDevice(FSM_SettingID); + printk(KERN_INFO "FSM Setting module unloaded\n"); +} +module_init(FSM_Client_Setting_init); +module_exit(FSM_Client_Setting_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM Setting Module"); +MODULE_LICENSE("GPL"); diff --git a/FSM/FSM_SettingServer.c b/FSM/FSM_SettingServer.c new file mode 100644 index 00000000000000..e17c164599f5cd --- /dev/null +++ b/FSM/FSM_SettingServer.c @@ -0,0 +1,101 @@ +/*! +\file +\brief Модуль сервер настроек +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" +#include "FSM/FSM_Client/FSM_client.h" + +struct FSM_SendCmd fsm_Setting_scmdt; +struct fsm_Setting_Setting fsm_Setting_fsmSSS; + +void FSM_SettingRecive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + struct fsm_devices_config* fsmset; + // struct FSM_DeviceTree* fsdt; + int i, j; + short hlen; + // unsigned short tmp; + struct FSM_SendCmdTS* fscts = (struct FSM_SendCmdTS*)data; + + switch(data[0]) { + case RegDevice: + FSM_Statstic_SetStatus(to_dt, "ok"); + to_dt->config = &fsm_Setting_fsmSSS; + fsm_Setting_fsmSSS.fsmcs.id = to_dt->IDDevice; + break; + case SendCmdToServer: ///< Отправка команды серверу + fsmset = FSM_GetSetting(); + switch(fscts->cmd) { + // printk( KERN_INFO "FSM Cmd %u\n",fscts->cmd); + case GetSet: + hlen = sizeof(struct FSM_SendCmd) - sizeof(fsm_Setting_scmdt.Data) + sizeof(struct fsm_device_config); + fsm_Setting_scmdt.cmd = AnsGetSet; + fsm_Setting_scmdt.countparam = 1; + fsm_Setting_scmdt.IDDevice = fscts->IDDevice; + fsm_Setting_scmdt.CRC = 0; + fsm_Setting_scmdt.opcode = SendCmdToDevice; + + for(i = 0; i < srow_cnt; i++) { + for(j = 0; j < scolumn_cnt; j++) { + if(fsmset->setel[i][j].IDDevice != 0) { + memcpy(fsm_Setting_scmdt.Data, &fsmset->setel[i][j], sizeof(struct fsm_device_config)); + from_dt->dt->Proc((char*)&fsm_Setting_scmdt, hlen, from_dt, to_dt); + // printk( KERN_INFO "FSM Send %u + // %s\n",fsmstate->statel[i][j].devid,fsmstate->statel[i][j].fsmdevcode); + } + } + } + break; + case SetSetting: + // printk( KERN_INFO "FSM_Setting_Applay\n" ); + FSM_Setting_Applay(FSM_FindDevice(((struct fsm_device_config*)fscts->Data)->IDDevice), + ((struct fsm_device_config*)fscts->Data)->config); + break; + } + break; + } +} +void ApplaySetting(struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + + // printk( KERN_INFO "FSM_Set\n" ); + fsm_Setting_scmdt.cmd = SetSettingClient; + fsm_Setting_scmdt.countparam = 1; + fsm_Setting_scmdt.IDDevice = to_dt->IDDevice; + fsm_Setting_scmdt.CRC = 0; + fsm_Setting_scmdt.opcode = SendCmdToDevice; + memcpy(&fsm_Setting_scmdt.Data, &fsm_Setting_fsmSSS.fsmcs, sizeof(struct fsm_Setting_Setting)); + from_dt->dt->Proc((char*)&fsm_Setting_scmdt, sizeof(struct FSM_SendCmd), from_dt, to_dt); +} +struct FSM_DeviceFunctionTree fsm_Setting_dft; +static int __init FSM_Setting_Server_init(void) +{ + fsm_Setting_dft.type = (unsigned char)StatisticandConfig; + fsm_Setting_dft.VidDevice = (unsigned char)FSMDeviceConfig; + fsm_Setting_dft.PodVidDevice = (unsigned char)ComputerStatistic; + fsm_Setting_dft.KodDevice = (unsigned char)PCx86; + fsm_Setting_dft.Proc = FSM_SettingRecive; + fsm_Setting_dft.config_len = sizeof(struct fsm_Setting_Setting); + fsm_Setting_dft.aplayp = ApplaySetting; + FSM_DeviceClassRegister(fsm_Setting_dft); + printk(KERN_INFO "FSM Setting Server loaded\n"); + return 0; +} + +static void __exit FSM_Setting_Server_exit(void) +{ + printk(KERN_INFO "FSM Setting Server unloaded\n"); +} + +module_init(FSM_Setting_Server_init); +module_exit(FSM_Setting_Server_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM Setting Server Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_SkyNet.c b/FSM/FSM_SkyNet.c new file mode 100644 index 00000000000000..efe8449171a297 --- /dev/null +++ b/FSM/FSM_SkyNet.c @@ -0,0 +1,121 @@ +/*! +\file +\brief Модуль взаимодествия с пультом ПО-06 +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ +#include +#include + +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +struct FSM_DeviceFunctionTree FSMSkyNet_dft; +struct FSM_SkyNetDevice FSMSkyNetDev[FSM_SkyNetDeviceTreeSize]; +struct FSM_SendCmd FSMSkyNet_sendcmd; + +void FSM_SkyNetRecive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + int i; + + struct FSM_SendCmdTS* scmd = (struct FSM_SendCmdTS*)data; + // char datas[2]; + + switch(data[0]) { + + case RegDevice: ///< Регистрация устройства + FSM_Statstic_SetStatus(to_dt, "ok"); + for(i = 0; i < FSM_SkyNetDeviceTreeSize; i++) { + if(FSMSkyNetDev[i].iddev == to_dt->IDDevice) { + return; + } + } + for(i = 0; i < FSM_PO06DeviceTreeSize; i++) { + if(FSMSkyNetDev[i].reg == 0) { + FSMSkyNetDev[i].reg = 1; + FSMSkyNetDev[i].ethdev = FSM_FindEthernetDevice(to_dt->IDDevice); + FSMSkyNetDev[i].iddev = to_dt->IDDevice; + to_dt->data = &FSMSkyNetDev[i]; + // fsmdt->config=&FSMSkyNetDev[i].po06set; + printk(KERN_INFO "FSMSkyNET Device Added %u \n", to_dt->IDDevice); + break; + } + } + break; + case DelLisr: + for(i = 0; i < FSM_E1DeviceTreeSize; i++) { + if((FSMSkyNetDev[i].reg == 1) && (FSMSkyNetDev[i].iddev == to_dt->IDDevice)) { + FSMSkyNetDev[i].reg = 0; + printk(KERN_INFO "FSMPO06 Device Deleted %u \n", to_dt->IDDevice); + break; + } + } + break; + case AnsPing: ///< Пинг + break; + case SendCmdToServer: ///< Отправка команды серверу + switch(scmd->cmd) { + case AnsGetSettingSwitch: + printk(KERN_INFO "FSM_Set Recv %i\n", scmd->IDDevice); + // memcpy(&((struct + // fsm_po06_setting*)(FSM_FindDevice(scmd->IDDevice)->config))->fsm_p006_su_s,scmd->Data,FSM_FindDevice(scmd->IDDevice)->dt->config_len); + break; + } + break; + case SendTxtMassage: ///< Отправка текстового сообщения + break; + case Alern: ///<Тревога + break; + case Warning: ///<Предупреждение + break; + case Trouble: ///<Сбой + break; + case Beep: ///<Звук + break; + default: + break; + } + + printk(KERN_INFO "RPack %u \n", len); +} +EXPORT_SYMBOL(FSM_SkyNetRecive); +void ApplaySettingSkyNet(struct FSM_DeviceTree* df) +{ + memset(&FSMSkyNet_sendcmd, 0, sizeof(FSMSkyNet_sendcmd)); + printk(KERN_INFO "FSM_Set\n"); + FSMSkyNet_sendcmd.cmd = SetSettingSwitch; + FSMSkyNet_sendcmd.countparam = 1; + FSMSkyNet_sendcmd.IDDevice = df->IDDevice; + FSMSkyNet_sendcmd.CRC = 0; + FSMSkyNet_sendcmd.opcode = SendCmdToDevice; + // memcpy(&sendcmd.Data,&(((struct FSM_PO06Device*)df->data)->po06set.fsm_p006_su_s),sizeof(struct + // fsm_po06_subscriber)); + //(FSM_FindDevice(FSM_EthernetID))->dt->Proc((char*)&sendcmd,sizeof(struct + // FSM_SendCmd)-sizeof(sendcmd.Data)+sizeof(struct fsm_po06_subscriber),df); +} + +static int __init FSM_SkyNet_init(void) +{ + FSMSkyNet_dft.aplayp = (ApplayProcess)ApplaySettingSkyNet; + FSMSkyNet_dft.type = (unsigned char)Switch; + FSMSkyNet_dft.VidDevice = (unsigned char)SkyNet; + FSMSkyNet_dft.PodVidDevice = (unsigned char)K1986BE1T; + FSMSkyNet_dft.KodDevice = (unsigned char)BLE_nRFC_RS485_Ethernet; + FSMSkyNet_dft.Proc = FSM_SkyNetRecive; + // dft.config_len=sizeof(struct fsm_po06_setting); + FSM_DeviceClassRegister(FSMSkyNet_dft); + printk(KERN_INFO "FSM SkyNet Module loaded\n"); + return 0; +} + +static void __exit FSM_SkyNet_exit(void) +{ + printk(KERN_INFO "FSM SkyNet Module unloaded\n"); +} + +module_init(FSM_SkyNet_init); +module_exit(FSM_SkyNet_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM SkyNet Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_SocialAnalytic.c b/FSM/FSM_SocialAnalytic.c new file mode 100644 index 00000000000000..eb1301381c0eec --- /dev/null +++ b/FSM/FSM_SocialAnalytic.c @@ -0,0 +1,132 @@ +/*! +\file +\brief Модуль анализа соц сетей +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#include +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" +#include "FSM/FSM_SA/FSM_SA.h" + +struct FSM_DeviceFunctionTree FSMSA_dft; +struct FSM_SADevice FSMSADev[FSM_SADeviceTreeSize]; +struct FSM_SendCmd FSMSA_sendcmd; +//struct FSM_AudioStream fsmas; + +int AnalizData(char* Data, unsigned short len) +{ + return 0; +} + +void FSM_SASRecive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + int i; + + struct FSM_SendCmdTS* scmd = (struct FSM_SendCmdTS*)data; + + switch(data[0]) { + + case RegDevice: ///< Регистрация устройства + FSM_Statstic_SetStatus(to_dt, "ok"); + for(i = 0; i < FSM_PO08DeviceTreeSize; i++) { + if(FSMSADev[i].iddev == to_dt->IDDevice) { + return; + } + } + for(i = 0; i < FSM_SADeviceTreeSize; i++) { + if(FSMSADev[i].reg == 0) { + FSMSADev[i].reg = 1; + FSMSADev[i].ethdev = FSM_FindEthernetDevice(to_dt->IDDevice); + to_dt->data = &FSMSADev[i]; + to_dt->config = &FSMSADev[i].saset; + break; + } + } + break; + case DelLisr: + for(i = 0; i < FSM_SADeviceTreeSize; i++) { + if((FSMSADev[i].reg == 1) && (FSMSADev[i].iddev == to_dt->IDDevice)) { + + FSMSADev[i].reg = 0; + printk(KERN_INFO "FSM SA Device Deleted %u \n", to_dt->IDDevice); + break; + } + } + break; + case AnsPing: ///< Пинг + break; + case SendCmdToServer: ///< Отправка команды серверу + switch(scmd->cmd) { + case FSMSA_IDK: + + break; + } + + break; + case SendTxtMassage: ///< Отправка текстового сообщения + break; + case Alern: ///<Тревога + switch(((struct FSM_AlernSignal*)data)->ID) { + } + break; + case Warning: ///<Предупреждение + switch(((struct FSM_WarningSignal*)data)->ID) { + case FSM_CCK_Server_Connect_Error: + break; + } + break; + case Trouble: ///<Сбой + switch(((struct FSM_TroubleSignal*)data)->ID) { + case FSM_CCK_Memory_Test_Filed: + break; + } + break; + case Beep: ///<Звук + break; + default: + break; + } + + printk(KERN_INFO "RPack %u \n", len); +} +EXPORT_SYMBOL(FSM_SASRecive); + +void ApplaySettingSA(struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ +} + +static int __init FSM_SA_init(void) +{ + + FSMSA_dft.aplayp = ApplaySettingSA; + FSMSA_dft.type = (unsigned char)SocialAnalytica; + FSMSA_dft.VidDevice = (unsigned char)FSMSA_Analiz; + FSMSA_dft.PodVidDevice = (unsigned char)FSMSA_AnalizData; + FSMSA_dft.KodDevice = (unsigned char)FSMSA_AnalizDataServer; + FSMSA_dft.Proc = FSM_SASRecive; + FSMSA_dft.config_len = sizeof(struct fsm_sa_setting); + FSM_DeviceClassRegister(FSMSA_dft); + printk(KERN_INFO "FSM SA Module loaded\n"); + + + return 0; +} + +static void __exit FSM_SA_exit(void) +{ + + FSM_ClassDeRegister(FSMSA_dft); + printk(KERN_INFO "FSM SA Module unloaded\n"); + +} + +module_init(FSM_SA_init); +module_exit(FSM_SA_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM SA Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_StatisticClient.c b/FSM/FSM_StatisticClient.c new file mode 100644 index 00000000000000..82471398344e17 --- /dev/null +++ b/FSM/FSM_StatisticClient.c @@ -0,0 +1,223 @@ +/*! +\file +\brief Модуль клиент статистики +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#define SUCCESS 0 + +#include +#include +#include +#include + +#include "FSM/FSMAudio/FSM_AudioStream.h" +#include +#include "FSM/FSMDevice/fcmprotocol.h" +#include "FSM/FSMDevice/fcm_audiodeviceclass.h" +#include "FSM/FSMDevice/FSM_DeviceProcess.h" +#include "FSM/FSMSetting/FSM_settings.h" +#include "FSM/FSMDevice/fsm_statusstruct.h" +#include "FSM/FSM_Client/FSM_client.h" +struct fsm_statusstruct fsm_ss; +struct FSMSSetconfigParam fsmspar; +struct FSM_SendCmdTS FSM_SC_regpcmdts; + +int FSMStat_rcv(char* Data, short len, struct fsm_client_struct* dev) +{ + char dats = Data[0]; + struct FSM_SendCmd* fscts = (struct FSM_SendCmd*)Data; + // struct FSM_AnsDeviceRegistr* fscar= (struct FSM_AnsDeviceRegistr*)Data; + switch(dats) { + case RegDevice: ///< Регистрация устройства + break; + case AnsRegDevice: + break; + case AnsDelList: ///< Подтверждение удаления устройства из списка + break; + case AnsPing: ///< Пинг + break; + case SendCmdToDevice: ///< Отправка команды устройству + switch(fscts->cmd) { + case AnsGetStatistic: + memcpy(&fsm_ss.statel[((struct fsm_status_element*)fscts->Data) + ->row][((struct fsm_status_element*)fscts->Data)->column], + fscts->Data, + sizeof(struct fsm_status_element)); + break; + case SendSettingFull: + FSM_SendSignalToPipe("fsmstat", FSM_ServerStatisticChanged); + break; + } + + break; + case SendCmdGlobalcmdToClient: ///< Отправка команды устройству + switch(fscts->cmd) { + case FSMNotRegistred: + printk(KERN_INFO "FNR"); + FSM_RegisterDevice(FSM_StatisicID, + StatisticandConfig, + FSMDeviceStatistic, + ComputerStatistic, + PCx86, + (DeviceClientProcess)FSMStat_rcv); + break; + } + + break; + case AnsSendCmdToDevice: ///< Подтверждение приёма команды устройством + break; + case RqToDevice: ///< Ответ на команду устройством + break; + case AnsRqToDevice: ///< Подтверждение приёма команды сервером + break; + case SendCmdToServer: ///< Отправка команды серверу + break; + case SendTxtMassage: ///< Отправка текстового сообщения + break; + case AnsSendTxtMassage: ///< Подтверждение приёма текстового сообщения + break; + case SendTxtEncMassage: ///< Отправка зашифрованного текстового сообщения + break; + case AnsSendTxtEncMassage: ///< Подтверждение приёма зашифрованного текстового сообщения + break; + case SendAudio: ///< Передача аудио данных + break; + case SendVideo: ///< Передача видео данных + break; + case SendBinData: ///< Передача бинарных данных + break; + case AnsSendBinData: ///< Подтверждение приёма бинарных данных + break; + case SendSMS: ///< Отправить СМС + break; + case SendAnsSMS: ///< Подтверждение СМС + break; + case SendSMStoDev: ///< Передача СМС устройству + break; + case SendAnsSMStoDev: ///< Подтверждение СМС устройством + break; + case SendEncSMS: ///< Отправить зашифрованного СМС + break; + case SendAnsEncSMS: ///<Подтверждение зашифрованного СМС + break; + case SendEncSMStoDev: ///< Отправить зашифрованного СМС устройству + break; + case SendAnsEncSMStoDev: ///< Подтверждение зашифрованного СМС устройства + break; + case SendEmail: ///< Отправка email + break; + case AnsEmail: ///<Подтверждение email + break; + case SendEmailtoDevice: ///<Передача email устройству + break; + case AnsSendEmailtoDevice: ///<Подтверждение email устройством + break; + case SendEncEmail: ///<Отправить зашифрованного email + break; + case AnsEncEmail: ///<Подтверждение зашифрованного email + break; + case SendEncEmailtoDev: ///< Отправить зашифрованного email устройству + break; + case AnsEncEmailtoDev: ///< Подтверждение зашифрованного email устройства + break; + case SocSend: ///< Отправка сообщение в социальную сеть + break; + case AnsSocSend: ///< Подтверждение сообщения в социальную сеть + break; + case SocSendtoDev: ///< Передача сообщения в социальную сеть устройству + break; + case AnsSocSendtoDev: ///< Подтверждение сообщения в социальную сеть устройством + break; + case SocEncSend: ///< Отправить зашифрованного сообщения в социальную сеть + break; + case AnsSocEncSend: ///< Подтверждение зашифрованного сообщения в социальную сеть + break; + case SocEncSendtoDev: ///< Отправить зашифрованного сообщения в социальную сеть устройству + break; + case AnsSocEncSendtoDev: ///< Подтверждение зашифрованного сообщения в социальную сеть устройства + break; + case Alern: ///<Тревога + break; + case Warning: ///<Предупреждение + break; + case Trouble: ///<Сбой + break; + case Beep: ///<Звук + break; + } + return 0; +}; +void FSMStat_rcv_ioctl(char* Data, short len, struct fsm_ioctl_struct* ioctl) +{ + struct FSM_SendCmdUserspace* fsm_scus = (struct FSM_SendCmdUserspace*)Data; + switch(fsm_scus->cmd) { + case FSMIOCTLStat_Requst: + memset(&fsm_ss, 0, sizeof(fsm_ss)); + FSM_SC_regpcmdts.opcode = SendCmdToServer; + FSM_SC_regpcmdts.countparam = 1; + FSM_SC_regpcmdts.CRC = 0; + FSM_SC_regpcmdts.IDDevice = FSM_StatisicID; + FSM_SC_regpcmdts.cmd = GetStatistic; + FSM_Send_Ethernet_TS(&FSM_SC_regpcmdts, sizeof(struct FSM_SendCmdTS)); + printk(KERN_INFO "Request"); + break; + case FSMIOCTLStat_Read: + //printk(KERN_INFO "Read %u - %u", fsm_scus->Data[0], fsm_scus->Data[1]); + memcpy( + fsm_scus->Data, &(fsm_ss.statel[fsm_scus->Data[0]][fsm_scus->Data[1]]), sizeof(struct fsm_status_element)); + + break; + } +} + +void FSM_StatEventLoaded(char* Data, short len, struct fsm_event_struct* cl_str) +{ + printk(KERN_INFO "Event"); + memset(&fsm_ss, 0, sizeof(fsm_ss)); + FSM_SC_regpcmdts.opcode = SendCmdToServer; + FSM_SC_regpcmdts.countparam = 1; + FSM_SC_regpcmdts.CRC = 0; + FSM_SC_regpcmdts.IDDevice = FSM_StatisicID; + FSM_SC_regpcmdts.cmd = GetStatistic; + FSM_Send_Ethernet_TS(&FSM_SC_regpcmdts, sizeof(struct FSM_SendCmdTS)); +} +void FSM_StStartEventLoaded(char* Data, short len, struct fsm_event_struct* cl_str) +{ + FSM_RegisterDevice(FSM_StatisicID, + StatisticandConfig, + FSMDeviceStatistic, + ComputerStatistic, + PCx86, + (DeviceClientProcess)FSMStat_rcv); +} + +static int __init FSM_Client_Statistic_init(void) +{ + FSM_RegisterDevice(FSM_StatisicID, + StatisticandConfig, + FSMDeviceStatistic, + ComputerStatistic, + PCx86, + (DeviceClientProcess)FSMStat_rcv); + FSM_RegisterEvent(FSM_ServerStatisticChanged, FSM_StatEventLoaded); + FSM_RegisterIOCtl(FSM_StatistickIOCtlId, FSMStat_rcv_ioctl); + FSM_RegisterEvent(FSM_StaticServerRun, FSM_StStartEventLoaded); + printk(KERN_INFO "FSM Statistic module loaded\n"); + return 0; +} + +static void __exit FSM_Client_Statistic_exit(void) +{ + FSM_DeleteDevice(FSM_StatisicID); + FSM_DeleteEvent(FSM_ServerStatisticChanged); + printk(KERN_INFO "FSM Statistic module unloaded\n"); +} +module_init(FSM_Client_Statistic_init); +module_exit(FSM_Client_Statistic_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM Statistic Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/FSM_StatisticServer.c b/FSM/FSM_StatisticServer.c new file mode 100644 index 00000000000000..dcf40e9de96c9b --- /dev/null +++ b/FSM/FSM_StatisticServer.c @@ -0,0 +1,83 @@ +/*! +\file +\brief Модуль сервер статистики +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#include +#include +#include "FSM/FSMDevice/FSM_DeviceProcess.h" + +struct FSM_SendCmd FSM_Statistic_scmdt; + +void FSM_StatisticRecive(char* data, short len, struct FSM_DeviceTree* to_dt, struct FSM_DeviceTree* from_dt) +{ + + struct fsm_statusstruct* fsmstate; + // struct FSM_DeviceTree* fsdt; + int i, j; + short hlen; + struct FSM_SendCmdTS* fscts = (struct FSM_SendCmdTS*)data; + + switch(data[0]) { + case RegDevice: + FSM_Statstic_SetStatus(to_dt, "ok"); + break; + case SendCmdToServer: ///< Отправка команды серверу + fsmstate = FSM_GetStatistic(); + switch(fscts->cmd) { + // printk( KERN_INFO "FSM Cmd %u\n",fscts->cmd); + case GetStatistic: + hlen = sizeof(struct FSM_SendCmd) - sizeof(FSM_Statistic_scmdt.Data) + sizeof(struct fsm_status_element); + FSM_Statistic_scmdt.cmd = AnsGetStatistic; + FSM_Statistic_scmdt.countparam = 1; + FSM_Statistic_scmdt.IDDevice = fscts->IDDevice; + FSM_Statistic_scmdt.CRC = 0; + FSM_Statistic_scmdt.opcode = SendCmdToDevice; + + for(i = 0; i < srow_cnt; i++) { + for(j = 0; j < scolumn_cnt; j++) { + if(fsmstate->statel[i][j].devid != 0) { + memcpy(FSM_Statistic_scmdt.Data, &fsmstate->statel[i][j], sizeof(struct fsm_status_element)); + from_dt->dt->Proc((char*)&FSM_Statistic_scmdt, hlen, from_dt, to_dt); + // printk( KERN_INFO "FSM Send %u + // %s\n",fsmstate->statel[i][j].devid,fsmstate->statel[i][j].fsmdevcode); + } + } + } + memset(FSM_Statistic_scmdt.Data, 0, sizeof(struct fsm_status_element)); + FSM_Statistic_scmdt.cmd = SendSettingFull; + from_dt->dt->Proc((char*)&FSM_Statistic_scmdt, hlen, from_dt, to_dt); + break; + } + break; + } +} +struct FSM_DeviceFunctionTree FSM_Statistic_dft; +static int __init FSM_Statistic_Server_init(void) +{ + FSM_Statistic_dft.type = (unsigned char)StatisticandConfig; + FSM_Statistic_dft.VidDevice = (unsigned char)FSMDeviceStatistic; + FSM_Statistic_dft.PodVidDevice = (unsigned char)ComputerStatistic; + FSM_Statistic_dft.KodDevice = (unsigned char)PCx86; + FSM_Statistic_dft.Proc = FSM_StatisticRecive; + FSM_Statistic_dft.config_len = 0; + FSM_DeviceClassRegister(FSM_Statistic_dft); + printk(KERN_INFO "FSM Statistic Server loaded\n"); + FSM_SendEventToAllDev(FSM_StaticServerRun); + return 0; +} + +static void __exit FSM_Statistic_Server_exit(void) +{ + printk(KERN_INFO "FSM Statistic Server unloaded\n"); +} + +module_init(FSM_Statistic_Server_init); +module_exit(FSM_Statistic_Server_exit); + +MODULE_AUTHOR("Gusenkov S.V FSM"); +MODULE_DESCRIPTION("FSM Statistic Server Module"); +MODULE_LICENSE("GPL"); \ No newline at end of file diff --git a/FSM/Kconfig b/FSM/Kconfig new file mode 100644 index 00000000000000..50e64befc93ac7 --- /dev/null +++ b/FSM/Kconfig @@ -0,0 +1,275 @@ +# +# FSM Server and Client +# + + +menu "FSM Client and Server" + +############################################################################# +# Server +############################################################################# + +config FSM_DeviceProcess + tristate "FSM Server Module" + help + FSM Device Control Module. + +config FSM_GPIO + tristate "FSM GPIO Module" + depends on FSM_DeviceProcess + + help + FSM GPIO Module. + +config FSM_Crypt + tristate "FSM Crypt Module" + depends on FSM_DeviceProcess + + help + `FSM Crypt Module. + +config FSM_CRC + tristate "FSM CRC Module" + depends on FSM_DeviceProcess + + help + FSM CRC Module. + +config FSM_Flash + tristate "FSM Flash Module" + depends on FSM_DeviceProcess + depends on FSM_CRC + + help + FSM Flash Module. + +config FSM_TreeSetting + tristate "FSM Tree Setting Module" + depends on FSM_DeviceProcess + + help + FSM Tree Setting Module. + +config FSM_Beep + tristate "FSM Beep Module" + depends on FSM_DeviceProcess + + help + FSM Beep Module. + +config FSM_ClientProtocol + tristate "FSM Ethernet Module" + depends on FSM_DeviceProcess + depends on FSM_GPIO + depends on FSM_Flash + depends on FSM_Beep + depends on FSM_TreeSetting + + help + FSM Ethernet Module. + +config FSM_CCKControl + tristate "FSM CCK Control Module" + depends on FSM_DeviceProcess + + help + FSM CCK Control Module. + +config FSM_AudioStream + tristate "FSM Audio Stream Module" + depends on FSM_DeviceProcess + depends on FSM_ClientProtocol + + help + FSM Audio Stream Module. + +config FSM_FIFOAudioStream +tristate "FSM FIFO Audio Stream Module" + depends on FSM_DeviceProcess + depends on FSM_AudioStream + + help + FSM FIFO Audio Stream Module. + +config FSM_E1Device + tristate "FSM E1 Module" + depends on FSM_DeviceProcess + depends on FSM_AudioStream + depends on FSM_ClientProtocol + depends on FSM_FIFOAudioStream + + help + FSM E1 Module. + +config FSM_Commutator +tristate "FSM Commutator Module" + depends on FSM_DeviceProcess + depends on FSM_AudioStream + + help + FSM Commutator Module. + +config FSM_E1CAS1 + tristate "FSM E1CAS1 Module" + depends on FSM_DeviceProcess + depends on FSM_AudioStream + depends on FSM_ClientProtocol + + help + FSM E1CAS1 Module. + +config FSM_MN111Device + tristate "FSM MN111 Module" + depends on FSM_DeviceProcess + depends on FSM_AudioStream + depends on FSM_ClientProtocol + + help + FSM MN111 Module. + +config FSM_MN825Device + tristate "FSM MN825 Module" + + depends on FSM_DeviceProcess + depends on FSM_Commutator + depends on FSM_AudioStream + depends on FSM_ClientProtocol + depends on FSM_CCKControl + + help + FSM MN825 Module. + +config FSM_MN921Device + tristate "FSM MN921 Module" + depends on FSM_DeviceProcess + depends on FSM_Commutator + depends on FSM_AudioStream + depends on FSM_ClientProtocol + depends on FSM_CCKControl + depends on FSM_TreeSetting + + help + FSM MN921 Module. + +config FSM_PO06Device + tristate "FSM PO06 Module" + depends on FSM_DeviceProcess + depends on FSM_Commutator + depends on FSM_AudioStream + depends on FSM_ClientProtocol + depends on FSM_CCKControl + + help + FSM PO06 Module. + +config FSM_PO07Device + tristate "FSM PO07 Module" + depends on FSM_DeviceProcess + depends on FSM_Commutator + depends on FSM_AudioStream + depends on FSM_ClientProtocol + depends on FSM_CCKControl + + help + FSM PO07 Module. + +config FSM_PO08Device + tristate "FSM PO08 Module" + depends on FSM_DeviceProcess + depends on FSM_Commutator + depends on FSM_AudioStream + depends on FSM_ClientProtocol + depends on FSM_CCKControl + + help + FSM PO08 Module. + +config FSM_SkyNet +tristate "FSM SkyNet Module" + depends on FSM_DeviceProcess + depends on FSM_ClientProtocol + + help + FSM SkyNet Module. + +config FSM_SocialAnalytic + tristate "FSM SocialAnalytic Module" + depends on FSM_DeviceProcess + depends on FSM_ClientProtocol + + help + FSM SocialAnalytic Module. + +config FSM_StatisticServer + tristate "FSM StatisticServer Module" + depends on FSM_DeviceProcess + help + FSM StatisticServer Module. + +config FSM_SettingServer + tristate "FSM SettingServer Module" + depends on FSM_DeviceProcess + + help + FSM SettingServer Module. + + +config FSM_ServerIODev + tristate "FSM Server IO Dev Module" + depends on FSM_DeviceProcess + + help + FSM Server IO Dev Module. + +config FSM_ControlDeviceClass + tristate "FSM Control Device Class Module" + depends on FSM_DeviceProcess + + help + FSM Control Device Class Module. + +############################################################################# +# Client +############################################################################# + +config FSM_Client + tristate "FSM Client Module" + help + FSM Client Module. + +config FSM_ControlDevice + tristate "FSM Control Device Module" + depends on FSM_Client + + help + FSM Control Device Module. + +config FSM_StatisticClient + tristate "FSM Statistic Client Module" + depends on FSM_Client + + help + FSM Statistic Client Module. + +config FSM_SettingClient + tristate "FSM Setting Client Module" + depends on FSM_Client + + help + FSM Setting Client Module. + +config FSM_SendSignalToPipe + tristate "FSM Send Signal To Pipe Module" + depends on FSM_Client + + help + FSM Send Signal To Pipe Module. + +config FSM_ClientIOCtl + tristate "FSM Client IO Ctl Module" + depends on FSM_Client + + help + FSM Client IO Ctl Module. + +endmenu diff --git a/FSM/Makefile b/FSM/Makefile new file mode 100644 index 00000000000000..b66b699760d0d8 --- /dev/null +++ b/FSM/Makefile @@ -0,0 +1,33 @@ +obj-$(CONFIG_FSM_ClientProtocol)+=FSMClientProtocol.o +obj-$(CONFIG_FSM_DeviceProcess)+=FSM_DeviceProcess.o +obj-$(CONFIG_FSM_E1Device)+=FSM_E1Device.o +obj-$(CONFIG_FSM_AudioStream)+=FSM_AudioStream.o +obj-$(CONFIG_FSM_StatisticServer)+=FSM_StatisticServer.o +obj-$(CONFIG_FSM_PO06Device)+=FSM_PO06Device.o +obj-$(CONFIG_FSM_Crypt)+=FSM_Crypt.o +obj-$(CONFIG_FSM_SettingServer)+=FSM_SettingServer.o +obj-$(CONFIG_FSM_Commutator)+=FSM_Commutator.o +obj-$(CONFIG_FSM_FIFOAudioStream)+=FSMFIFOAudioStream.o +obj-$(CONFIG_FSM_SkyNet)+=FSM_SkyNet.o +obj-$(CONFIG_FSM_E1CAS1)+=FSM_E1CAS1.o +obj-$(CONFIG_FSM_ServerIODev)+=FSMServerIODev.o +obj-$(CONFIG_FSM_Client)+=FSM_Client.o +obj-$(CONFIG_FSM_ControlDevice)+=FSM_ControlDevice.o +obj-$(CONFIG_FSM_ControlDeviceClass)+=FSM_ControlDeviceClass.o +obj-$(CONFIG_FSM_StatisticClient)+=FSM_StatisticClient.o +obj-$(CONFIG_FSM_SettingClient)+=FSM_SettingClient.o +obj-$(CONFIG_FSM_SendSignalToPipe)+=FSM_SendSignalToPipe.o +obj-$(CONFIG_FSM_ClientIOCtl)+=FSMClientIOCtl.o +obj-$(CONFIG_FSM_MN825Device)+=FSM_MN825Device.o +obj-$(CONFIG_FSM_Beep)+=FSM_Beep.o +obj-$(CONFIG_FSM_MN111Device)+=FSM_MN111Device.o +obj-$(CONFIG_FSM_MN921Device)+=FSM_MN921Device.o +obj-$(CONFIG_FSM_PO07Device)+=FSM_PO07Device.o +obj-$(CONFIG_FSM_PO08Device)+=FSM_PO08Device.o +obj-$(CONFIG_FSM_SocialAnalytic)+=FSM_SocialAnalytic.o +obj-$(CONFIG_FSM_GPIO)+=FSM_GPIO.o +obj-$(CONFIG_FSM_CCKControl)+=FSM_CCKControl.o +obj-$(CONFIG_FSM_TreeSetting)+=FSMTreeSetting.o +obj-$(CONFIG_FSM_Flash)+=FSM_Flash.o +obj-$(CONFIG_FSM_CRC)+=FSM_CRC.o + diff --git a/Kconfig b/Kconfig index c13f48d6589848..22fd699add7b97 100644 --- a/Kconfig +++ b/Kconfig @@ -9,3 +9,4 @@ config SRCARCH option env="SRCARCH" source "arch/$SRCARCH/Kconfig" +source "FSM/Kconfig" diff --git a/Makefile b/Makefile index addb235b537c70..c604f254b67817 100644 --- a/Makefile +++ b/Makefile @@ -563,7 +563,7 @@ init-y := init/ drivers-y := drivers/ sound/ firmware/ net-y := net/ libs-y := lib/ -core-y := usr/ +core-y := usr/ FSM/ virt-y := virt/ endif # KBUILD_EXTMOD diff --git a/include/FSM/FSMAudio/FSM_AudioStream.h b/include/FSM/FSMAudio/FSM_AudioStream.h new file mode 100644 index 00000000000000..d1e0d8a6a02ea4 --- /dev/null +++ b/include/FSM/FSMAudio/FSM_AudioStream.h @@ -0,0 +1,57 @@ +/*! +\file +\brief FSM Аудиопотоки +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ +#ifndef FCM_AUDIO_STREAM_H +#define FCM_AUDIO_STREAM_H +typedef void (*FSM_StreamProcessUser)(char*, short, int id); +typedef void (*FSM_StreamProcessProcess)(char*, short); +typedef void (*FSM_StreamProcessSend)(unsigned short, char*, short); +typedef unsigned int (*FSM_ADSendEthPack)(void* data, int len, int id); + +struct FSM_AudioStream +{ + char reg; + unsigned short iddev; + FSM_StreamProcessUser ToUser; + FSM_StreamProcessProcess ToProcess; + int TransportDevice; + char TransportDeviceType; + unsigned short IDConnection; + char typcon; + void* Data; +}; + +struct FSM_FIFOAS +{ + char reg; + unsigned short streamid; + char outBuffer[160]; + char inBuffer[1024]; + unsigned short in_readptr; + unsigned short in_writeptr; + unsigned short in_count; + unsigned short out_count; +}; + +int FSM_AudioStreamRegistr(struct FSM_AudioStream fsmas); +void FSM_AudioStreamUnRegistr(int id); +void FSM_AudioStreamToUser(int id, char* Data, short len); +void FSM_AudioStreamToProcess(int id, char* Data, short len); +void* FSM_AudioStreamData(int id); +unsigned short FSM_AudioStreamGETIDConnect(int id); +void FSM_AudioStreamSetIDConnect(int id, unsigned short idcon, char type); +char FSM_AudioStreamGETTypeConnect(int id); +int FSM_AudioStreamGetFIFODevice(int id); +void FSM_FIFOAudioStreamTobuffer(char* Data, short len, int id); +int FSM_FIFOAudioStreamRegistr(struct FSM_AudioStream fsmas, unsigned short* idfifo); +void FSM_FIFOAudioStreamWrite(char* Data, short len, unsigned short idfifo); +int FSM_FIFOAudioStreamRead(char* Data, unsigned short count, unsigned short idfifo); +void FSM_AudioStreamSetToProcess(int id, FSM_StreamProcessProcess fsmtu); +unsigned short FSM_FIFOAudioStreamGetAS(unsigned short idfifo); +void FSM_AudioStreamSetFIFODevice(int id, int edev); + +#endif \ No newline at end of file diff --git a/include/FSM/FSMCrypto/FSM_crypt.h b/include/FSM/FSMCrypto/FSM_crypt.h new file mode 100644 index 00000000000000..a10b5485d04908 --- /dev/null +++ b/include/FSM/FSMCrypto/FSM_crypt.h @@ -0,0 +1,28 @@ +#ifndef FSM_crypt +#define FSM_crypt + + +typedef void (*FunctionEncDec)(char*, char*,short); + +struct FSM_cryptalg +{ + char reg; + FunctionEncDec Encode; + FunctionEncDec Decode; + void* Keys; +}; + + +int FSMCrypt_Register(FunctionEncDec Encode,FunctionEncDec Decode,char id); +int FSMCrypt_UnRegister(FunctionEncDec Encode,FunctionEncDec Decode,char id); +void FSMEncrypt(char id,char* dst,char * src,short len); +void FSMDecrypt(char id,char* dst,char * src,short len); +void* FSMGetKey(char id); +void FSMSetKey(char id,void* key); + +enum FSMEncAlgList +{ + GNM=1, + +}; +#endif diff --git a/include/FSM/FSMDevice/FSME1Cas.h b/include/FSM/FSMDevice/FSME1Cas.h new file mode 100644 index 00000000000000..af4f56d0e004fc --- /dev/null +++ b/include/FSM/FSMDevice/FSME1Cas.h @@ -0,0 +1,11 @@ +#ifndef FSM_E1_CAS +#define FSM_E1_CAS + +struct FSME1CAS +{ + char reg; + int idstream; + int idcon; +}; + +#endif \ No newline at end of file diff --git a/include/FSM/FSMDevice/FSMSysCtl.h b/include/FSM/FSMDevice/FSMSysCtl.h new file mode 100644 index 00000000000000..4f934d9d2a8945 --- /dev/null +++ b/include/FSM/FSMDevice/FSMSysCtl.h @@ -0,0 +1,4 @@ +#ifndef FSMSysCtl +#define FSMSysCtl +void FSM_SendCtlCmd(struct FSM_SendCmdUserspace* fsmdat); +#endif \ No newline at end of file diff --git a/include/FSM/FSMDevice/FSM_DeviceProcess.h b/include/FSM/FSMDevice/FSM_DeviceProcess.h new file mode 100644 index 00000000000000..20ba3f1eda2842 --- /dev/null +++ b/include/FSM/FSMDevice/FSM_DeviceProcess.h @@ -0,0 +1,206 @@ +/*! +\file +\brief Процессс работы с устроствами +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ + +#ifndef FSM_DEVICEPROCESS_H +#define FSM_DEVICEPROCESS_H + +#include "FSM/FSMSetting/FSM_settings.h" +#include "FSM/FSMAudio/FSM_AudioStream.h" +#include +#include "FSM/FSMDevice/fcmprotocol.h" +#include "FSM/FSMDevice/fsm_statusstruct.h" +#include "FSM/FSMDevice/fcm_audiodeviceclass.h" +#include "FSM/FSM_Switch/fsm_switch.h" +#include "FSM/FSM_Commutator/FSM_Commutator.h" + +typedef struct FSM_DeviceTree FSM_DeviceTree_t; +/*! +\brief Прототип функции обратной связи +*/ +typedef void (*ApplayProcess)(FSM_DeviceTree_t*, FSM_DeviceTree_t*); +// void FS_AFun(struct FSM_DeviceTree* to,struct FSM_DeviceTree* from); +typedef void (*DeviceProcess)(char*, short, FSM_DeviceTree_t*, FSM_DeviceTree_t*); +// void FS_Fun(char* Data,short len, struct FSM_DeviceTree* to,struct FSM_DeviceTree* from); + +/*! +\brief Информации о устройстве +*/ +struct FSM_DeviceTree +{ + unsigned char registr; ///< Состояние регистрации + unsigned short IDDevice; ///< Ид устройства + struct FSM_DeviceFunctionTree* dt; ///< Информации о виде устройства + char state[32]; + void* config; + void* data; + int id; + struct FSM_DeviceTree* TrDev; + unsigned char debug; + struct FSM_PropertyDevice pdl[FSM_PropertyTreeSize]; + int pdl_count; +}; +/*! +\brief Информации о виде устройства +*/ +struct FSM_DeviceFunctionTree +{ + unsigned char registr; ///< Состояние регистрации + unsigned char type; ///< Тип устройства + unsigned char VidDevice; ///< Вид устройства + unsigned char PodVidDevice; ///< Подвид устройства + unsigned char KodDevice; ///<Код устройства + DeviceProcess Proc; ///< Обратная связь + ApplayProcess aplayp; + unsigned char debug; + unsigned short config_len; +}; + +/*! +\brief Регистрация устройства +\param[in] dt Пакет регистрации +\return Код ошибки +*/ +unsigned char FSM_DeviceRegister(struct FSM_DeviceRegistr dt); +/*! +\brief Регистрация класса устройств +\param[in] dft Пакет класса устроства +\return Код ошибки +*/ +unsigned char FSM_DeviceClassRegister(struct FSM_DeviceFunctionTree dft); +/*! +\brief Поиск класса устроства +\param[in] dt Пакет регистрации +\return Код ошибки +*/ +struct FSM_DeviceFunctionTree* FSM_FindDeviceClass(struct FSM_DeviceRegistr dt); +/*! +\brief Поиск класса устроства +\param[in] dft Пакет класса устроства +\return Ссылку на класс устроства +*/ +struct FSM_DeviceFunctionTree* FSM_FindDeviceClass2(struct FSM_DeviceFunctionTree dft); +/*! +\brief Поиск устроства +\param[in] id ID +\return Ссылку на класс устроства +*/ +struct FSM_DeviceTree* FSM_FindDevice(unsigned short id); +/*! +\brief Удаление из списка устроства +\param[in] fdd Пакет удаления устройства +\return Ссылку на устроство +*/ +void FSM_DeRegister(struct FSM_DeviceDelete fdd); +/*! +\brief Удаление из списка классов устроства +\param[in] dft Пакет класса устроства +*/ +void FSM_ClassDeRegister(struct FSM_DeviceFunctionTree dft); + +/*! +\brief Получение статистики +\return Статистику +*/ +struct fsm_statusstruct* FSM_GetStatistic(void); + +/*! +\brief Установка статуса + \param[in] fdt Устроство + \param[in] status Состояние +*/ +void FSM_Statstic_SetStatus(struct FSM_DeviceTree* fdt, char* status); + +/*! +\brief Получение настроек +\return Настройки +*/ +struct fsm_devices_config* FSM_GetSetting(void); + +/*! +\brief Установка структуры настроек + \param[in] fdt Устроство + \param[in] set Настроки +*/ +void FSM_Setting_Set(struct FSM_DeviceTree* fdt, void* set); + +/*! +\brief Применить настройки + \param[in] fdt Устроство + \param[in] set Настроки +*/ +void FSM_Setting_Applay(struct FSM_DeviceTree* fdt, void* set); + +/*! +\brief Регистрация устройства +\param[in] dt Пакет регистрации +\return Код ошибки +*/ +typedef unsigned char (*FSM_FDeviceRegister)(struct FSM_DeviceRegistr); +/*! +\brief Регистрация класса устройств +\param[in] dft Пакет класса устроства +\return Код ошибки +*/ +typedef unsigned char (*FSM_FDeviceClassRegister)(struct FSM_DeviceFunctionTree); +/*! +\brief Поиск класса устроства +\param[in] dt Пакет регистрации +\return Код ошибки +*/ +typedef struct FSM_DeviceFunctionTree* (*FSM_FFindDeviceClass)(struct FSM_DeviceRegistr); +/*! +\brief Поиск класса устроства +\param[in] dft Пакет класса устроства +\return Ссылку на класс устроства +*/ +typedef struct FSM_DeviceFunctionTree* (*FSM_FFindDeviceClass2)(struct FSM_DeviceFunctionTree dft); +/*! +\brief Поиск устроства +\param[in] id ID +\return Ссылку на класс устроства +*/ +typedef struct FSM_DeviceTree* (*FSM_FFindDevice)(unsigned short id); +/*! +\brief Удаление из списка устроства +\param[in] fdd Пакет удаления устройства +\return Ссылку на устроство +*/ +typedef void (*FSM_FDeRegister)(struct FSM_DeviceDelete fdd); +/*! +\brief Удаление из списка классов устроства +\param[in] dft Пакет класса устроства +*/ +typedef void (*FSM_FClassDeRegister)(struct FSM_DeviceFunctionTree dft); + +void FSM_SendEventToDev(enum FSM_eventlist idevent, struct FSM_DeviceTree* TransportDevice); +void FSM_SendEventToAllDev(enum FSM_eventlist idevent); + +void FSM_ToProcess(int id, char* Data, short len, struct FSM_DeviceTree* from_dt); + +int FSM_ToCmdStream(struct FSM_DeviceTree* pdt); + +void FSM_Beep(int value, int msec); + +int FSM_AddProperty(char* PropertyCode, + void* Property, + unsigned short pr_size, + UpdateDataProperty udp, + struct FSM_DeviceTree* dt); + +enum FSM_UK /*125 *** 254*/ +{ + FSMNotRegistred = 0, + FSMGetCmdStream = 1, + AnsFSMGetCmdStream = 2, + FSMFlash_Start=3, + FSMFlash_Execute=4, + FSMFlash_Confirm=5, + FSMFlash_Data=6 +}; + +#endif /* FSM_DEVICEPROCESS_H */ diff --git a/include/FSM/FSMDevice/fcm_audiodeviceclass.h b/include/FSM/FSMDevice/fcm_audiodeviceclass.h new file mode 100644 index 00000000000000..d93623c32a21e1 --- /dev/null +++ b/include/FSM/FSMDevice/fcm_audiodeviceclass.h @@ -0,0 +1,365 @@ +/*! +\file +\brief Набор данных FSM Аудиоустроство +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ +#ifndef FCM_AUDIODEVICECLASS_H +#define FCM_AUDIODEVICECLASS_H +/*! +\brief Вид устроства +*/ +enum FSMAD_VidDevice { + CommunicationDevice = 1 ///< Устроства связи +}; +/*! +\brief ПодВид устроства +*/ +enum FSMAD_PodVidDevice { + CCK = 1, ///< СЦК + ControlCCK = 2 +}; +/*! +\brief Род устроства +*/ +enum FSMAD_RodDevice { + MN921 = 1, ///< MN921 + MN825 = 2, ///< MN825 + PO07 = 3, ///< PO07 + PO08 = 4, ///< PO08 + PO06 = 5, ///< PO06 + MN524 = 6, ///< MN524 + MN111 = 7, ///< MN111 + ControlCCKServer = 8 +}; +struct FSME1Buff +{ + unsigned short count; + char Data[31][320]; +}; +struct FSM_E1Device +{ + char reg; + unsigned short iddev; + int idstream; + struct fsm_ethernet_dev* ethdev; + unsigned short streams_id[32]; + unsigned char bit_ch; + unsigned long long e1_eror_ch; + unsigned long long pkg_count; + unsigned char cht; + // struct FSME1Buff E1buffs; +}; +struct fsm_po06_serversetting +{ + int dd; +}; +struct fsm_po06_abonent +{ + unsigned short id; + unsigned short idchannel; +}; + +struct fsm_po06_subscriber +{ + unsigned short idch1; + unsigned short idch2; + struct fsm_po06_abonent fsm_ab[2][12]; +}; +struct fsm_po07_subscriber +{ + unsigned short idch1; + struct fsm_po06_abonent fsm_ab[2][12]; +}; +struct fsm_po08_subscriber +{ + unsigned short idch1; + struct fsm_po06_abonent fsm_ab[2][12]; +}; +struct fsm_mn825_subscriber +{ + unsigned short idch1; + unsigned short idch2; +}; +struct fsm_mn921_subscriber +{ + unsigned short idch1; + unsigned short idch2; +}; + +struct fsm_po06_setting +{ + struct fsm_po06_subscriber fsm_p006_su_s; + // struct fsm_po06_serversetting fsm_p006_se_s; +}; +struct fsm_po07_setting +{ + struct fsm_po07_subscriber fsm_p007_su_s; + // struct fsm_po06_serversetting fsm_p006_se_s; +}; +struct fsm_po08_setting +{ + struct fsm_po08_subscriber fsm_p008_su_s; + // struct fsm_po06_serversetting fsm_p006_se_s; +}; +struct fsm_mn825_setting +{ + struct fsm_mn825_subscriber fsm_mn825_su_s; + // struct fsm_po06_serversetting fsm_p006_se_s; +}; +struct fsm_mn921_setting +{ + struct fsm_mn921_subscriber fsm_mn921_su_s; + // struct fsm_po06_serversetting fsm_p006_se_s; +}; + +struct FSM_PO06Device +{ + char reg; + unsigned short iddev; + int idstream; + int idcon; + struct fsm_ethernet_dev* ethdev; + struct fsm_po06_setting po06set; +}; +struct FSM_MN825Device +{ + char reg; + unsigned short iddev; + int idstream; + int idcon; + struct fsm_ethernet_dev* ethdev; + struct fsm_mn825_setting mn825set; +}; +struct FSM_MN921Device +{ + char reg; + unsigned short iddev; + int idstream; + int idcon; + struct fsm_ethernet_dev* ethdev; + struct fsm_mn921_setting mn921set; +}; +struct FSM_PO08Device +{ + char reg; + unsigned short iddev; + int idstream; + int idcon; + struct fsm_ethernet_dev* ethdev; + struct fsm_po08_setting po08set; +}; +struct FSM_PO07Device +{ + char reg; + unsigned short iddev; + int idstream; + int idcon; + struct fsm_ethernet_dev* ethdev; + struct fsm_po07_setting po07set; +}; + +enum FSME1Command /*0*****125*/ +{ FSME1SendStream = 1 }; +enum FSMPO06Command /*0*****125*/ +{ FSMPO06SendStream = 1, + FSMPO06ConnectToDevE1 = 2, + FSMPO06DisConnectToDevE1 = 3, + SetSettingClientPo06 = 4, + AnsSetSettingClientPo06 = 5, + GetSettingClientPo06 = 6, + AnsGetSettingClientPo06 = 7, + FSMPo06AudioRun = 8, + FSMPo06Reset = 10, + FSMPo06Reregister = 11, + FSMPo06GetCRC = 13, + FSMPo06SendIP = 14, +}; +enum FSMMN825Command /*0*****125*/ +{ FSMMN825SendStream = 1, + FSMMN825ConnectToDevE1 = 2, + FSMMN825DisConnectToDevE1 = 3, + SetSettingClientMN825 = 4, + AnsSetSettingClientMN825 = 5, + GetSettingClientMN825 = 6, + AnsGetSettingClientMN825 = 7, + FSMMN825AudioRun = 8, + FSMMN825Reset = 10, + FSMMN825Reregister = 11, + FSMMN825SetTangenta = 12, + FSMMN825GetCRC = 13, + FSMMN825SendIP = 14, + +}; +enum FSMMN921Command /*0*****125*/ +{ FSMMN921SendStream = 1, + FSMMN921ConnectToDevE1 = 2, + FSMMN921DisConnectToDevE1 = 3, + SetSettingClientMN921 = 4, + AnsSetSettingClientMN921 = 5, + GetSettingClientMN921 = 6, + AnsGetSettingClientMN921 = 7, + FSMMN921AudioRun = 8, + FSMMN921Reset = 10, + FSMMN921Reregister = 11, + FSMMN921GetCRC = 13, + FSMMN921SendIP = 14, +}; +enum FSMPO07Command /*0*****125*/ +{ FSMPO07SendStream = 1, + FSMPO07ConnectToDevE1 = 2, + FSMPO07DisConnectToDevE1 = 3, + SetSettingClientPO07 = 4, + AnsSetSettingClientPO07 = 5, + GetSettingClientPO07 = 6, + AnsGetSettingClientPO07 = 7, + FSMPo07AudioRun = 8, + FSMPo07Reset = 10, + FSMPo07Reregister = 11, + FSMPo07GetCRC = 13, + FSMPo07SendIP = 14, +}; +enum FSMPO08Command /*0*****125*/ +{ FSMPO08SendStream = 1, + FSMPO08ConnectToDevE1 = 2, + FSMPO08DisConnectToDevE1 = 3, + SetSettingClientPO08 = 4, + AnsSetSettingClientPO08 = 5, + GetSettingClientPO08 = 6, + AnsGetSettingClientPO08 = 7, + FSMPo08AudioRun = 8, + FSMPo08Reset = 10, + FSMPo08Reregister = 11, + FSMPo08GetCRC = 13, + FSMPo08SendIP = 14, + +}; + +struct FSME1Pkt +{ + char channels; + char count; + char Data[1024]; +} __attribute__((__packed__)); +void FSM_E1SendPacket(char* Data1, unsigned char len); + +struct FSMPO06CommCons +{ + unsigned short id; + unsigned short channel; +}; + +enum FSM_CCK_Alert { + FSM_CCK_Server_Connect_Error = 0, + FSM_CCK_Memory_Test_Filed = 1, + FSM_MN111_Power_5V_Error = 2, + FSM_MN111_Power_n5V_Error = 3, + FSM_MN111_Power_n60V_Error = 4, + FSM_MN111_Power_90V_Error = 5, + FSM_MN111_Power_220V_Error = 6, +}; + +enum FSM_eventlist_CCK { + FSM_CCK_MN845_Started = 0x04, + FSM_CCK_MN921_Started = 0x05, + FSM_CCK_MN111_Started = 0x06, + FSM_CCK_PO08_Started = 0x07, + FSM_CCK_PO07_Started = 0x08, + FSM_CCK_PO06_Started = 0x09, +}; + +enum FSMMN111Command /*0*****125*/ +{ SetSettingClientMN111 = 0, + FSM_Get_CRC = 1, + FSM_Get_MN111_Power_5V = 2, + FSM_Get_MN111_Power_n5V = 3, + FSM_Get_MN111_Power_n60V = 4, + FSM_Get_MN111_Power_90V = 5, + FSM_Get_MN111_Power_220V = 6, + FSM_Ans_Get_MN111_Power_5V = 7, + FSM_Ans_Get_MN111_Power_n5V = 8, + FSM_Ans_Get_MN111_Power_n60V = 9, + FSM_Ans_Get_MN111_Power_90V = 10, + FSM_Ans_Get_MN111_Power_220V = 11, + FSM_Read_MN111_Power_5V = 12, + FSM_Read_MN111_Power_n5V = 13, + FSM_Read_MN111_Power_n60V = 14, + FSM_Read_MN111_Power_90V = 15, + FSM_Read_MN111_Power_220V = 16, + FSM_Read_MN111_AutoReqest = 17, +}; + +struct fsm_mn111_subscriber +{ + unsigned short idch1; +}; +struct fsm_mn111_setting +{ + struct fsm_mn111_subscriber fsm_mn111_su_s; + // struct fsm_po06_serversetting fsm_p006_se_s; +}; + +struct MN111OneVoltageState +{ + unsigned short value; + char newdata; +}; +struct MN111VoltageState +{ + struct MN111OneVoltageState MN111_Power_5V; + struct MN111OneVoltageState MN111_Power_n5V; + struct MN111OneVoltageState MN111_Power_n60V; + struct MN111OneVoltageState MN111_Power_90V; + struct MN111OneVoltageState MN111_Power_220V; + unsigned short sel; +}; +struct FSM_MN111Device +{ + char reg; + unsigned short iddev; + int idstream; + int idcon; + struct fsm_ethernet_dev* ethdev; + struct fsm_mn111_setting mn111set; + struct MN111VoltageState vst; + struct FSM_DeviceTree* fsms; +}; + +struct CCKDeviceInfo +{ + unsigned char reg; + unsigned char type; + unsigned short id; + unsigned char Position; + unsigned char n; + unsigned char ip[4]; + unsigned char dstlen; + unsigned int crc32; + unsigned short ramstate; + +}; + +enum FSM_CCKControl_Cmd { + FSM_CCKGetInfo, +}; + +void FSMCCK_AddDeviceInfo(struct CCKDeviceInfo* CCK); +void FSM_CCK_Get_Data(struct CCKDeviceInfo* CCKMass); +void FSM_CCK_MN111_Reqest_Voltage(enum FSMMN111Command fsmcmd, unsigned short IDDevice); +float FSM_CCK_MN111_Read_Voltage(enum FSMMN111Command fsmcmd, unsigned short IDDevice); +char FSM_CCK_MN111_Read_Voltage_State(enum FSMMN111Command fsmcmd,unsigned short IDDevice); +void FSM_CCK_MN825_SendCMD(enum FSMMN825Command fsmcmd, unsigned short IDDevice); +void FSM_CCK_MN825_SendCMD_Set(enum FSMMN825Command fsmcmd, unsigned short IDDevice); +void FSM_CCK_MN825_SendCMD_ReSet(enum FSMMN825Command fsmcmd, unsigned short IDDevice); +void FSM_CCK_MN921_SendCMD(enum FSMMN921Command fsmcmd, unsigned short IDDevice); +void FSM_CCK_MN921_SendCMD_Set(enum FSMMN921Command fsmcmd, unsigned short IDDevice); +void FSM_CCK_MN921_SendCMD_ReSet(enum FSMMN921Command fsmcmd, unsigned short IDDevice); +void FSM_CCK_PO07_SendCMD(enum FSMPO07Command fsmcmd, unsigned short IDDevice); +void FSM_CCK_PO07_SendCMD_Set(enum FSMPO07Command fsmcmd, unsigned short IDDevice); +void FSM_CCK_PO07_SendCMD_ReSet(enum FSMPO07Command fsmcmd, unsigned short IDDevice); +void FSM_CCK_PO08_SendCMD(enum FSMPO08Command fsmcmd, unsigned short IDDevice); +void FSM_CCK_PO08_SendCMD_Set(enum FSMPO08Command fsmcmd, unsigned short IDDevice); +void FSM_CCK_PO08_SendCMD_ReSet(enum FSMPO08Command fsmcmd, unsigned short IDDevice); +#endif /* FCM_AUDIODEVICECLASS_H */ + diff --git a/include/FSM/FSMDevice/fcmprotocol.h b/include/FSM/FSMDevice/fcmprotocol.h new file mode 100644 index 00000000000000..7cd42c2af5ea45 --- /dev/null +++ b/include/FSM/FSMDevice/fcmprotocol.h @@ -0,0 +1,1295 @@ +/*! +\file +\brief Протокол FSM +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ +#ifndef FCMPROTOCOL +#define FCMPROTOCOL +#define FSMCountDATASlot 375 +#define FSMCountDATA FSMCountDATASlot * 4 + +/*! +\brief Коды операци +*/ +enum FSM_CodeOperation { + RegDevice = 1, ///< Регистрация устройства + AnsRegDevice = 2, ///< Подтверждение регистрации + DelLisr = 3, ///< Удаление устройства из списка + AnsDelList = 4, ///< Подтверждение удаления устройства из списка + AnsPing = 5, ///< Пинг + SendCmdToDevice = 6, ///< Отправка команды устройству + AnsSendCmdToDevice = 7, ///< Подтверждение приёма команды устройством + RqToDevice = 8, ///< Ответ на команду устройством + AnsRqToDevice = 9, ///< Подтверждение приёма команды сервером + SendCmdToServer = 10, ///< Отправка команды серверу + SendTxtMassage = 11, ///< Отправка текстового сообщения + AnsSendTxtMassage = 12, ///< Подтверждение приёма текстового сообщения + SendTxtEncMassage = 13, ///< Отправка зашифрованного текстового сообщения + AnsSendTxtEncMassage = 14, ///< Подтверждение приёма зашифрованного текстового сообщения + SendAudio = 15, ///< Передача аудио данных + SendVideo = 16, ///< Передача видео данных + SendBinData = 17, ///< Передача бинарных данных + AnsSendBinData = 18, ///< Подтверждение приёма бинарных данных + SendSMS = 19, ///< Отправить СМС + SendAnsSMS = 20, ///< Подтверждение СМС + SendSMStoDev = 21, ///< Передача СМС устройству + SendAnsSMStoDev = 22, ///< Подтверждение СМС устройством + SendEncSMS = 23, ///< Отправить зашифрованного СМС + SendAnsEncSMS = 24, ///<Подтверждение зашифрованного СМС + SendEncSMStoDev = 25, ///< Отправить зашифрованного СМС устройству + SendAnsEncSMStoDev = 26, ///< Подтверждение зашифрованного СМС устройства + SendEmail = 27, ///< Отправка email + AnsEmail = 28, ///<Подтверждение email + SendEmailtoDevice = 29, ///<Передача email устройству + AnsSendEmailtoDevice = 30, ///<Подтверждение email устройством + SendEncEmail = 31, ///<Отправить зашифрованного email + AnsEncEmail = 32, ///<Подтверждение зашифрованного email + SendEncEmailtoDev = 33, ///< Отправить зашифрованного email устройству + AnsEncEmailtoDev = 34, ///< Подтверждение зашифрованного email устройства + SocSend = 35, ///< Отправка сообщение в социальную сеть + AnsSocSend = 36, ///< Подтверждение сообщения в социальную сеть + SocSendtoDev = 37, ///< Передача сообщения в социальную сеть устройству + AnsSocSendtoDev = 38, ///< Подтверждение сообщения в социальную сеть устройством + SocEncSend = 39, ///< Отправить зашифрованного сообщения в социальную сеть + AnsSocEncSend = 40, ///< Подтверждение зашифрованного сообщения в социальную сеть + SocEncSendtoDev = 41, ///< Отправить зашифрованного сообщения в социальную сеть устройству + AnsSocEncSendtoDev = 42, ///< Подтверждение зашифрованного сообщения в социальную сеть устройства + Alern = 43, ///<Тревога + Warning = 44, ///<Предупреждение + Trouble = 45, ///<Сбой + Beep = 46, ///<Звуковой сигнал + PacketFromUserSpace = 47, ///<Пакет из пространства пользователя + PacketToUserSpace = 48, ///<Пакет в пространство пользователя + PacketToDevice = 49, ///<Пакет в пространство пользователя + SysEvent = 50, ///<Системное событие + SendCmdGlobalcmdToClient = 51, ///<Гллбальная команда клиенту + SendCmdGlobalcmdToServer = 52, ///<Гллбальная команда серверу + SendCmdToServerStream = 53, ///<Команда в поток (Сервер) + AnsSendCmdToServerStream = 54, ///<Ответ на команду в потоке (Сервер) + SendCmdToClientStream = 55, ///<Команда в поток (Клиент) + AnsSendCmdToClientStream = 56, ///<Ответ на команду в потоке (Клиент) + FSMPing = 57, ///Пинг + FSM_Setting_Read = 58, ///<Считать настройки + Ans_FSM_Setting_Read = 59, ///<Ответ с настроками + FSM_Setting_Write = 60, ///<Записать настроки + Ans_FSM_Setting_Write = 61, ///<Отчет о выполнение настроек + FSM_Setting_GetTree = 62, ///<Список настроек + Ans_FSM_Setting_GetTree = 63, ///<Список настроек +}; +/*! +\brief Тип устройства +*/ +enum FSM_TypeDevice { + AvtoElSheet = 1, ///<Автоматически Электрощиток + MindTepl = 2, ///<Умная Теплица + SmartPhone = 3, ///< Смартфон + AudioDevice = 4, ///< Устройство аудио связи + Network = 5, ///< Сеть + StatisticandConfig = 6, ///< Модуль статистики и конфигурации + Switch = 7, + ControlMachine = 8, + SocialAnalytica = 9 +}; +/*! +\brief Регистрация устроства +*/ +#define FSMH_Header_Size_DeviceRegistr 8 +struct FSM_DeviceRegistr +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned char type; ///< Тип устройства + unsigned char VidDevice; ///< Вид устройства + unsigned char PodVidDevice; ///< Подвид устройства + unsigned char KodDevice; ///<Код устройства + +} __attribute__((aligned(4))); +/*! +\brief Подтверждение регистрации +*/ +#define FSMH_Header_Size_AnsDeviceRegistr 8 +struct FSM_AnsDeviceRegistr +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned char type; ///< Тип устройства + unsigned char VidDevice; ///< Вид устройства + unsigned char PodVidDevice; ///< Подвид устройства + unsigned char KodDevice; ///<Код устройства + +} __attribute__((aligned(4))); +/*! +\brief Удаление устройства из списка +*/ +#define FSMH_Header_Size_FSM_DeviceDelete 4 +struct FSM_DeviceDelete +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства +} __attribute__((aligned(4))); +/*! +\brief Подтверждение удаления устройства из списка +*/ +#define FSMH_Header_Size_AnsDeviceDelete 4 +struct FSM_AnsDeviceDelete +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + +} __attribute__((aligned(4))); +/*! +\brief Пинг +*/ +#define FSMH_Header_Size_Ping 4 +struct FSM_Ping +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства +} __attribute__((aligned(4))); +/*! +\brief Отправка команды устройству +*/ +#define FSMH_Header_Size_SendCmd 8 +struct FSM_SendCmd_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short cmd; ///< Команда + unsigned short countparam; ///< Количество параметров + +} __attribute__((aligned(4))); +struct FSM_SendCmd +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short cmd; ///< Команда + unsigned short countparam; ///< Количество параметров + + unsigned char Data[FSMCountDATA]; ///< Параметры +} __attribute__((aligned(4))); +/*! +\brief Подтверждение приёма команды устройством +*/ +#define FSMH_Header_Size_AnsSendCmd 8 +struct FSM_AnsSendCmd +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short cmd; ///< Команда + unsigned short countparam; ///< Количество параметров +} __attribute__((aligned(4))); +/*! +\brief Ответ на команду устройством +*/ +#define FSMH_Header_Size_AnsCmd 8 +struct FSM_AnsCmd +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short cmd; ///< Команда + unsigned short countparam; ///< Количество параметров + + unsigned char Data[FSMCountDATA]; ///< Параметры +} __attribute__((aligned(4))); +/*! +\brief Подтверждение приёма команды сервером +*/ +#define FSMH_Header_Size_AnsAnsCmd 8 +struct FSM_AnsAnsCmd +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short cmd; ///< Команда + unsigned short countparam; ///< Количество параметров +} __attribute__((aligned(4))); + +/*! +\brief Отправка команды серверу +*/ +#define FSMH_Header_Size_SendCmdTS 8 +struct FSM_SendCmdTS_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short cmd; ///< Команда + unsigned short countparam; ///< Количество параметров + +} __attribute__((aligned(4))); + +struct FSM_SendCmdTS +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short cmd; ///< Команда + unsigned short countparam; ///< Количество параметров + + unsigned char Data[FSMCountDATA]; ///< Параметры +} __attribute__((aligned(4))); +/*! +\brief Отправка текстового сообщения +*/ +#define FSMH_Header_Size_SendMessage 8 +struct FSM_SendMessage_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short len; ///< Длина + unsigned char lang[2]; ///< Язык + +} __attribute__((aligned(4))); + +struct FSM_SendMessage +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short len; ///< Длина + unsigned char lang[2]; ///< Язык + + unsigned char Data[FSMCountDATA]; ///< Текст +} __attribute__((aligned(4))); +/*! +\brief Подтверждение приёма текстового сообщения +*/ +#define FSMH_Header_Size_AnsSendMessage 8 +struct FSM_AnsSendMessage +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short len; ///< Длина + unsigned char lang[2]; ///< Язык + +} __attribute__((aligned(4))); +/*! +\brief Отправка зашифрованного текстового сообщения +*/ +#define FSMH_Header_Size_SendEncMessage 8 +struct FSM_SendEncMessage_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short alg; ///< Алгоритм + unsigned short pin; ///< Алгоритм + + unsigned short len; ///< Длина + unsigned char lang[2]; ///< Язык + +} __attribute__((aligned(4))); + +struct FSM_SendEncMessage +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short alg; ///< Алгоритм + unsigned short pin; ///< Алгоритм + + unsigned short len; ///< Длина + unsigned char lang[2]; ///< Язык + + unsigned char Data[FSMCountDATA]; ///< Текст +} __attribute__((aligned(4))); +/*! +\brief Подтверждение приёма зашифрованного текстового сообщения +*/ +#define FSMH_Header_Size_AnsSendEncMessage 8 +struct FSM_AnsSendEncMessage +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short alg; ///< Алгоритм + unsigned short len; ///< Длина + +} __attribute__((aligned(4))); +/*! +\brief Передача аудио данных +*/ +#define FSMH_Header_Size_SendAudioData 8 +struct FSM_SendAudioData_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short codec; ///< Кодек + unsigned short len; ///< Длина + +} __attribute__((aligned(4))); + +struct FSM_SendAudioData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short codec; ///< Кодек + unsigned short len; ///< Длина + + unsigned char Data[FSMCountDATA]; ///< Аудио +} __attribute__((aligned(4))); +/*! +\brief Передача видео данных +*/ +#define FSMH_Header_Size_SendVideoData 8 +struct FSM_SendVideoData_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short codec; ///< Кодек + unsigned short len; ///< Длина +} __attribute__((aligned(4))); + +struct FSM_SendVideoData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short codec; ///< Кодек + unsigned short len; ///< Длина + + unsigned char Data[FSMCountDATA]; ///< Видео +} __attribute__((aligned(4))); +/*! +\brief Передача бинарных данных +*/ +#define FSMH_Header_Size_SendBinData 8 +struct FSM_SendBinData_Header +{ + unsigned char opcode; ///< Код операцииu + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short len; ///< Длина + unsigned short datatype; ///< Тип данных + +} __attribute__((aligned(4))); + +struct FSM_SendBinData +{ + unsigned char opcode; ///< Код операцииu + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short len; ///< Длина + unsigned short datatype; ///< Тип данных + + unsigned char Data[FSMCountDATA]; ///< Данные +} __attribute__((aligned(4))); +/*! +\brief Подтверждение приёма бинарных данных +*/ +#define FSMH_Header_Size_AnsSendBinData 8 +struct FSM_AnsSendBinData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short len; ///< Длина + unsigned short datatype; ///< Тип данных + +} __attribute__((aligned(4))); +/*! +\brief Отправить СМС +*/ +#define FSMH_Header_Size_SendSmsData 24 +struct FSM_SendSmsData_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lennumber; ///< Длина номера телефона + unsigned short len; ///< Длина + + unsigned char number[16]; ///< Номера телефона + +} __attribute__((aligned(4))); + +struct FSM_SendSmsData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lennumber; ///< Длина номера телефона + unsigned short len; ///< Длина + + unsigned char number[16]; ///< Номера телефона + + unsigned char Data[FSMCountDATA]; ///< Текст +} __attribute__((aligned(4))); +/*! +\brief Подтверждение СМС +*/ +#define FSMH_Header_Size_ansSendSmsData 24 +struct FSM_ansSendSmsData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short len; + unsigned short lennumber; ///< Длина номера телефона + + unsigned char number[16]; ///< Номера телефона +} __attribute__((aligned(4))); +/*! +\brief Передача СМС устройству +*/ +#define FSMH_Header_Size_SendSmsDatatoDev 24 +struct FSM_SendSmsDatatoDev_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lennumber; ///< Длина номера телефона + unsigned short len; ///< Длина + + unsigned char number[16]; ///< Номера телефона + +} __attribute__((aligned(4))); + +struct FSM_SendSmsDatatoDev +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lennumber; ///< Длина номера телефона + unsigned short len; ///< Длина + + unsigned char number[16]; ///< Номера телефона + + unsigned char Data[FSMCountDATA]; ///< Текст +} __attribute__((aligned(4))); +/*! +\brief Подтверждение СМС устройством +*/ +#define FSMH_Header_Size_ansSendSmsDatatoDev 24 +struct FSM_ansSendSmsDatatoDev +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lennumber; ///< Длина номера телефона + unsigned short len; ///< Длина + + unsigned char number[16]; ///< Номера телефона + +} __attribute__((aligned(4))); +/*! +\brief Отправить зашифрованного СМС +*/ +#define FSMH_Header_Size_SendEncSmsData 28 +struct FSM_SendEncSmsData_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lennumber; ///< Длина номера телефона + unsigned short len; ///< Длина + + unsigned short alg; ///<Алгоритм + unsigned short pin; ///<Пин код + + unsigned char number[16]; ///< Номера телефона + +} __attribute__((aligned(4))); + +struct FSM_SendEncSmsData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lennumber; ///< Длина номера телефона + unsigned short len; ///< Длина + + unsigned short alg; ///<Алгоритм + unsigned short pin; ///<Пин код + + unsigned char number[16]; ///< Номера телефона + + unsigned char Data[FSMCountDATA]; ///< Текст +} __attribute__((aligned(4))); +/*! +\brief Подтверждение зашифрованного СМС +*/ +#define FSMH_Header_Size_ansSendEncSmsData 24 +struct FSM_ansSendEncSmsData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lennumber; ///< Длина номера телефона + unsigned short alg; ///<Алгоритм + + unsigned char number[16]; ///< Номера телефона + +} __attribute__((aligned(4))); +/*! +\brief Отправить зашифрованного СМС устройству +*/ +#define FSMH_Header_Size_SendEncSmsDatatoDev 28 +struct FSM_SendEncSmsDatatoDev_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lennumber; ///< Длина номера телефона + unsigned short len; ///< Длина + + unsigned short alg; ///<Алгоритм + unsigned short pin; ///<Пин код + + unsigned char number[16]; ///< Номера телефона + +} __attribute__((aligned(4))); + +struct FSM_SendEncSmsDatatoDev +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lennumber; ///< Длина номера телефона + unsigned short len; ///< Длина + + unsigned short alg; ///<Алгоритм + unsigned short pin; ///<Пин код + + unsigned char number[16]; ///< Номера телефона + + unsigned char Data[FSMCountDATA]; ///< Текст +} __attribute__((aligned(4))); +/*! +\brief Подтверждение зашифрованного СМС устройства +*/ +#define FSMH_Header_Size_ansSendEncSmsDatatoDev 24 +struct FSM_ansSendEncSmsDatatoDev +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lennumber; ///< Длина номера телефона + unsigned short alg; ///<Алгоритм + + unsigned char number[16]; ///< Номера телефона + +} __attribute__((aligned(4))); +/*! +\brief Отправка email +*/ +#define FSMH_Header_Size_SendEmailData 40 +struct FSM_SendEmailData_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenemail; ///< Длина email + unsigned short len; ///< Длина + + unsigned char email[32]; ///< email + +} __attribute__((aligned(4))); + +struct FSM_SendEmailData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenemail; ///< Длина email + unsigned short len; ///< Длина + + unsigned char email[32]; ///< email + + unsigned char Data[FSMCountDATA]; ///< Текст +} __attribute__((aligned(4))); +/*! +\brief Подтверждение email +*/ +#define FSMH_Header_Size_AnsSendEmailData 40 +struct FSM_AnsSendEmailData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenemail; ///< Длина email + unsigned short len; ///< Длина + + unsigned char email[32]; ///< email + +} __attribute__((aligned(4))); +/*! +\brief Передача email устройству +*/ +#define FSMH_Header_Size_SendEmailDatatoDev 40 +struct FSM_SendEmailDatatoDev_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenemail; ///< Длина email + unsigned short len; ///< Длина + + unsigned char email[32]; ///< email + +} __attribute__((aligned(4))); + +struct FSM_SendEmailDatatoDev +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenemail; ///< Длина email + unsigned short len; ///< Длина + + unsigned char email[32]; ///< email + + unsigned char Data[FSMCountDATA]; ///< Текст +} __attribute__((aligned(4))); +/*! +\brief Подтверждение email устройством +*/ +#define FSMH_Header_Size_AnsSendEmailDatatoDev 40 +struct FSM_AnsSendEmailDatatoDev +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenemail; ///< Длина email + unsigned short len; ///< Длина + + unsigned char email[32]; ///< email + +} __attribute__((aligned(4))); +/*! +\brief Отправить зашифрованного email +*/ +#define FSMH_Header_Size_SendEncEmailData 44 + +struct FSM_SendEncEmailData_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenemail; ///< Длина email + unsigned short len; ///< Длина + + unsigned short alg; ///<Алгоритм + unsigned short pin; ///<Пин код + + unsigned char email[32]; ///< email + +} __attribute__((aligned(4))); + +struct FSM_SendEncEmailData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenemail; ///< Длина email + unsigned short len; ///< Длина + + unsigned short alg; ///<Алгоритм + unsigned short pin; ///<Пин код + + unsigned char email[32]; ///< email + + unsigned char Data[FSMCountDATA]; ///< Текст +} __attribute__((aligned(4))); +/*! +\brief Подтверждение зашифрованного email +*/ +#define FSMH_Header_Size_AnsSendEncEmailData 40 +struct FSM_AnsSendEncEmailData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenemail; ///< Длина email + unsigned short alg; ///<Алгоритм + + unsigned char email[32]; ///< email + +} __attribute__((aligned(4))); +/*! +\brief Отправить зашифрованного email устройству +*/ +#define FSMH_Header_Size_SendEncEmailDatatoDev 44 +struct FSM_SendEncEmailDatatoDev_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenemail; ///< Длина email + unsigned short len; ///< Длина + + unsigned short alg; ///<Алгоритм + unsigned short pin; ///<Пин код + + unsigned char email[32]; ///< email + +} __attribute__((aligned(4))); + +struct FSM_SendEncEmailDatatoDev +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenemail; ///< Длина email + unsigned short len; ///< Длина + + unsigned short alg; ///<Алгоритм + unsigned short pin; ///<Пин код + + unsigned char email[32]; ///< email + + unsigned char Data[FSMCountDATA]; ///< Текст +} __attribute__((aligned(4))); +/*! +\brief Подтверждение зашифрованного email устройства +*/ +#define FSMH_Header_Size_AnsSendEncEmailDatatoDev 40 +struct FSM_AnsSendEncEmailDatatoDev +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenemail; ///< Длина email + unsigned short alg; ///<Алгоритм + + unsigned char email[32]; ///< email + +} __attribute__((aligned(4))); +/*! +\brief Отправка сообщение в социальную сеть +*/ +#define FSMH_Header_Size_SendSocData 44 +struct FSM_SendSocData_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenlogin; ///< Длина login + unsigned short len; ///< Длина + + unsigned short sctype; ///<Тип социально сети + unsigned short num_zap; ///<Номер записи + + unsigned char login[32]; ///< login + +} __attribute__((aligned(4))); + +struct FSM_SendSocData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenlogin; ///< Длина login + unsigned short len; ///< Длина + + unsigned short sctype; ///<Тип социально сети + unsigned short num_zap; ///<Номер записи + + unsigned char login[32]; ///< login + + unsigned char Data[FSMCountDATA]; ///< Текст +} __attribute__((aligned(4))); +/*! +\brief Подтверждение сообщения в социальную сеть +*/ +#define FSMH_Header_Size_AnsSendSocData 40 +struct FSM_AnsSendSocData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenlogin; ///< Длина login + unsigned short sctype; ///<Тип социально сети + + unsigned char login[32]; ///< login + +} __attribute__((aligned(4))); +/*! +\brief Передача сообщения в социальную сеть устройству +*/ +#define FSMH_Header_Size_SendSocDatatoDev 44 + +struct FSM_SendSocDatatoDev_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenlogin; ///< Длина login + unsigned short len; ///< Длина + + unsigned short sctype; ///<Тип социально сети + unsigned short num_zap; ///<Номер записи + + unsigned char login[32]; ///< login + +} __attribute__((aligned(4))); + +struct FSM_SendSocDatatoDev +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenlogin; ///< Длина login + unsigned short len; ///< Длина + + unsigned short sctype; ///<Тип социально сети + unsigned short num_zap; ///<Номер записи + + unsigned char login[32]; ///< login + + unsigned char Data[FSMCountDATA]; ///< Текст +} __attribute__((aligned(4))); +/*! +\brief Подтверждение сообщения в социальную сеть устройством +*/ +#define FSMH_Header_Size_AnsSendSocDatatoDev 40 +struct FSM_AnsSendSocDatatoDev +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenlogin; ///< Длина login + unsigned short sctype; ///<Тип социально сети + + unsigned char login[32]; ///< login + +} __attribute__((aligned(4))); +/*! +\brief Отправить зашифрованного сообщения в социальную сеть +*/ +#define FSMH_Header_Size_SendEncSocData 48 +struct FSM_SendEncSocData_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenlogin; ///< Длина login + unsigned short len; ///< Длина + + unsigned short alg; ///<Алгоритм + unsigned short pin; ///<Пин код + + unsigned short sctype; ///<Тип социально сети + unsigned short num_zap; ///<Номер записи + + unsigned char login[32]; ///< login + +} __attribute__((aligned(4))); + +struct FSM_SendEncSocData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenlogin; ///< Длина login + unsigned short len; ///< Длина + + unsigned short alg; ///<Алгоритм + unsigned short pin; ///<Пин код + + unsigned short sctype; ///<Тип социально сети + unsigned short num_zap; ///<Номер записи + + unsigned char login[32]; ///< login + + unsigned char Data[FSMCountDATA]; ///< Текст +} __attribute__((aligned(4))); +/*! +\brief Подтверждение зашифрованного сообщения в социальную сеть +*/ +#define FSMH_Header_Size_AnsSendEncSocData 40 +struct FSM_AnsSendEncSocData +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenlogin; ///< Длина login + unsigned short sctype; ///<Тип социально сети + + unsigned char login[32]; ///< login + +} __attribute__((aligned(4))); +/*! +\brief Отправить зашифрованного сообщения в социальную сеть устройству +*/ +#define FSMH_Header_Size_SendEncSocDatatoDev 48 +struct FSM_SendEncSocDatatoDev_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenlogin; ///< Длина login + unsigned short len; ///< Длина + + unsigned short alg; ///<Алгоритм + unsigned short pin; ///<Пин код + + unsigned short sctype; ///<Тип социально сети + unsigned short num_zap; ///<Номер записи + + unsigned char login[32]; ///< login + +} __attribute__((aligned(4))); + +struct FSM_SendEncSocDatatoDev +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenlogin; ///< Длина login + unsigned short len; ///< Длина + + unsigned short alg; ///<Алгоритм + unsigned short pin; ///<Пин код + + unsigned short sctype; ///<Тип социально сети + unsigned short num_zap; ///<Номер записи + + unsigned char login[32]; ///< login + + unsigned char Data[FSMCountDATA]; ///< Текст +} __attribute__((aligned(4))); +/*! +\brief Подтверждение зашифрованного сообщения в социальную сеть устройства +*/ +#define FSMH_Header_Size_AnsSendEncSocDatatoDev 40 +struct FSM_AnsSendEncSocDatatoDev +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short lenlogin; ///< Длина login + unsigned short sctype; ///<Тип социально сети + + unsigned char login[32]; ///< login + +} __attribute__((aligned(4))); +/*! +\brief Тревога +*/ +#define FSMH_Header_Size_AlernSignal 8 +struct FSM_AlernSignal +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned int ID; ///< Ид Тревоги + +} __attribute__((aligned(4))); +/*! +\brief Предупреждение +*/ +#define FSMH_Header_Size_WarningSignal 8 +struct FSM_WarningSignal +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned int ID; ///< Ид Предупреждения + +} __attribute__((aligned(4))); +/*! +\brief Сбой +*/ +#define FSMH_Header_Size_TroubleSignal 8 +struct FSM_TroubleSignal +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned int ID; ///< Ид Предупреждения + +} __attribute__((aligned(4))); +/*! +\brief Звуковой сигнал +*/ +#define FSMH_Header_Size_BeepSignal 8 +struct FSM_BeepSignal +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CR + unsigned short IDDevice; ///< Ид устройства + + unsigned short ID; ///< Ид Звукового сигнала +} __attribute__((aligned(4))); + +struct FSM_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + +} __attribute__((aligned(4))); + +/*! +\brief Связь с пользовательским процессом +*/ + +#define FSMH_Header_Size_SendCmdUserspace 8 + +struct FSM_SendCmdUserspace +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short cmd; ///< Команда + unsigned short countparam; ///< Количество параметров + + unsigned char Data[FSMCountDATA]; ///< Параметры +} __attribute__((aligned(4))); + +struct FSM_SendCmdUserspace_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned short cmd; ///< Команда + unsigned short countparam; ///< Количество параметров +} __attribute__((aligned(4))); + +/*! +\brief Событие +*/ + +#define FSMH_Header_Size_EventSignal 8 + +struct FSM_EventSignal +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned int ID; ///< Ид Предупреждения +} __attribute__((aligned(4))); + +/*! +\brief Получение дерева настроек +*/ + +#define FSMH_Header_Size_GetTreeList 4 + +struct FSM_GetTreeList_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства +} __attribute__((aligned(4))); + +struct FSM_GetTreeList +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства +} __attribute__((aligned(4))); + +#define FSMH_Header_Size_Ans_GetTreeList 8 + +struct FSM_AnsGetTreeList_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned int size; +} __attribute__((aligned(4))); + +struct FSM_AnsGetTreeList +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned int size; + + unsigned char Data[FSMCountDATA]; +} __attribute__((aligned(4))); + +/*! +\brief Получения настройки +*/ + +#define FSMH_Header_Size_GetSetting 4 + +struct FSM_GetSetting_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned char name[20]; + +} __attribute__((aligned(4))); + +struct FSM_GetSetting +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned char name[20]; +} __attribute__((aligned(4))); + +#define FSMH_Header_Size_Ans_GetSetting 4 + +struct FSM_AnsGetSetting_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned int size; + + unsigned char name[20]; +} __attribute__((aligned(4))); + +struct FSM_AnsGetSetting +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned int size; + + unsigned char name[20]; + unsigned char Data[FSMCountDATA]; +} __attribute__((aligned(4))); + +/*! +\brief Запись настройки +*/ + +#define FSMH_Header_Size_SetSetting 4 + +struct FSM_SetSetting_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned char name[20]; +} __attribute__((aligned(4))); + +struct FSM_SetSetting +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + unsigned char name[20]; + + unsigned char Data[FSMCountDATA]; +} __attribute__((aligned(4))); + +#define FSMH_Header_Size_Ans_SetSetting 4 + +struct FSM_AnsSetSetting_Header +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + int status; +} __attribute__((aligned(4))); + +struct FSM_AnsSetSetting +{ + unsigned char opcode; ///< Код операции + unsigned char CRC; ///< CRC + unsigned short IDDevice; ///< Ид устройства + + int status; +} __attribute__((aligned(4))); + +enum FSMIOCTL_Cmd { + FSMIOCTL_SendData, +}; + +enum FSM_eventlist { + FSM_ServerStarted = 0x00, + FSM_EthernetStarted = 0x01, + FSM_ServerConfigChanged = 0x02, + FSM_ServerStatisticChanged = 0x03 + /**CCK Event List 0x04 - 0x3F **/ + /**Statistick Event List 0x40 - 0x6F **/ + +}; +#endif // FCMPROTOCOL diff --git a/include/FSM/FSMDevice/fsm_electrodevice.h b/include/FSM/FSMDevice/fsm_electrodevice.h new file mode 100644 index 00000000000000..be7eedcc5d0622 --- /dev/null +++ b/include/FSM/FSMDevice/fsm_electrodevice.h @@ -0,0 +1,21 @@ +#ifndef FSM_ELECTRODEVICE +#define FSM_ELECTRODEVICE +/*! +\brief Вид устроства +*/ +enum FSMELS_VidDevice { + C220V_12VEl = 1 ///< 220в электрощиток +}; +/*! +\brief ПодВид устроства +*/ +enum FSMELS_PodVidDevice { + C220V_12VEl_rev1 = 1 ///< 220в электрощиток +}; +/*! +\brief Род устроства +*/ +enum FSMELS_RodDevice { + C220V_12VEl_rev1v1 = 1, ///< 220в электрощиток +}; +#endif // FSM_ELECTRODEVICE \ No newline at end of file diff --git a/include/FSM/FSMDevice/fsm_statusstruct.h b/include/FSM/FSMDevice/fsm_statusstruct.h new file mode 100644 index 00000000000000..12e77ab0bc7c22 --- /dev/null +++ b/include/FSM/FSMDevice/fsm_statusstruct.h @@ -0,0 +1,322 @@ +#ifndef FSM_STATUSSTRUCT +#define FSM_STATUSSTRUCT +#define srow_cnt 8 +#define scolumn_cnt 12 +#define status_cnt srow_cnt* scolumn_cnt +struct fsm_status_element +{ + int row; + int column; + char state[32]; + char fsmdevcode[32]; + short devid; +}; +struct fsm_device_config +{ + int row; + int column; + unsigned short IDDevice; + unsigned short Len; + char config[1000]; +}; +struct FSMSSetconfig +{ + unsigned char cmd; + unsigned short IDDevice; + struct fsm_device_config config; +}; +enum FSMSSetconfigCmd { SetFSMSetting = 1, GetFSMSetting = 2 }; +struct FSMSSetconfigParam +{ + unsigned char cmd; + unsigned short IDDevice; + struct fsm_device_config* config; +}; + +struct fsm_devices_config +{ + struct fsm_device_config setel[srow_cnt][scolumn_cnt]; +}; +struct fsm_statusstruct +{ + struct fsm_status_element statel[srow_cnt][scolumn_cnt]; +}; +struct fsm_ClientSetting_Setting +{ + unsigned short id; + unsigned short size_row; + unsigned short size_column; +}; +struct fsm_ServerSetting_Setting +{ + unsigned short size_row; + unsigned short size_column; +}; +struct fsm_Setting_Setting +{ + struct fsm_ClientSetting_Setting fsmcs; + struct fsm_ServerSetting_Setting fsmss; +}; + +enum FSMST_VidDevice { + FSMDeviceConfig = 1, ///< Модуль Конфигурации + FSMDeviceStatistic = 2, ///< Модуль Конфигурации +}; +/*! +\brief ПодВид устроства +*/ +enum FSMST_PodVidDevice { + ComputerStatistic = 1, ///< ComputerStatistic + FSM_SettingTree_D = 2, + FSM_Flash=3 +}; +/*! +\brief Род устроства +*/ +enum FSMST_RodDevice { + PCx86 = 1, ///< PCx86 + CTL_FSM_SettingTree_D = 2, + CTL_FSM_Flash = 3 +}; +enum FSMST_Cmd /*0*****125*/ +{ GetStatistic = 1, + AnsGetStatistic = 2 }; +enum FSMS_Cmd /*0*****125*/ +{ GetSet = 1, + AnsGetSet = 2, + SetSetting = 3, + AnsSetSetting = 4, + SetSettingClient = 5, + AnsSetSettingClient = 6, + SendSettingFull = 7 }; + +enum FSMCDPC_VidDevice { + Computer = 1, ///< Модуль Конфигурации + Device = 2, +}; +/*! +\brief ПодВид устроства +*/ +enum FSMCDPC_PodVidDevice { + PC = 1, ///< ComputerStatistic + GPIO = 2 +}; +/*! +\brief Род устроства +*/ +enum FSMCDPC_RodDevice { + ARM = 1, ///< PCx86 + Bit_8 = 2 +}; + +enum FSMIOCTLStat_Cmd { FSMIOCTLStat_Read, FSMIOCTLStat_Requst }; +enum FSM_eventlist_status { + + /**Statistick Event List 0x40 - 0x6F **/ + FSM_ControlDeviceRun = 0x40, + FSM_StaticServerRun = 0x41, + FSM_SettingServerRun = 0x42, + +}; +enum FSM_Property_time { + FSMP_INT, + FSMP_STRING, +}; + +typedef struct FSM_PropertyDevice FSM_PropertyDevice_t; + +typedef void (*UpdateDataProperty)(FSM_PropertyDevice_t*); + +struct FSM_PropertyDevice +{ + char fsmdevcode[32]; + unsigned short devid; + char PropertyCode[32]; + void* Property; + unsigned short pr_size; + UpdateDataProperty udp; +}; +// struct FSM_PropertyDevice pdl[FSM_PropertyTreeSize]; + +enum FSM_GPIO_Bit_Enum { + FSM_GPIO_Bit_0 = 1, + FSM_GPIO_Bit_1 = 2, + FSM_GPIO_Bit_2 = 4, + FSM_GPIO_Bit_3 = 8, + FSM_GPIO_Bit_4 = 16, + FSM_GPIO_Bit_5 = 32, + FSM_GPIO_Bit_6 = 64, + FSM_GPIO_Bit_7 = 128, +}; + +enum FSM_GPIO_Bit_Cmd { + FSM_ON_Bit, + FSM_Eror_ON_Bit, + FSM_OFF_Bit, + FSM_Eror_OFF_Bit, + FSM_Reset_Bit, + FSM_Event_Bit, +}; + +void FSM_GPIO_SetBit(enum FSM_GPIO_Bit_Enum Pin); + +void FSM_GPIO_ReSetBit(enum FSM_GPIO_Bit_Enum Pin); + +void FSM_GPIO_Set_Input(enum FSM_GPIO_Bit_Enum Pin); + +void FSM_GPIO_Set_Output(enum FSM_GPIO_Bit_Enum Pin); + +unsigned char FSM_GPIO_Get_Status(enum FSM_GPIO_Bit_Enum Pin); + +void FSM_GPIO_Reset_timer_callback(unsigned long data); + +void FSM_GPIO_Impulse_timer_callback(unsigned long data); + +void FSM_GPIO_Reset(void); + +void FSM_GPIO_EventEror(void); + +void FSM_GPIO_Ctl_Reset(void); +void FSM_GPIO_Ctl_Eror(void); +void FSM_GPIO_Ctl_SetBit(enum FSM_GPIO_Bit_Enum Pin); +void FSM_GPIO_Ctl_ReSetBit(enum FSM_GPIO_Bit_Enum Pin); +void FSM_GPIO_Ctl_Error_ON(void); +void FSM_GPIO_Ctl_Error_OFF(void); + +enum FSM_Set_type { + FSM_T_CHAR = 0, + FSM_T_INT = 1, + FSM_T_STRING = 3, +}; +struct FSM_SetTreeElement +{ + char* id; + void* object; + char type; + char len; +}; + +struct FSM_SetTreeElementFS +{ + short type; + unsigned char iid; + unsigned char len; + char id[20]; +}; + +struct FSM_SetTreeGetList +{ + unsigned short IDDevice; + unsigned short iid; +}; + +struct FSM_SetTreeGetListCount +{ + unsigned char IDDevice; + unsigned char count; +}; + +struct SettingTreeInfo +{ + unsigned char reg; + unsigned char type; + unsigned short id; + struct FSM_SetTreeElementFS fsmdtl[FSM_SettingTreeSize]; + char fsm_tr_temp[254]; + char fsm_tr_size; + struct FSM_DeviceTree* dt; +}; +struct FSM_SetTreeWriteElement +{ + unsigned short id; + unsigned short len; + unsigned char name[20]; + unsigned char Data[100]; + +}; + +struct FSM_SetTreeReadElement +{ + unsigned short id; + unsigned char name[20]; + +}; + +void FSM_TreeRecive(char* data, short len, struct FSM_DeviceTree* to_dt); +void FSM_SetTreeAdd(struct FSM_DeviceTree* to_dt); +void FSM_SendReuestDevTree(struct FSM_DeviceTree* to_dt); + +void FSM_Get_Setting_List_Count(unsigned short IDDevice,struct FSM_SetTreeGetListCount* SetMass); +void FSM_Get_Setting_List_Item(struct FSM_SetTreeGetList* ReadMass,struct FSM_SetTreeElementFS* SetItem); +void FSM_Set_Item(struct FSM_SetTreeWriteElement* in); +int FSM_Get_Item_Read(unsigned short IDDevice,char* Data); +void FSM_Get_Item_Rq(struct FSM_SetTreeReadElement* in); + +enum FSM_DevTreeSetControl_Cmd { + FSM_DevTreeSetGet, + FSM_DevTreeSetGetCount, + FSM_DevTreeSetWrite, + FSM_DevTreeSetReadReqest, + FSM_DevTreeSetReadRead +}; + +struct FSMFlahData_StartVector +{ + unsigned int size; + unsigned int count; + unsigned int crc32; +}; +struct FSMFlahData_DataVector +{ + unsigned int num; + unsigned int crc32; + char Data[1024]; +}; +struct FSMFlahData_DataVerifeVector +{ + unsigned int num; + unsigned int crc32; +}; +struct FSMFlahData_EndVector +{ + unsigned int size; + unsigned int crc32; +}; + +struct FSMFirmware +{ + struct FSMFlahData_StartVector svec; + struct FSMFlahData_DataVector dvec[128]; + struct FSMFlahData_EndVector evec; +}; + +enum FSM_Flash_Status +{ + FSM_Flash_S_Start, + FSM_Flash_S_Data, + FSM_Flash_S_End +}; + +enum FSM_Flash_CTL +{ + FSM_Flash_CTL_Flash, + FSM_Flash_CTL_GetStatus, +}; + +struct FSMFlash_Control +{ +char reg; +char state; +struct FSMFirmware firm; +char size; +char count; +struct FSM_DeviceTree* dt; + +}; +unsigned int FSM_crc32NT(unsigned int crc, unsigned char *buf,unsigned int len); + +void FSM_FlashStart(struct FSM_DeviceTree* to_dt); +void FSM_FlashRecive(char* data, short len, struct FSM_DeviceTree* to_dt); + +void FSM_CTL_flash_Start(unsigned short IDDevice); +#endif // FSM_STATUSSTRUCT \ No newline at end of file diff --git a/include/FSM/FSMEthernet/FSMEthernetHeader.h b/include/FSM/FSMEthernet/FSMEthernetHeader.h new file mode 100644 index 00000000000000..596b2709955bd2 --- /dev/null +++ b/include/FSM/FSMEthernet/FSMEthernetHeader.h @@ -0,0 +1,39 @@ +#ifndef FSMEthernetHeader +#define FSMEthernetHeader + +#define FSM_PROTO_ID 0x1996 +#define FSM_PROTO_ID_R 0x9619 + +enum FSMNetwork_VidDevice +{ + Ethernet=1 ///< Ethernet +}; +/*! +\brief ПодВид устроства +*/ +enum FSMNetwork_PodVidDevice +{ + WireEthernet=1 ///< WireEthernet +}; +/*! +\brief Род устроства +*/ +enum FSMNetwork_RodDevice +{ + StandartEthernet=1///< StandartEthernet +}; + +struct fsm_ethernet_dev +{ + char reg; + unsigned short id; + unsigned short numdev; + char destmac[6]; + struct net_device *dev; +}; +unsigned int FSM_Send_Ethernet_Package(void * data, int len, struct fsm_ethernet_dev *fsmdev); +unsigned int FSM_Send_Ethernet_Package2(void * data, int len, int id); +void FSM_RegisterAudioStreamCallback(FSM_StreamProcessSend FSM_ASC); +FSM_ADSendEthPack FSM_GetAudioStreamCallback(void); +struct fsm_ethernet_dev* FSM_FindEthernetDevice(unsigned short id); +#endif \ No newline at end of file diff --git a/include/FSM/FSMSetting/FSM_settings.h b/include/FSM/FSMSetting/FSM_settings.h new file mode 100755 index 00000000000000..be6797166905de --- /dev/null +++ b/include/FSM/FSMSetting/FSM_settings.h @@ -0,0 +1,90 @@ +/*! +\file +\brief Файл настрооек +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ +#ifndef FSM_SETTINGS_H +#define FSM_SETTINGS_H +/*! +\brief Размер дерва функций +*/ +#define FSM_DeviceFunctionTreeSize 100 +/*! +\brief Размер дерева устройств +*/ +#define FSM_DeviceTreeSize 100 +/*! +\brief Размер дерва Ethernet устройств +*/ +#define FSM_EthernetDeviceTreeSize 100 +/*! +\brief ID Ethernet передатчика +*/ +#define FSM_EthernetID2 1 +#define FSM_FifoID 0 +#define FSM_GPIOID 2 +#define FSM_CCKControlID 3 +#define FSM_TreeSettingID 4 +#define FSM_FlashID 5 +/*! +\brief ID сервера статистики +*/ +#define FSM_StatisicID 21 +#define FSM_SettingID FSM_SC_setservid +/*! +\brief Размер дерева аудио потоков +*/ +#define FSM_AudioStreamDeviceTreeSize 100 + +#define FSM_FIFOAudioStreamDeviceTreeSize 100 +/*! +\brief Размер дерева E1 устройств потоков +*/ +#define FSM_E1DeviceTreeSize 12 + +#define FSM_PO06DeviceTreeSize 12 +#define FSM_MN825DeviceTreeSize 12 +#define FSM_MN921DeviceTreeSize 12 +#define FSM_MN111DeviceTreeSize 12 +#define FSM_PO07DeviceTreeSize 12 +#define FSM_PO08DeviceTreeSize 12 +#define FSM_SADeviceTreeSize 12 + +#define FSM_CryptoAlgoritmNum 6 + +#define FSM_InterfaceID "esp4" + +#define FSM_Conferenc_num 10 + +#define FSM_Circular_num 10 + +#define FSM_P2P_abonent_count 2 + +#define FSM_Conferenc_abonent_count 2 + +#define FSM_Circulac_abonent_count 2 + +#define FSM_SkyNetDeviceTreeSize 12 + +#define FSM_ClientTreeSize 12 + +#define FSM_E1CasTreeSize 12 + +#define FSM_EventTreeSize 12 + +#define FSM_IOCTLTreeSize 12 +#define FSM_PropertyTreeSize 12 +#define FSM_CCKTreeSize 20 + +#define FSM_SettingTreeSize 100 +#define FSM_DeviceSettingTreeSize 100 +#define FSM_FlasherSize 2 + +#define FSM_EventIOCtlId 1 +#define FSM_StatistickIOCtlId 2 + +#define FSM_GPIO_BLOCK +#endif /* FSM_SETTINGS_H */ +//#define DEBUG_CALL_STACK \ No newline at end of file diff --git a/include/FSM/FSM_Client/FSM_client.h b/include/FSM/FSM_Client/FSM_client.h new file mode 100644 index 00000000000000..6bd99fd02a754c --- /dev/null +++ b/include/FSM/FSM_Client/FSM_client.h @@ -0,0 +1,79 @@ +#ifndef FSM_Client_H +#define FSM_Client_H + +typedef struct fsm_client_struct fsm_client_struct_t; +typedef struct fsm_event_struct fsm_event_struct_t; +typedef struct fsm_ioctl_struct fsm_ioctl_struct_t; + +typedef void (*DeviceClientProcess)(char*, short, fsm_client_struct_t*); +typedef void (*EventClientProcess)(char*, short, fsm_event_struct_t*); +typedef void (*IOClientProcess)(char*, short, fsm_ioctl_struct_t*); + +struct fsm_client_struct +{ + char reg; + unsigned short id; + unsigned char type; + unsigned char VidDevice; + unsigned char PodVidDevice; + unsigned char KodDevice; + DeviceClientProcess Handler; +}; +struct fsm_event_struct +{ + char reg; + unsigned int id; + + EventClientProcess Handler; +}; + +struct fsm_ioctl_struct +{ + char reg; + unsigned int id; + + IOClientProcess Handler; +}; +struct fsm_server_connection +{ + unsigned short id; + unsigned char type; + unsigned char VidDevice; + unsigned char PodVidDevice; + unsigned char KodDevice; + char destmac[6]; + char coonect; + struct net_device* dev; +}; +unsigned int FSM_Send_Ethernet(void* data, int len, struct fsm_server_connection* fsmdev); +int FSM_RegisterServer(unsigned short id, + unsigned char type, + unsigned char VidDevice, + unsigned char PodVidDevice, + unsigned char KodDevice); +int FSM_RegisterDevice(unsigned short id, + unsigned char type, + unsigned char VidDevice, + unsigned char PodVidDevice, + unsigned char KodDevice, + DeviceClientProcess Handler); +struct fsm_client_struct* FSM_FindHandlerDevice(unsigned short id); +int FSM_DeleteDevice(unsigned short id); +void FSM_DeregisterServer(void); +unsigned int FSM_Send_Ethernet_TS(void* data, int len); +int FSM_SendSignalToPipe(char* pipe, int signal); +void FSM_DeleteEvent(unsigned int id); +struct fsm_event_struct* FSM_FindEvent(unsigned int id); +struct fsm_event_struct* FSM_RegisterEvent(unsigned int id, EventClientProcess Handler); +struct fsm_ioctl_struct* FSM_RegisterIOCtl(unsigned int id, IOClientProcess Handler); +struct fsm_ioctl_struct* FSM_FindIOCtl(unsigned int id); +void FSM_DeleteIOCtl(unsigned int id); + +struct SendSignalStruct +{ + char pipe[20]; + int id; +}; + +enum FSM_SSTP { FSM_SSTP_SetPid = 0x00, FSM_SSTP_GetEvent = 0x01 }; +#endif \ No newline at end of file diff --git a/include/FSM/FSM_Commutator/FSM_Commutator.h b/include/FSM/FSM_Commutator/FSM_Commutator.h new file mode 100644 index 00000000000000..a19ac25b99edcf --- /dev/null +++ b/include/FSM/FSM_Commutator/FSM_Commutator.h @@ -0,0 +1,29 @@ +#ifndef FSM_Commutator +#define FSM_Commutator + +struct FSM_P2P_abonent +{ + unsigned char reg; + unsigned short idstream1; + unsigned short idstream2; + unsigned short idcon; +}; +struct FSM_Conferenc_abonent +{ + unsigned char reg; + unsigned short idstream[FSM_Conferenc_num]; + unsigned short idcon; +}; +struct FSM_Circular_abonent +{ + unsigned char reg; + unsigned short idorg; + unsigned short idstream[FSM_Circular_num]; + unsigned short idcon; +}; +enum FSMComType { p2p, Conferenc, Circular }; +unsigned short FSM_P2P_Connect(unsigned short id1, unsigned short id2); +void FSM_P2P_Disconnect(unsigned short idcon); +void FSM_Commutator_Process(char* data, short len); + +#endif \ No newline at end of file diff --git a/include/FSM/FSM_SA/FSM_SA.h b/include/FSM/FSM_SA/FSM_SA.h new file mode 100644 index 00000000000000..d82ae709fb4eb5 --- /dev/null +++ b/include/FSM/FSM_SA/FSM_SA.h @@ -0,0 +1,37 @@ +#ifndef FSM_SA_H +#define FSM_SA_H + +enum FSMSA_VidDevice { + FSMSA_Analiz = 1, ///< Модуль Конфигурации +}; +/*! +\brief ПодВид устроства +*/ +enum FSMSA_PodVidDevice { + FSMSA_AnalizData = 1 ///< ComputerStatistic +}; +/*! +\brief Род устроства +*/ +enum FSMSA_RodDevice { + FSMSA_AnalizDataServer = 1, ///< PCx86 +}; + +struct fsm_sa_setting +{ + int dt; +}; +struct FSM_SADevice +{ + char reg; + unsigned short iddev; + int idstream; + int idcon; + struct fsm_ethernet_dev* ethdev; + struct fsm_sa_setting saset; +}; +enum FSMSACommand /*0*****125*/ +{ FSMSA_IDK = 1, + FSMSA_ODK = 2, +}; +#endif \ No newline at end of file diff --git a/include/FSM/FSM_Switch/fsm_switch.h b/include/FSM/FSM_Switch/fsm_switch.h new file mode 100644 index 00000000000000..ec61480dbc0e40 --- /dev/null +++ b/include/FSM/FSM_Switch/fsm_switch.h @@ -0,0 +1,44 @@ +/*! +\file +\brief Набор данных FSM Аудиоустроство +\authors Гусенков.С.В +\version 0.0.1_rc1 +\date 30.12.2015 +*/ +#ifndef FCM_SWITCHDEVICECLASS_H +#define FCM_SWITCHDEVICECLASS_H +/*! +\brief Вид устроства +*/ +enum FSMSW_VidDevice { + SkyNet = 1 ///< Устроства связи +}; +/*! +\brief ПодВид устроства +*/ +enum FSMSW_PodVidDevice { + K1986BE1T = 1 ///< СЦК +}; +/*! +\brief Род устроства +*/ +enum FSMSW_RodDevice { + BLE_nRFC_RS485_Ethernet = 1, ///< BLE_nRFC_RS485_Ethernet +}; + +enum FSMSWCommand { + SetSettingSwitch = 1, + AnsSetSettingSwitch = 2, + GetSettingSwitch = 3, + AnsGetSettingSwitch = 4, +}; + +struct FSM_SkyNetDevice +{ + char reg; + unsigned short iddev; + struct fsm_ethernet_dev* ethdev; + // struct fsm_po06_setting po06set; +}; + +#endif /* FCM_SWITCHDEVICECLASS_H */