Ignore:
Timestamp:
May 1, 2026, 7:10:54 PM (5 days ago)
Author:
f.jahn
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/fw_g473rct/Core/Src/main.c

    r69 r70  
    101101static volatile uint32_t newADC5Data = 0;
    102102
    103 ring_buffer_t usb_in_buff __attribute__((section(".CCM_RAM1_CRC")));
    104 ring_buffer_t usb_out_buff __attribute__((section(".CCM_RAM1_CRC")));
     103ring_buffer_t usb_in_buff __attribute__((section(".CCM_RAM1")));
     104ring_buffer_t usb_out_buff __attribute__((section(".CCM_RAM1")));
    105105
    106106/* USER CODE END PV */
     
    381381
    382382#ifdef DEBUG
    383           if (sys_data.s.values.onTime % 5U == 0U)
     383          /*if (sys_data.s.values.onTime % 5U == 0U)
    384384          {
    385385                  static char* Buf = "Hello everybody!\r\n";
    386386                  const unsigned BufLen = strlen(Buf);
    387387                  CDC_Transmit_FS((uint8_t*)Buf, BufLen - 1);
    388           }
     388          }*/
    389389#endif
    390390    }
     
    474474                processUSB(&usb_in_buff, &usb_out_buff);
    475475        }
     476
     477        if (rb_available(&usb_out_buff) > 0)
     478        {
     479                static uint32_t lastTime_ms;
     480
     481                uint16_t data_num = rb_available(&usb_out_buff);
     482
     483                static uint8_t out_buff[1U + 1U + 1U + 250U + 2U];
     484
     485                for (int i = 0; i < data_num; ++i)
     486                {
     487                        uint8_t data;
     488                        rb_pop(&usb_out_buff, &data);
     489                        out_buff[i] = data;
     490                }
     491
     492                CDC_Transmit_FS(out_buff, data_num);
     493
     494                lastTime_ms = HAL_GetTick();
     495        }
    476496 
    477497  }
     
    547567        switch (stage)
    548568        {
    549                 case 0: // Initial stage. We are waiting for our slave address
     569                case 0: // Initial stage. We are waiting for our slave address in input buffer
    550570                        while (rb_peek(ring_in_buff, &adr) && adr != sys_data.s.parameter.slave_address) // Removing elements from ring buffer, till we get a byte with our salve address
     571                        {
    551572                                rb_pop(ring_in_buff, &data);
     573#ifdef DEBUG
     574                                printf("USB: Removed 0x%02X from input buffer\n", data);
     575#endif
     576                        }
    552577       
     578                        uint8_t offset = 0U;
    553579                        uint8_t fc;
    554                         bool r = rb_peek_at(ring_in_buff, 1U, &fc);                                                     // Testing function code, if present
     580                        bool r = rb_peek_at(ring_in_buff, ++offset, &fc);                                       // Testing function code, if present
    555581                        if (r == false)
    556582                        {
     
    564590                                case FC_READ_HOLDING_REGISTERS: {
    565591                                        uint8_t start_addr_hi;
    566                                         r = rb_peek_at(ring_in_buff, 3U, &start_addr_hi);
     592                                        r = rb_peek_at(ring_in_buff, ++offset, &start_addr_hi);
    567593                                        if (r == false)
    568594                                        {
     
    573599
    574600                                        uint8_t start_addr_lo;
    575                                         r = rb_peek_at(ring_in_buff, 2U, &start_addr_lo);
     601                                        r = rb_peek_at(ring_in_buff, ++offset, &start_addr_lo);
    576602                                        if (r == false)
    577603                                        {
     
    582608
    583609                                        uint16_t start_addr = (((uint16_t)start_addr_hi) << 8U) | ((uint16_t)start_addr_lo);  // Modbus register start address
    584 
     610#ifdef DEBUG
     611                                        printf("USB: Start address is 0x%04X\n", start_addr);
     612#endif
    585613                                        uint8_t reg_num_hi;
    586                                         r = rb_peek_at(ring_in_buff, 5U, &reg_num_hi);
     614                                        r = rb_peek_at(ring_in_buff, ++offset, &reg_num_hi);
    587615                                        if (r == false)
    588616                                        {
     
    593621
    594622                                        uint8_t reg_num_lo;
    595                                         r = rb_peek_at(ring_in_buff, 4U, &reg_num_lo);
     623                                        r = rb_peek_at(ring_in_buff, ++offset, &reg_num_lo);
    596624                                        if (r == false)
    597625                                        {
     
    602630
    603631                                        uint16_t reg_num = (((uint16_t)reg_num_hi) << 8U) | ((uint16_t)reg_num_lo);  // Modbus Quantity of Registers
    604 
    605 
     632#ifdef DEBUG
     633                                        printf("USB: Register number is %u(0x%04X)\n", reg_num, reg_num);
     634#endif
     635                                        uint8_t crc_hi;
     636                                        r = rb_peek_at(ring_in_buff, ++offset, &crc_hi);
     637                                        if (r == false)
     638                                        {
     639                                                lastTime = HAL_GetTick();                                                               // Saving time of arrival of last byte
     640                                                ++stage;
     641                                                return;
     642                                        }
     643
     644                                        uint8_t crc_lo;
     645                                        r = rb_peek_at(ring_in_buff, ++offset, &crc_lo);
     646                                        if (r == false)
     647                                        {
     648                                                lastTime = HAL_GetTick();                                                               // Saving time of arrival of last byte
     649                                                ++stage;
     650                                                return;
     651                                        }
     652
     653                                        uint16_t crc = (((uint16_t)crc_hi) << 8U) | ((uint16_t)crc_lo);  // Modbus CRC
     654#ifdef DEBUG
     655                                        printf("USB: CRC from data packet is %u(0x%04X)\n", crc, crc);
     656#endif
     657                                        const uint8_t in_buff[6U] = { adr, fc, start_addr_hi, start_addr_lo, reg_num_hi, reg_num_lo };
     658                                        uint16_t calc_crc = mbCrc16(in_buff, 6U);
     659                                        calc_crc = __REV16(calc_crc);
     660#ifdef DEBUG
     661                                        printf("USB: Calculated CRC is %u(0x%04X)\n", calc_crc, calc_crc);
     662#endif
     663                                        if (calc_crc != crc)                                                                            // Transmission error or bad packet
     664                                        {
     665                                                stage = 0;                                                                                              // Starting all over again
     666                                                return;
     667                                        }
     668
     669                                        for (int i = 0; i < 8; ++i) rb_pop(ring_in_buff, &data);        // If CRC Ok, then removing recognized bytes from ring buffer to free some place as soon as possible
     670
     671                                        // Now we need to send a respond
     672                                        static uint8_t out_buff[1U + 1U + 1U + 250U + 2U];
     673                                        out_buff[0U] = adr;
     674                                        out_buff[1U] = fc;
     675                                        out_buff[2U] = reg_num * 2U;
     676                                        for (uint16_t i = 3U, j = start_addr; j < reg_num; i += 2U, ++j)
     677                                        {
     678                                                //printf("i = %u, j = %u\n", i , j);
     679                                                out_buff[i] = sys_data.mb[j].b[1];
     680                                                out_buff[i + 1U] = sys_data.mb[j].b[0];
     681                                        }
     682                                        uint16_t resp_crc = mbCrc16(out_buff, 1U + 1U + 1U + reg_num * 2U);
     683                                        resp_crc = __REV16(resp_crc);
     684                                        out_buff[1U + 1U + 1U + reg_num * 2U] = resp_crc >> 8U;
     685                                        out_buff[1U + 1U + 1U + reg_num * 2U + 1U] = (resp_crc & 0x00FF);
     686
     687                                        /*for (int i = 0; i < 1 + 1 + 1 + reg_num * 2 + 2; ++i)
     688                                                printf("0x%02X ", out_buff[i]);
     689                                        printf("\n");*/
     690
     691                                        // Putting prepared packet into output buffer
     692                                        for (int i = 0; i < 1 + 1 + 1 + reg_num * 2 + 2; ++i)
     693                                                rb_push(ring_out_buff, out_buff[i]);
    606694                                        }
    607695                                        break;
Note: See TracChangeset for help on using the changeset viewer.