API tools faq
paste
Advertisement
2andnot

main.cpp

2andnot
Dec 14th, 2018
149
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 23.90 KB | None | 0 0
raw download clone embed print report
  1. ///////////////////////////////////////////////////////////////////
  2. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
  3. // Проэкт.  версия 3.0         Редакцыя Турок А.
  4. // В данной версии МСК МРТП4 и ИМВВ переведены в одно адресное
  5. // пространство. Проверка МСК осуществляется функцыей msk()
  6. // Мнемосхема переведена в систему координат Х У
  7. //
  8. // Версия 2.0 - в системе введено понятие событие
  9. // Версия 1.0 - в система изначальная, доставшаяся мне
  10. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
  11. ///////////////////////////////////////////////////////////////////
  12. #include "Main.h"
  13.  
  14. #define F_CPU 11059200UL
  15. //тик системы 1.48(148) ms
  16.  
  17. //DefineProcess(TAnMeas, 50);
  18. typedef OS::process<OS::pr0, 150> TUART0;
  19. typedef OS::process<OS::pr1, 150> TUART1;
  20. typedef OS::process<OS::pr2, 150> TPeripheral;
  21. typedef OS::process<OS::pr3, 150> TTechnolog;
  22.  
  23.  
  24. //TAnMeas AnMeas(pr0);
  25. TUART0 UART0;
  26. TUART1 UART1;
  27. TPeripheral Peripheral;
  28. TTechnolog Technolog;
  29.  
  30.  
  31. #if !UART0_MASTER
  32. OS::TEventFlag efUART0;
  33. #endif
  34.  
  35. //#if !UART1_MASTER
  36. OS::TEventFlag efUART1;
  37. //#endif
  38.  
  39.  
  40. uint8_t tech_fl;
  41.  
  42. // Основной массив хранения 2-х строк экрана ЖКИ пульта
  43. char LCD_str[]=  "                                ";
  44. //-----------------------------------------------------------------------------
  45. extern uint8_t message_arch_byte[];
  46. extern uint8_t message_arch_byte_cpy[];
  47.  
  48. void my_init_portb (void) __attribute__ ((naked)) \
  49.     __attribute__ ((section (".init1")));
  50.  
  51. void
  52. my_init_portb (void)
  53. {
  54.     PORTE = 1<<PE4;
  55.     DDRE = 1<<PE4;
  56.     PORTD|=((1<<PD4)|(1<<PD5)|(1<<PD6)|(1<<PD7));
  57.     DDRD|=(1<<PD7)|(1<<PD6)|(1<<PD5)|(1<<PD4);
  58. }
  59.  
  60. #include "Etaz.h"
  61. NET_BFPP_OUTPUT_STRUCT data_for_bfpp[NUM_OF_BFPP];
  62. NET_BFPP_INPUT_STRUCT data_from_bfpp[NUM_OF_BFPP];
  63. //щуа
  64. NET_OUTPUT_STRUCT data_for_slave;
  65. NET_INPUT_STRUCT data_from_slave;
  66. //щпз-т
  67. NET_IMVV_OUTPUT_STRUCT data_for_imvv, FORBFPP1_1;
  68. NET_IMVV_INPUT_STRUCT data_from_imvv, FROMBFPP1_1;
  69.  
  70. //NET_BRIDJ_OUTPUT_STRUCT data_for_BRIDJ[NUM_OF_BRIDJ];
  71. //NET_BRIDJ_INPUT_STRUCT data_from_BRIDJ[NUM_OF_BRIDJ];
  72.  
  73. LCD_OUTPUT_STRUCT lcd_data;
  74. LCD_INPUT_STRUCT key_data;
  75.  
  76. void timer_init(void )
  77. {
  78. // Timer/Counter 1 initialization
  79. // Clock source: System Clock
  80. // Clock value: 7,200 kHz
  81. // Mode: CTC top=OCR1A
  82. // OC1A output: Discon.
  83. // OC1B output: Discon.
  84. // Noise Canceler: Off
  85. // Input Capture on Falling Edge
  86. // Timer1 Overflow Interrupt: Off
  87. // Input Capture Interrupt: Off
  88. // Compare A Match Interrupt: On
  89. // Compare B Match Interrupt: Off
  90. TCCR1A=0x00;
  91. TCCR1B=0x0D;
  92. TCNT1H=0x00;
  93. TCNT1L=0x00;
  94. ICR1H=0x00;
  95. ICR1L=0x00;
  96. OCR1AH=0x05;
  97. OCR1AL=0xA0;
  98. OCR1BH=0x00;
  99. OCR1BL=0x00;
  100. // Timer/Counter 1 Interrupt(s) initialization
  101. #if atmega128
  102. TIMSK|=(1<<OCIE1A);
  103. #endif
  104. #if atmega1281
  105. TIMSK1|=(1<<OCIE1A);
  106. #endif
  107. // Timer/Counter 2 initialization
  108. // Clock source: System Clock
  109. // Clock value: 7,200 kHz
  110. // Mode: Normal top=FFh
  111. // OC2 output: Disconnected
  112. //ASSR=0x00;
  113. //TCCR2A=0x00;
  114. //TCCR2B=0x07;
  115. //TCNT2=0x00;
  116. //OCR2A=0x00;
  117. //OCR2B=0x00;
  118. // Timer/Counter 2 Interrupt(s) initialization
  119. //TIMSK=0x01;
  120. }
  121. uint8_t mnemoXY[NUM_OF_LED_X][NUM_OF_LED_Y];
  122.  
  123.  
  124.  
  125.  
  126. int main()
  127. {
  128.     PORTE = 1<<PE4;
  129.     DDRE = 1<<PE4;
  130.     PORTD|=((1<<PD4)|(1<<PD5)|(1<<PD6)|(1<<PD7));
  131.     DDRD|=(1<<PD7)|(1<<PD6)|(1<<PD5)|(1<<PD4);
  132.     uint8_t i,j;
  133. #if atmega128
  134.     message_arch_byte[1]=MCUCSR;
  135.     MCUCSR&=0x1f;
  136. #endif
  137. #if atmega1281
  138.     message_arch_byte[1]=MCUSR;
  139.     MCUSR&=0x1f;
  140. #endif
  141.     message_arch_byte_cpy[1]=0xff;
  142.  
  143.  
  144.     message_arch_byte[0]=1;
  145.     message_arch_byte_cpy[0]=0xff;
  146.  
  147.     PORTA = 0xFF;
  148.     DDRA = 0xFF;
  149.     DDRB = 0x00;
  150.     DDRC = 0x00;
  151. //    DDRD = 0x00;
  152.     DDRF = 0x00;
  153.  
  154.     PORTB = 0x00;
  155.     PORTC = 0x00;
  156. //  PORTD = 0x00;
  157.  
  158.     PORTF = 0x00;
  159.  
  160.  
  161. //  DDRA=0xff;
  162.  
  163. //  PORTD=0xff;
  164.  
  165.  
  166.     DDRC=(1<<PC0)/*|(1<<PC1)*/|(1<<PC2)|(1<<PC3);
  167.     PORTC|=(1<<PC3);
  168.  
  169.     RAMPZ=0;
  170.  
  171.  
  172.     KEY[0]=0x00;
  173.     KEY[1]=0x00;
  174.  
  175.    
  176. //  SET_IO (data_from_io[NUM_OF_IO-1],(0x40),'d',sizeof(NET_IO_INPUT_STRUCT))
  177. //  SET_IO (data_for_io[NUM_OF_IO-1],(0x40),'d',sizeof(NET_IO_OUTPUT_STRUCT))
  178.  
  179.     for(i=0;i<(NUM_OF_BFPP);i++){SET_BFPP (data_for_bfpp[i],(0xB0+i),'d',sizeof(NET_BFPP_OUTPUT_STRUCT))}
  180.  
  181.     for(i=0;i<(NUM_OF_BFPP);i++){SET_BFPP (data_from_bfpp[i],(0xB0+i),'d',sizeof(NET_BFPP_INPUT_STRUCT))}
  182.  
  183.     lcd_data.head.size=sizeof(LCD_OUTPUT_STRUCT);
  184.     lcd_data.head.adr=0x20;
  185.     lcd_data.head.cmd='S';
  186.  
  187.     key_data.head.size=sizeof(LCD_INPUT_STRUCT);
  188.     key_data.head.adr=0x20;
  189.     key_data.head.cmd='d';
  190.  
  191.  
  192.     data_for_slave.head.size=sizeof(NET_OUTPUT_STRUCT);
  193.     data_for_slave.head.adr=0x50;
  194.     data_for_slave.head.cmd='d';
  195.  
  196.     data_from_slave.head.size=sizeof(NET_INPUT_STRUCT);
  197.     data_from_slave.head.adr=0x50;
  198.     data_from_slave.head.cmd='d';
  199.  
  200.     SET_IMVV (data_from_imvv,(0x90),'d',sizeof(NET_IMVV_INPUT_STRUCT))
  201.     SET_IMVV (data_for_imvv,(0x90),'d',sizeof(NET_IMVV_OUTPUT_STRUCT))
  202.  
  203.     SET_IMVV (FROMBFPP1_1,(0x91),'d',sizeof(NET_IMVV_INPUT_STRUCT))
  204.     SET_IMVV (FORBFPP1_1,(0x91),'d',sizeof(NET_IMVV_OUTPUT_STRUCT))
  205.     for(i=0;i<NUM_OF_BRIDJ;i++)
  206.     {
  207.     //  SET_BRIDJ (data_from_BRIDJ[i],(0x50+i),'d',sizeof(NET_BRIDJ_INPUT_STRUCT))
  208.     //  SET_BRIDJ (data_for_BRIDJ[i],(i+0x50),'d',sizeof(NET_BRIDJ_OUTPUT_STRUCT))
  209.     }
  210.    
  211.  
  212.    
  213.     for(i=0;i<NUM_OF_LED_X;i++)
  214.         for(j=0;j<NUM_OF_LED_Y;j++)
  215.             mnemoXY[i][j] = 0xff;
  216.  
  217.    
  218.     low_init();
  219.     Init_iic();
  220.     uart_status1|=UART_TX_OK;
  221.     uart_status0|=UART_TX_OK;
  222.  
  223.     check_iic_status();
  224.     Work_init();
  225.     Dev_init();
  226.     Etaz_init();
  227.     Menu_init();
  228.     Pdz_init();
  229.     init_knc();
  230.     Message_init();
  231.     timer_init();
  232.  
  233. #if atmega128
  234.     TCCR0 = (1 << CS01) | (1 << CS00);          
  235.     TIMSK |=  (1 << TOIE0);
  236. #endif
  237. #if atmega1281
  238.     TCCR0B = (1 << CS01) | (1 << CS00);          
  239.     TIMSK0 |=  (1 << TOIE0);
  240. #endif
  241.  
  242.     OS::Run();
  243. }
  244.  
  245.  
  246. //-----------------------------------------------------------------------------
  247. //-----------------------------------------------------------------------------
  248. #include <avr/delay.h>
  249. uint8_t NetPackInfo[NUM_OF_BFPP+NUM_OF_SCAFE];
  250. uint8_t cur_bfpp_net_pack;
  251. uint8_t cur_address0;
  252. uint8_t cur_address1;
  253. namespace OS {
  254.  
  255. template<> OS_PROCESS void TUART0::Exec()
  256. {
  257. //  uint8_t cou_imvv=0;
  258. //  uint8_t new_imvv_byte=0;
  259. //  uint8_t i;
  260.    
  261.     UCSR0A=0x00;
  262.     UCSR0B=(1<<RXCIE0)|(1<<RXEN0);
  263.     UCSR0C=(1<<UCSZ01)|(1<<UCSZ00);
  264.     UBRR0H=0;
  265.     UBRR0L=11;
  266.     NetPackInfo[0]=12;
  267.     //NetPackInfo[1]=12;
  268.     //NetPackInfo[2]=12;
  269.     //NetPackInfo[NUM_OF_BFPP+1]=12;
  270.     cur_bfpp_net_pack=0;
  271.     set_uart0_to_receive();
  272.     for(;;)
  273.     {
  274.     if (uart_status0&UART_TX_OK)
  275.     {
  276.         #if !UART0_MASTER
  277.         efUART0.Wait(200);
  278.         #endif
  279.         if(uart_status0&UART_RX_OK)
  280.         {
  281.             uart_status0&=~UART_RX_OK;
  282.             NetPackInfo[cur_bfpp_net_pack]=0;
  283.             switch(cur_bfpp_net_pack)
  284.             {
  285.                 case 0: //приём данных от ИМВВ (щпз-т)
  286.                     memcpy((uint8_t*)&(data_from_imvv.imvv_in[0]),(uint8_t*)&rx_local_buffer0[3],
  287.                     sizeof(NET_IMVV_INPUT_STRUCT)-sizeof(HEAD_NET_STRUCT));
  288.                 break;
  289.                 case 1:
  290.                     break;
  291.                 case 2:
  292.                     break;
  293.                 default:
  294.                     memcpy((uint8_t*)&(data_from_bfpp[cur_bfpp_net_pack-NUM_OF_SCAFE].msk),
  295.                     (uint8_t*)&rx_local_buffer0[3],
  296.                         sizeof(NET_BFPP_INPUT_STRUCT)-sizeof(HEAD_NET_STRUCT));
  297.                 break;
  298.             }
  299.         }
  300.         else{
  301.             if (NetPackInfo[cur_bfpp_net_pack]<12);
  302.                 NetPackInfo[cur_bfpp_net_pack]++;
  303.         }
  304.    
  305.         cur_bfpp_net_pack++;
  306.         if(cur_bfpp_net_pack>=NUM_OF_BFPP+NUM_OF_SCAFE) cur_bfpp_net_pack=0; //>(NUM_OF_BFPP+1))
  307.        
  308.         switch(cur_bfpp_net_pack)
  309.         {
  310.             case 0: //передача данных в ИМВВ
  311.                 memcpy((uint8_t*)&tx_local_buffer0,(uint8_t*)&data_for_imvv,sizeof(NET_IMVV_OUTPUT_STRUCT));
  312.                 cur_address0=data_for_imvv.head.adr;
  313.             break;
  314.             case 1:
  315.                 break;
  316.             case 2:
  317.                 break;
  318.             default:
  319.                 memcpy((uint8_t*)&tx_local_buffer0,
  320.                 (uint8_t*)&data_for_bfpp[cur_bfpp_net_pack-NUM_OF_SCAFE],
  321.                 sizeof(NET_BFPP_OUTPUT_STRUCT));
  322.                 cur_address0=data_for_bfpp[cur_bfpp_net_pack-NUM_OF_SCAFE].head.adr;
  323.             break;
  324.         }
  325.  
  326.  
  327.         uart_status0=0;
  328.         uart_init0();
  329.         set_uart0_to_receive();
  330. #if UART0_MASTER
  331.             UCSR0B=(1<<TXEN0)|(1<<TXCIE0);   //разрешение передатчика
  332.             set_uart0_to_transmitt();
  333.             _delay_us(100);
  334.             UDR0='#';
  335. #else
  336.             UCSR0B=(1<<RXEN0)|(1<<RXCIE0);
  337. #endif
  338.         }
  339.         else Transmitt_buffer_uart0();
  340.         Sleep(50);//7//10.37ms//30
  341.     }
  342. }
  343. }
  344.  
  345. extern void set_uart1_transmitt();
  346. extern uint8_t tx_local_buffer1[MAX_LENGTH_TX_BUFFER1];
  347. extern uint8_t rx_local_buffer1[MAX_LENGTH_TX_BUFFER1];
  348. extern uint8_t mnemo_test_counter;
  349. extern uint8_t LCD_light;
  350. uint8_t mnemo_counter;
  351.  
  352.  
  353. extern uint8_t fire_floor;
  354. extern uint8_t stat_g;
  355. extern uint8_t fire_buz;
  356.  
  357. #define UART1_NUM_PACK (NUM_OF_MNEMO + NUM_OF_IO + NUM_OF_BRIDJ + 1)*2
  358.  
  359. namespace OS {
  360.  
  361. template<> OS_PROCESS void TUART1::Exec()
  362. {
  363.     static uint8_t i,j,k;
  364.     UCSR1A=0x00;
  365.     UCSR1B=(1<<RXCIE1)|(1<<RXEN1);
  366.     UCSR1C=(1<<UCSZ11)|(1<<UCSZ10);
  367.     UBRR1H=0;
  368.     UBRR1L=11;
  369.     set_uart1_to_receive();
  370.  
  371.     for(;;)
  372.     {
  373.     efUART1.Wait(20);//200
  374.     if (uart_status1&UART_TX_OK)
  375.     {
  376.  
  377.         if(uart_status1&UART_RX_OK)
  378.         {
  379.             uart_status1&=~UART_RX_OK;
  380.             if(!(mnemo_counter & 1))//если числа четные считываем клаву,
  381.             {
  382.                 memcpy((uint8_t*)&(key_data.key[0]),(uint8_t*)&rx_local_buffer1[3],
  383.                 sizeof(LCD_INPUT_STRUCT)-sizeof(HEAD_NET_STRUCT));
  384.             }
  385.             switch(mnemo_counter >> 1)
  386.             {
  387.                 case NUM_OF_MNEMO + 0://ВИТ
  388.                 break;
  389.                 case NUM_OF_MNEMO + 1://Бридж 1
  390.                     //memcpy((uint8_t*)&(data_from_BRIDJ[0].BRIDJ_in),(uint8_t*)&rx_local_buffer1[3],
  391.                     //sizeof(NET_BRIDJ_INPUT_STRUCT)-sizeof(HEAD_NET_STRUCT));
  392.                 break;
  393.                 case NUM_OF_MNEMO + 2://Бридж 2
  394.                     //memcpy((uint8_t*)&(data_from_BRIDJ[1].BRIDJ_in),(uint8_t*)&rx_local_buffer1[3],
  395.                     //sizeof(NET_BRIDJ_INPUT_STRUCT)-sizeof(HEAD_NET_STRUCT));
  396.                 break;
  397.                 case NUM_OF_MNEMO + 3://Бридж 3
  398.                     //memcpy((uint8_t*)&(data_from_BRIDJ[2].BRIDJ_in),(uint8_t*)&rx_local_buffer1[3],
  399.                     //sizeof(NET_BRIDJ_INPUT_STRUCT)-sizeof(HEAD_NET_STRUCT));
  400.                 break;
  401.                 case NUM_OF_MNEMO + 4://Бридж 4
  402.                     //memcpy((uint8_t*)&(data_from_BRIDJ[3].BRIDJ_in),(uint8_t*)&rx_local_buffer1[3],
  403.                     //sizeof(NET_BRIDJ_INPUT_STRUCT)-sizeof(HEAD_NET_STRUCT));
  404.                 break;
  405.                 case NUM_OF_MNEMO + 5://Бридж 5
  406.                     //memcpy((uint8_t*)&(data_from_BRIDJ[4].BRIDJ_in),(uint8_t*)&rx_local_buffer1[3],
  407.                     //sizeof(NET_BRIDJ_INPUT_STRUCT)-sizeof(HEAD_NET_STRUCT));
  408.                 break;
  409.                
  410.                
  411.             }
  412.         }
  413.        
  414.         mnemo_counter++;
  415.         if(mnemo_counter>((UART1_NUM_PACK))) mnemo_counter=0;
  416.  
  417.         if(mnemo_counter & 1)//нечетные числа
  418.         {
  419.             if((mnemo_counter >> 1) < NUM_OF_MNEMO)//(mnemo_counter / 2) < кол-во мнемосхем
  420.             {
  421.                 if(mnemo_fl&MNEMO_WRK)
  422.                 {
  423.                     mnemo_test_work();
  424.                     mnemo_fl|=MN_TEST_on;
  425.                 }
  426. /*              else if(mnemo_fl&MN_TEST_on)//окончательное обнуление светодиодов после теста
  427.                 {
  428.                     mnemo_fl&=~MN_TEST_on;
  429.        
  430.    
  431.                     for(i=0;i<NUM_OF_LED_X;i++)
  432.                         for(j=0;j<NUM_OF_LED_Y;j++)
  433.                             mnemoXY[i][j] = 0xff;
  434.                 }
  435. */              else
  436.                 {
  437.  
  438. //////////////////////////////////////////////////////////////////////////////////////
  439. //~~~~~~~~~~здесь происходит таинство отправки светодиодов~~~~~~~~~~~~~~~~~~
  440. //~~~~~со всеми преобразованиями координат Х и У в координаты мнемосхемы~~~~
  441. //~~~~~~~~~~~Передавать не более, чем 4 мнемосхемы~~~~~~~~~~~~~~~~~~~~~~~~~~
  442. //////////////////////////////////////////////////////////////////////////////////////
  443. //~~~~~~~~~автоматически понимает положение мнемосхемы по NUM_OF_LED_X и NUM_OF_LED_Y
  444. //~~~~~~~~~~~~~~~~~~~~~~~~~~только совсем не доделанное~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  445. //////////////////////////////////////////////////////////////////////////////////////
  446.                     uint8_t y,x,m_c;
  447.                     m_c = (mnemo_counter >> 1);
  448.                     y = 0;
  449.                     while(m_c > (NUM_OF_MNEMO_X -1))//вычисляем смещения координат для текущей мнемосхемы
  450.                     {
  451.                         m_c = m_c  - NUM_OF_MNEMO_X;
  452.                         y++;
  453.                     }
  454.  
  455. //if(m_c > NUM_OF_LED_X)
  456.                     if(NUM_OF_LED_MNEMO_X < NUM_OF_LED_MNEMO_Y)
  457.                     {
  458.                         x = m_c * 5; //смещение по мнемосхеме, в штуках светодиодов
  459.                         y = y * 16;//смещение по мнемосхеме, в штуках светодиодов
  460.                         for(uint8_t k=0; k<2; k++) //переход по половинкам мнемосхемы, разделенной, по 40 светодиодов
  461.                             for(i=0;i<5;i++)//по Х мнемосхемы
  462.                                 for(j=0;j<8;j++)// по У мнемосхемы
  463.                                 {
  464.                                     tx_local_buffer1[4+(k*40)+((i*8)+j)] = mnemoXY[x + (4-i)] [k*8 + y + j];
  465.                                    
  466.                                 }
  467.                     }
  468.                     else //работает
  469.                     {
  470.                        
  471.                         for(k=0;k<2;k++)
  472.                             for(i=0;i<5;i++)
  473.                                 for(j=0;j<8;j++)
  474.                                 {
  475.                                     tx_local_buffer1[4+((k*40)+i*8+j)] = mnemoXY [((mnemo_counter>>2) & 1)*16 + j + k*8][((mnemo_counter>>1) & 1)*5 + i];
  476.                                 }
  477.                     }
  478.                 }
  479.                 cur_address1 = (mnemo_counter >>1) + 0x30;
  480.                 tx_local_buffer1[0] = 84;//размер пакета мнемосхемы
  481.                 tx_local_buffer1[1]=cur_address1;
  482.                 tx_local_buffer1[2]='d';
  483.                 tx_local_buffer1[3]=0;
  484.             }
  485.             else
  486.                 switch(mnemo_counter >> 1)
  487.                 {
  488.                     case NUM_OF_MNEMO:
  489.                             tx_local_buffer1[0]=6;
  490.                             tx_local_buffer1[1]=0x7F; //адреса
  491.                             tx_local_buffer1[2]='d';  //команда
  492.                             tx_local_buffer1[3]=fire_floor;//fire_g;
  493.                             tx_local_buffer1[4]=stat_g;//статус
  494.                             tx_local_buffer1[5]=fire_buz;//f2;
  495.                             cur_address1=0x7F;
  496.                     break;
  497.                     case NUM_OF_MNEMO + 1:  //бридж 1
  498.                         //memcpy((uint8_t*)&tx_local_buffer1,(uint8_t*)&data_for_BRIDJ[0],sizeof(NET_BRIDJ_OUTPUT_STRUCT));
  499.                         //cur_address1=data_for_BRIDJ[0].head.adr;
  500.                     break;
  501.                     case NUM_OF_MNEMO + 2:  //бридж 2
  502.                         //memcpy((uint8_t*)&tx_local_buffer1,(uint8_t*)&data_for_BRIDJ[1],sizeof(NET_BRIDJ_OUTPUT_STRUCT));
  503.                         //cur_address1=data_for_BRIDJ[1].head.adr;
  504.                     break;
  505.                     case NUM_OF_MNEMO + 3:  //бридж 3
  506.                         //memcpy((uint8_t*)&tx_local_buffer1,(uint8_t*)&data_for_BRIDJ[2],sizeof(NET_BRIDJ_OUTPUT_STRUCT));
  507.                         //cur_address1=data_for_BRIDJ[2].head.adr;
  508.                     break;
  509.                     case NUM_OF_MNEMO + 4:  //бридж 4
  510.                         //memcpy((uint8_t*)&tx_local_buffer1,(uint8_t*)&data_for_BRIDJ[3],sizeof(NET_BRIDJ_OUTPUT_STRUCT));
  511.                         //cur_address1=data_for_BRIDJ[3].head.adr;
  512.                     break;
  513.                     case NUM_OF_MNEMO + 5:  //бридж 5
  514.                         //memcpy((uint8_t*)&tx_local_buffer1,(uint8_t*)&data_for_BRIDJ[4],sizeof(NET_BRIDJ_OUTPUT_STRUCT));
  515.                         //cur_address1=data_for_BRIDJ[4].head.adr;
  516.                     break;
  517.                 }
  518.         }
  519.         else
  520.         {
  521.             if(tech_fl&SOUND)
  522.             {
  523.                 lcd_data.out_lcd[0]=10;
  524.                 lcd_data.out_lcd[1]=8;
  525.             }
  526.             else if(!LCD_light)
  527.             {
  528.                 lcd_data.out_lcd[0]=0;
  529.                 lcd_data.out_lcd[1]=0;
  530.             }
  531.             else
  532.             {
  533.                 lcd_data.out_lcd[0]=0;
  534.                 lcd_data.out_lcd[1]=8;
  535.             }
  536.             memcpy((uint8_t*)&lcd_data.out_lcd[2],(uint8_t*)&LCD_str[0],16);
  537.             lcd_data.out_lcd[18]='\\';
  538.             lcd_data.out_lcd[19]='n';
  539.             memcpy((uint8_t*)&lcd_data.out_lcd[20],(uint8_t*)&LCD_str[16],16);
  540.             memcpy((uint8_t*)&tx_local_buffer1,(uint8_t*)&lcd_data,sizeof(LCD_OUTPUT_STRUCT));
  541.             cur_address1=0x20;
  542.         }
  543.  
  544.         uart_status1=0;
  545.         uart_init1();
  546.         set_uart1_to_receive();
  547. #if UART1_MASTER
  548.             UCSR1B=(1<<TXEN1)|(1<<TXCIE1);   //разрешение передатчика
  549.             set_uart1_to_transmitt();
  550.             _delay_us(100);
  551.             UDR1='#';
  552. #else
  553.             UCSR1B=(1<<RXEN1)|(1<<RXCIE1);
  554. #endif
  555.     }
  556.     else Transmitt_buffer_uart1();
  557.     //Sleep(50);
  558. //      Sleep(25);//70//10.37ms//50!!!!!!!!!!!!!!!!!!!!!!НЕ ЗАБУДЬ, ЧТО НИ ТИКА НЕ ВЕРНУТЬ, НЕ ЗАБУДЬ!!!!!!!!!!
  559.     }
  560. }
  561.  
  562. }
  563.  
  564. //-----------------------------------------------------------------------------
  565. extern void low_drv();
  566. extern uint8_t cur_msk_selector;
  567. extern uint8_t MT[2];
  568. namespace OS {
  569.  
  570. template<> OS_PROCESS void TPeripheral::Exec()
  571. {
  572.     cur_msk_selector=0;
  573.     for(;;)
  574.     {
  575.         low_drv();
  576.         Sleep(7);//10.37ms//7
  577.     }
  578. }
  579. }
  580.  
  581. //-----------------------------------------------------------------------------
  582. void inconv();void outconv();void outconv_io();
  583. uint8_t sec_tik;
  584. uint8_t lcd_drv_counter;
  585. uint8_t WaitWhenIronIsReady;
  586. namespace OS {
  587.  
  588. template<> OS_PROCESS void TTechnolog::Exec()
  589. {
  590. /*
  591.     check_iic_status();
  592.     Work_init();
  593.     Dev_init();
  594.     Reg_init();
  595.     Menu_init();
  596.     Meas_init();
  597.     Cond_init();
  598.     Message_init();
  599. */
  600.     WaitWhenIronIsReady=10;
  601.     for(;;)
  602.     {
  603.         if(tech_fl&NO_IIC) tech_fl|=IIC_BUSY;
  604.         else tech_fl&=~IIC_BUSY;
  605. //      if(/*(!OS::GetTickCount())&&*/ (!(OS::GetTick200ms())) && (!(OS::GetTick1s()))) sec_tik=0;
  606. //      else sec_tik=0xff;
  607.         Menu_drv();
  608.         outconv();
  609.         if(!WaitWhenIronIsReady)
  610.         {
  611.             Pdz_drv();
  612.             Etaz_drv();
  613.             Work_drv();
  614.             Dev_drv();
  615.             Message_drv();
  616.             all_ind();
  617.             PORTE&=~(1<<PE4);
  618. //          outconv_io();
  619.         }
  620.         else if(!sec_tik) WaitWhenIronIsReady--;
  621.  
  622. //      if(lcd_drv_counter) lcd_drv_counter--;
  623. //      else lcd_drv_counter=5;
  624. //      if(!lcd_drv_counter)
  625.         skreensvr_drv();
  626.         inconv();
  627.         Sleep(27);//9//27
  628.     }
  629. }
  630. }
  631. //-----------------------------------------------------------------------------
  632. OS_INTERRUPT void USART0_RX_vect()
  633. {
  634.     OS::TISRW_SS ISRW;
  635.     uint8_t ret_val;
  636.  
  637.     ret_val=Receive_buffer_uart0(cur_address0);
  638.     switch(ret_val)
  639.     {
  640.         case 2:
  641.         {
  642.             UCSR0B=0;
  643.             #if !UART0_MASTER
  644.             efUART0.Signal();
  645.             #endif
  646.             break;
  647.         }
  648.         case 3:
  649.         {
  650.             uart_status0|=UART_RX_OK;
  651.             uart_init0();
  652.             #if !UART0_MASTER
  653.             UCSR0B=(1<<TXEN0)|(1<<TXCIE0);   //разрешение передатчика
  654.             set_uart0_to_transmitt();
  655.             UDR0='!';
  656.             #endif
  657.             break;
  658.         }
  659.     }
  660.    
  661. }
  662. OS_INTERRUPT void USART0_TX_vect()
  663. {
  664.     OS::TISRW_SS ISRW;
  665.     Transmitt_buffer_uart0();
  666.     #if !UART0_MASTER
  667.     if(uart_status0&UART_TX_OK)
  668.     {
  669.         efUART0.Signal();
  670.     }
  671.     #endif
  672.    
  673. }
  674. //-----------------------------------------------------------------------------
  675. OS_INTERRUPT void USART1_RX_vect()
  676. {
  677.     OS::TISRW_SS ISRW;
  678.     uint8_t ret_val;
  679.  
  680.     ret_val=Receive_buffer_uart1(cur_address1);
  681.     switch(ret_val)
  682.     {
  683.         case 2:
  684.         {
  685.             UCSR1B=0;
  686.             //#if !UART1_MASTER
  687.             efUART1.Signal();
  688.             //#endif
  689.             break;
  690.         }
  691.         case 3:
  692.         {
  693.             uart_status1|=UART_RX_OK;
  694.             uart_init1();
  695.             efUART1.Signal();
  696.             #if !UART1_MASTER
  697.             UCSR1B=(1<<TXEN1)|(1<<TXCIE1);   //разрешение передатчика
  698.             set_uart1_to_transmitt();
  699.             UDR1='!';
  700.             #endif
  701.             break;
  702.         }
  703.     }
  704.    
  705. }
  706.  
  707. void set_uart1_receive();
  708. OS_INTERRUPT void USART1_TX_vect()
  709. {
  710.     OS::TISRW_SS ISRW;
  711.     Transmitt_buffer_uart1();
  712.     #if !UART1_MASTER
  713.     if(uart_status1&UART_TX_OK)
  714.     {
  715.         efUART1.Signal();
  716.     }
  717.     #endif
  718.    
  719. }
  720. /////////////////////////////////////////////////////////////////
  721. //~~~~~~~~~~~~~~~~~~~~~~~~~~МСК~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
  722. // Функцыя обработки МСК. Цель такой переделки -
  723. // выиграть 100 байт памяти, а еще это может дать возможность,
  724. // задавать контакт МСК уст-ва из меню
  725. // В функцыю передается номер контакта МСК
  726. // функцыя возвращает значение МСК.
  727. // Если возвращаемое значение 0xFF - ошибка, номер контакта
  728. // выходит за пределы МСК.
  729. // Тут же мск ИМВВ
  730. // Дописать мск для 3-го и 4-го мск ИМВВ
  731. // Нумерацыя МСК МРТП4 от 0 до 63. Нумерацыя МСК ИМВВ 100-163.
  732. //
  733. //  V 1.0
  734. ////////////////////////////////////////////////////////////////
  735. uint8_t msk (uint8_t pin)
  736. {
  737.     uint8_t result=0;
  738.  
  739.     if(pin < 100) // МСК МРТП4
  740.     {
  741.         if(!(pin >> 5)) ///первый МСК
  742.         {
  743.             if(MSK[3 - (pin >> 3)] & (1<<((pin & 7)))) result = 1;
  744.             else result = 0;
  745.         }
  746.         else   // 2-й МСК
  747.         {
  748.             pin = pin & 0x1f;
  749.             if(MSK[7 - (pin >> 3)] & (1<<((pin & 7)))) result = 1;
  750.             else result = 0;
  751.         }
  752.     }
  753.     else // МСК ИМВВ
  754.     {
  755. //конвертация МСК ИМВВ
  756. /////////////////////////////////////////////////
  757. ////                МСК1     |   МСК2
  758. ////  imvv_in[4] [16,15,14,13|16,15,14,13]
  759. ////  imvv_in[6] [12,11,10, 9|12,11,10, 9]
  760. ////  imvv_in[8] [ 8, 7, 6, 5| 8, 7, 6, 5]
  761. ////  imvv_in[10][ 4, 3, 2, 1| 4, 3, 2, 1]
  762. /////////////////////////////////////////////////  
  763.         if(pin<200){//первое имвв
  764.             pin = pin - 100;
  765.             switch(pin >> 4)
  766.             {
  767.                 case 0:  // 1-й МСК
  768.                     pin = pin & 0xF;
  769.                     if(data_from_imvv.imvv_in[10 - ((pin>>2)*2)] & (1<<((pin & 3)))) result = 1;
  770.                     else result = 0;
  771.                 break;
  772.                 case 1:  // 2-й МСК
  773.                     pin = pin & 0xF;
  774.                     if(data_from_imvv.imvv_in[10 - ((pin>>2)*2)] & (1<<((pin & 3)+4))) result = 1;
  775.                     else result = 0;
  776.                 break;
  777.                 case 2:  // 3-й МСК
  778.                     pin &= 0xF;
  779.                     //pin = (pin - 32) & 0xF;
  780.                     if(data_from_imvv.imvv_in[11 - ((pin>>2)*2)] & (1<<((pin & 3)))) result = 1;
  781.                     else result = 0;
  782.                 break;
  783.                 case 3:  // 4-й МСК
  784.                     pin &= 0xF;
  785.                     //pin = (pin - 32) & 0xF;
  786.                     if(data_from_imvv.imvv_in[11 - ((pin>>2)*2)] & (1<<((pin & 3)+4))) result = 1;
  787.                     else result = 0;
  788.                 break;
  789.             }
  790.         }else{//второе имвв
  791.             pin = pin - 200;
  792.             switch(pin >> 4)
  793.             {
  794.                 case 0:  // 1-й МСК
  795.                     pin = pin & 0xF;
  796.                     if(FROMBFPP1_1.imvv_in[10 - ((pin>>2)*2)] & (1<<((pin & 3)))) result = 1;
  797.                     else result = 0;
  798.                 break;
  799.                 case 1:  // 2-й МСК
  800.                     pin = pin & 0xF;
  801.                     if(FROMBFPP1_1.imvv_in[10 - ((pin>>2)*2)] & (1<<((pin & 3)+4))) result = 1;
  802.                     else result = 0;
  803.                 break;
  804.             }
  805.         }
  806.     }
  807.     return result;
  808.    
  809. }
  810.  
  811.  
  812. extern uint8_t MSK[8],OS_MT[2],MT[2];
  813. uint8_t OS_FIELD[16],OUT_FIELD[16];//,OUT_FIELD_IO[8];
  814. uint8_t OUT_imvv[16*2], OS_imvv[16*2];//множим на колво имвв
  815. void outconv()
  816. {
  817.     uint8_t i,j;
  818. /*  for(i=0;i<8;i++)
  819.     {
  820.         for(j=0;j<8;j++)
  821.         {
  822.             MSK_FIELD[i*8+j]=MSK[i]&(1<<j);
  823.         }
  824.     }
  825. */  for(i=0;i<2;i++)
  826.     {
  827.         for(j=0;j<8;j++)
  828.         {
  829.             OS_FIELD[i*8+j]=OS_MT[i]&(1<<j);
  830.         }
  831.     }
  832. //конвертация ОС ИМВВ
  833.  
  834.     for(i=0;i<2;i++)//первое имвв
  835.     {
  836.         for(j=0;j<8;j++)
  837.         {
  838.             OS_imvv[i*8+j]=data_from_imvv.imvv_in[i+2]&(1<<j);
  839.         }
  840.     }
  841.  
  842.     for(i=0;i<2;i++)//второе имвв
  843.     {
  844.         for(j=0;j<8;j++)
  845.         {
  846.             OS_imvv[i*8+j+16]=FROMBFPP1_1.imvv_in[i+2]&(1<<j);
  847.         }
  848.     }
  849.  
  850. /*    for(i=0;i<4;i++)
  851.     {
  852.         for(j=0;j<8;j++)
  853.             if(j<4)
  854.                 if(data_from_imvv[0].imvv_in[10-i*2]&(1<<j)) MSK_IMVV[0][i*4+j]=1;
  855.                 else MSK_IMVV[0][i*4+j]=0;
  856.             else
  857.                 if(data_from_imvv[0].imvv_in[10-i*2]&(1<<j)) MSK_IMVV[1][i*4+(j-4)]=1;
  858.                 else  MSK_IMVV[1][i*4+(j-4)]=0;
  859.  
  860.     }*/
  861. }
  862. void inconv()
  863. {
  864.     uint8_t i,j;
  865.     for(i=0;i<2;i++)
  866.     {
  867.         for(j=0;j<8;j++)
  868.         {
  869.             if(OUT_FIELD[i*8+j]) MT[i]|=(1<<j);
  870.             else MT[i]&=~(1<<j);
  871.         }
  872.     }
  873. //конвертация выходов имвв
  874.     for(i=0;i<2;i++)//первое имвв
  875.     {
  876.         for(j=0;j<8;j++)
  877.         {
  878.             if(OUT_imvv[i*8+j]) data_for_imvv.imvv_out[i+2]&=~(1<<j);
  879.             else data_for_imvv.imvv_out[i+2]|=(1<<j);
  880.         }
  881.     }
  882.  
  883.     for(i=0;i<2;i++)//второе имвв
  884.     {
  885.         for(j=0;j<8;j++)
  886.         {
  887.             if(OUT_imvv[i*8+j+16]) FORBFPP1_1.imvv_out[i+2]&=~(1<<j);
  888.             else FORBFPP1_1.imvv_out[i+2]|=(1<<j);
  889.         }
  890.     }
  891.  
  892. }
  893.  
  894.  
  895.  
  896. /*void outconv_io()
  897. {
  898.     uint8_t i;
  899.     for(i=0;i<8;i++)
  900.     {
  901.             if(OUT_FIELD_IO[i]) data_for_io[0].io_out&=~(1<<i);
  902.             else data_for_io[0].io_out|=(1<<i);
  903.     }
  904. } */
  905.  
  906. OS_INTERRUPT void TIMER1_COMPA_vect()
  907. {
  908.     OS::TISRW_SS ISRW;
  909.     //set_sound();
  910. #if atmega128
  911.     if(!sec_tik) {OCR1AH = 0x28;OCR1AL = 0xB0;sec_tik=0xff;}
  912.     else{OCR1AH = 0x00;OCR1AL = 0xE0;sec_tik=0x00;}
  913. #endif
  914. #if atmega1281
  915.     if(!sec_tik) {OCR1AH = 0x28;OCR1AL = 0xB0;sec_tik=0xff;}
  916.     else{OCR1AH = 0x01;OCR1AL = 0xC0;sec_tik=0x00;}
  917. #endif
  918. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!