iNavFlight之RC遥控CRSF协议

已于 2022-12-16 10:26:54 修改
阅读量3.7k 收藏 27
点赞数 2
分类专栏： xFlight 文章标签： 单片机 stm32 嵌入式硬件 iNav
于 2022-12-16 09:44:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lida2003/article/details/128338564
版权

iNavFlight之RC遥控CRSF协议

本章重点介绍RC遥控CRSF协议，因为博主现在用的遥控器是TX12，外接了ELRS 915MHz发射器。

注：前面的坑就不说了，都是通信距离短短惹的货，最后就换遥控器，配大功率发射机。详细可参考【四轴飞控DIY集成FPV功能】。

关于【RC摇杆总体逻辑框架】【RC摇杆代码设计框架】这里我们都不再重复了，如果前面那篇没有看过的，点击【链接】。

1. 遥控器电传框架设计

通常遥控器都有电传功能：飞控可以配置使用遥控通信频道汇报链路状态，甚至GPS、高度等信息。这里补充下遥控电传的框架设计。

注1：基于MSP的RC遥控这部分内容是没有的，是一种存粹的遥控。
注2：通常MSP协议是通过TTL串口物理硬连接，且物理连线很短。所以设计时仅有一个20HZ的超时，也没有CRC校验，来确保链路的可靠性和数据的可靠性。

1.1 场景分析

除了控制飞控，同时也希望获得飞控当前的状态，比如：飞行姿态，高度，GPS位置等信息，以便地面人员更好的了解模型的飞行情况。

注：当然有些信息在OSD上也有显示，甚至显示的更加全面，但是遥控和电传比图传发展的更早。大家应该知道什么是目视飞行，目视飞行和FPV飞行最大的差异就是目视是以第三方视角来操控飞机，而FPV是第一人称方式操控飞机。

1.2 逻辑框架

从逻辑角度，需要三个步骤来完成电传的功能：

  1. 电传信息获取
  2. 电传信息处理
  3. 电传初始化

1.2.1 电传信息获取

  1. 电传信息主要来源于全局变量
  2. 当前全局变量一定是最近一次的数据更新
  3. iNav/BetaFlight飞控是一种特殊的多任务微系统(每个任务都会完整完成才会被切换)，数据完整性能够得到保证

所以，没有必要像多任务系统那样复杂封装接口来确保数据的有效性和完整性。

1.2.2 电传信息处理

电传信息主要来源于飞控内部，按时更新并反馈地面端即可，iNav/BetaFlight开启了电传任务来完成上述工作。

鉴于电传信息的汇报成功与否，并非会对飞行形成致命伤害，所以报文是否被地面端接受其实并不是太重要，反而间接的检验飞控与遥控器之间的通信链路是否稳定和可靠的一种补充。

当然，向433MHz的电传报文大部分就不是发送给遥控器，而是发给地面站软件，而这部分可能MAVLink通信报文比较多，后续我们有时间也会慢慢研读和介绍。

1.2.3 电传初始化

略, 这部分就不多展开，所有的嵌入式设计都会有初始化部分，航模飞控没有去初始化的部分，大体是因为我们通常是拔电池了，当然如果说自杀式无人机，估计也不需要去初始化，人家上天就不打算回来了，拔电池都省略了，呵呵。

注：要注意一点，如果有遥控器，通信端口在遥控器的初始化会挂在相应的报文接收函数。但是如果仅仅是电传，比如：MAVLink，那么初始化部分会提供通信端口的初始化，此时会挂在报文接收处理函数。

1.3 模块化设计

  • 各种电传报文初始化部分
main
 └──> init
     └──> telemetryInit
         ├──> initFrSkyTelemetry
         ├──> initHoTTTelemetry
         ├──> initSmartPortTelemetry
         ├──> initLtmTelemetry
         ├──> initMAVLinkTelemetry
         ├──> initJetiExBusTelemetry
         ├──> initIbusTelemetry
         ├──> initSimTelemetry
         ├──> **initCrsfTelemetry**
         ├──> initSrxlTelemetry
         ├──> initGhstTelemetry
         └──> telemetryCheckState
	         ├──> checkFrSkyTelemetryState
	         ├──> checkHoTTTelemetryState
	         ├──> checkSmartPortTelemetryState
	         ├──> checkLtmTelemetryState
	         ├──> checkMAVLinkTelemetryState
	         ├──> checkJetiExBusTelemetryState
	         ├──> checkIbusTelemetryState
	         ├──> checkSimTelemetryState
	         ├──> **checkCrsfTelemetryState**
	         ├──> checkSrxlTelemetryState
             └──> checkGhstTelemetryState
  • crsfRxSendTelemetryData发送电传报文 //永远发送的上一次打包的电传报文，鉴于频率是500Hz，2ms间隔粒度延迟
  • processCrsf打包电传报文
taskTelemetry
 └──> telemetryProcess
     └──> handleCrsfTelemetry
	     ├──> crsfRxSendTelemetryData
         └──> processCrsf

#ifdef USE_TELEMETRY
    [TASK_TELEMETRY] = {
        .taskName = "TELEMETRY",
        .taskFunc = taskTelemetry,
        .desiredPeriod = TASK_PERIOD_HZ(500),         // 500 Hz
        .staticPriority = TASK_PRIORITY_IDLE,
    },
#endif

2. CRSF电传报文

2.1 CRSF电传报文格式

  +----+---------+---------+---------------------+-----+
  |           CRSF Frame Format     4 + payload(n)     |
  +----+---------+---------+---------------------+-----+
  |0XC8| size(1) | type(1) |  payload(size - 2)  | CRC |
  +----+---------+---------+---------------------+-----+
size = payload(n) + type(1) + crc(1)

2.2 CRSF电传报文内容

iNav支持以下CRSF电传报文

  1. CRSF_FRAMETYPE_ATTITUDE = 0x1E
  2. CRSF_FRAMETYPE_BATTERY_SENSOR = 0x08
  3. CRSF_FRAMETYPE_FLIGHT_MODE = 0x21
  4. CRSF_FRAMETYPE_GPS = 0x02
  5. CRSF_FRAMETYPE_VARIO_SENSOR = 0x07

2.2.1 CRSF_FRAMETYPE_ATTITUDE

飞控飞行姿态角度：Pitch/Roll/Yaw

/*
0x1E Attitude
Payload:
int16_t     Pitch angle ( rad / 10000 )
int16_t     Roll angle ( rad / 10000 )
int16_t     Yaw angle ( rad / 10000 )
*/

#define DECIDEGREES_TO_RADIANS10000(angle) ((int16_t)(1000.0f * (angle) * RAD))

static void crsfFrameAttitude(sbuf_t *dst)
{
     sbufWriteU8(dst, CRSF_FRAME_ATTITUDE_PAYLOAD_SIZE + CRSF_FRAME_LENGTH_TYPE_CRC);
     crsfSerialize8(dst, CRSF_FRAMETYPE_ATTITUDE);
     crsfSerialize16(dst, DECIDEGREES_TO_RADIANS10000(attitude.values.pitch));
     crsfSerialize16(dst, DECIDEGREES_TO_RADIANS10000(attitude.values.roll));
     crsfSerialize16(dst, DECIDEGREES_TO_RADIANS10000(attitude.values.yaw));
}

2.2.2 CRSF_FRAMETYPE_BATTERY_SENSOR

电池状态：电压/电流/容量/剩余百分比

/*
0x08 Battery sensor
Payload:
uint16_t    Voltage ( mV * 100 )
uint16_t    Current ( mA * 100 )
uint24_t    Capacity ( mAh )
uint8_t     Battery remaining ( percent )
*/
static void crsfFrameBatterySensor(sbuf_t *dst)
{
    // use sbufWrite since CRC does not include frame length
    sbufWriteU8(dst, CRSF_FRAME_BATTERY_SENSOR_PAYLOAD_SIZE + CRSF_FRAME_LENGTH_TYPE_CRC);
    crsfSerialize8(dst, CRSF_FRAMETYPE_BATTERY_SENSOR);
    if (telemetryConfig()->report_cell_voltage) {
        crsfSerialize16(dst, getBatteryAverageCellVoltage() / 10);
    } else {
        crsfSerialize16(dst, getBatteryVoltage() / 10); // vbat is in units of 0.01V
    }
    crsfSerialize16(dst, getAmperage() / 10);
    const uint8_t batteryRemainingPercentage = calculateBatteryPercentage();
    crsfSerialize8(dst, (getMAhDrawn() >> 16));
    crsfSerialize8(dst, (getMAhDrawn() >> 8));
    crsfSerialize8(dst, (uint8_t)getMAhDrawn());
    crsfSerialize8(dst, batteryRemainingPercentage);
}

2.2.3 CRSF_FRAMETYPE_FLIGHT_MODE

飞行模式

/*
0x21 Flight mode text based
Payload:
char[]      Flight mode ( Null­terminated string )
*/
static void crsfFrameFlightMode(sbuf_t *dst)
{
    // just do "OK" for the moment as a placeholder
    // write zero for frame length, since we don't know it yet
    uint8_t *lengthPtr = sbufPtr(dst);
    sbufWriteU8(dst, 0);
    crsfSerialize8(dst, CRSF_FRAMETYPE_FLIGHT_MODE);

    // use same logic as OSD, so telemetry displays same flight text as OSD when armed
    const char *flightMode = "OK";
    if (ARMING_FLAG(ARMED)) {
        if (STATE(AIRMODE_ACTIVE)) {
            flightMode = "AIR";
        } else {
            flightMode = "ACRO";
        }
        if (FLIGHT_MODE(FAILSAFE_MODE)) {
            flightMode = "!FS!";
        } else if (ARMING_FLAG(ARMED) && IS_RC_MODE_ACTIVE(BOXHOMERESET) && !FLIGHT_MODE(NAV_RTH_MODE) && !FLIGHT_MODE(NAV_WP_MODE)) {
            flightMode = "HRST";
        } else if (FLIGHT_MODE(MANUAL_MODE)) {
            flightMode = "MANU";
        } else if (FLIGHT_MODE(NAV_RTH_MODE)) {
            flightMode = "RTH";
        } else if (FLIGHT_MODE(NAV_POSHOLD_MODE)) {
            flightMode = "HOLD";
        } else if (FLIGHT_MODE(NAV_COURSE_HOLD_MODE) && FLIGHT_MODE(NAV_ALTHOLD_MODE)) {
            flightMode = "CRUZ";
        } else if (FLIGHT_MODE(NAV_COURSE_HOLD_MODE)) {
            flightMode = "CRSH";
        } else if (FLIGHT_MODE(NAV_ALTHOLD_MODE)) {
            flightMode = "AH";
        } else if (FLIGHT_MODE(NAV_WP_MODE)) {
            flightMode = "WP";
        } else if (FLIGHT_MODE(ANGLE_MODE)) {
            flightMode = "ANGL";
        } else if (FLIGHT_MODE(HORIZON_MODE)) {
            flightMode = "HOR";
        }
#ifdef USE_GPS
    } else if (feature(FEATURE_GPS) && navConfig()->general.flags.extra_arming_safety && (!STATE(GPS_FIX) || !STATE(GPS_FIX_HOME))) {
        flightMode = "WAIT"; // Waiting for GPS lock
#endif
    } else if (isArmingDisabled()) {
        flightMode = "!ERR";
    }

    crsfSerializeData(dst, (const uint8_t*)flightMode, strlen(flightMode));
    crsfSerialize8(dst, 0); // zero terminator for string
    // write in the length
    *lengthPtr = sbufPtr(dst) - lengthPtr;
}

2.2.4 CRSF_FRAMETYPE_GPS

全套GPS信息，含GPS坐标，高度，卫星数量等等。

/*
0x02 GPS
Payload:
int32_t     Latitude ( degree / 10`000`000 )
int32_t     Longitude (degree / 10`000`000 )
uint16_t    Groundspeed ( km/h / 10 )
uint16_t    GPS heading ( degree / 100 )
uint16      Altitude ( meter ­1000m offset )
uint8_t     Satellites in use ( counter )
*/
static void crsfFrameGps(sbuf_t *dst)
{
    // use sbufWrite since CRC does not include frame length
    sbufWriteU8(dst, CRSF_FRAME_GPS_PAYLOAD_SIZE + CRSF_FRAME_LENGTH_TYPE_CRC);
    crsfSerialize8(dst, CRSF_FRAMETYPE_GPS);
    crsfSerialize32(dst, gpsSol.llh.lat); // CRSF and betaflight use same units for degrees
    crsfSerialize32(dst, gpsSol.llh.lon);
    crsfSerialize16(dst, (gpsSol.groundSpeed * 36 + 50) / 100); // gpsSol.groundSpeed is in cm/s
    crsfSerialize16(dst, DECIDEGREES_TO_CENTIDEGREES(gpsSol.groundCourse)); // gpsSol.groundCourse is 0.1 degrees, need 0.01 deg
    const uint16_t altitude = (getEstimatedActualPosition(Z) / 100) + 1000;
    crsfSerialize16(dst, altitude);
    crsfSerialize8(dst, gpsSol.numSat);
}

2.2.5 CRSF_FRAMETYPE_VARIO_SENSOR

计算得来的估算垂直速度

/*
0x07 Vario sensor
Payload:
int16      Vertical speed ( cm/s )
*/
static void crsfFrameVarioSensor(sbuf_t *dst)
{
    // use sbufWrite since CRC does not include frame length
    sbufWriteU8(dst, CRSF_FRAME_VARIO_SENSOR_PAYLOAD_SIZE + CRSF_FRAME_LENGTH_TYPE_CRC);
    crsfSerialize8(dst, CRSF_FRAMETYPE_VARIO_SENSOR);
    crsfSerialize16(dst, lrintf(getEstimatedActualVelocity(Z)));
}

3. CRSF摇杆代码设计

依然按照iNavFlight之RC遥控MSP协议里面关于遥控部分的逻辑思路和抽象化设计概念走。

  1. rcInit ==> crsfRxInit
  2. rcFrameStatus ==> crsfFrameStatus
  3. rcProcessFrame ==> 无
  4. rcReadRaw ==> crsfReadRawRC
  5. rcFrameReceive ==> crsfDataReceive

3.1 crsfRxInit

  1. 将crsfReadRawRC和crsfFrameStatus两个处理函数挂上统一处理框架
  2. 将crsfDataReceive报文处理函数挂上
  3. 支持17个RC摇杆通道
bool crsfRxInit(const rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig)
{
    for (int ii = 0; ii < CRSF_MAX_CHANNEL; ++ii) {
        crsfChannelData[ii] = (16 * PWM_RANGE_MIDDLE) / 10 - 1408;
    }

    rxRuntimeConfig->channelCount = CRSF_MAX_CHANNEL;
    rxRuntimeConfig->rcReadRawFn = crsfReadRawRC;
    rxRuntimeConfig->rcFrameStatusFn = crsfFrameStatus;

    const serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_RX_SERIAL);
    if (!portConfig) {
        return false;
    }

    serialPort = openSerialPort(portConfig->identifier,
        FUNCTION_RX_SERIAL,
        crsfDataReceive,
        NULL,
        CRSF_BAUDRATE,
        CRSF_PORT_MODE,
        CRSF_PORT_OPTIONS | (tristateWithDefaultOffIsActive(rxConfig->halfDuplex) ? SERIAL_BIDIR : 0)
        );

    return serialPort != NULL;
}

#define CRSF_MAX_CHANNEL        17

3.2 crsfFrameStatus

  1. 两种状态：PENDING or COMPLETE
  2. 两种报文：CRSF_FRAMETYPE_RC_CHANNELS_PACKED or CRSF_FRAMETYPE_LINK_STATISTICS
STATIC_UNIT_TESTED uint8_t crsfFrameStatus(rxRuntimeConfig_t *rxRuntimeConfig)
{
    UNUSED(rxRuntimeConfig);

    if (crsfFrameDone) {
        crsfFrameDone = false;
        if (crsfFrame.frame.type == CRSF_FRAMETYPE_RC_CHANNELS_PACKED) {
            // CRC includes type and payload of each frame
            const uint8_t crc = crsfFrameCRC();
            if (crc != crsfFrame.frame.payload[CRSF_FRAME_RC_CHANNELS_PAYLOAD_SIZE]) {
                return RX_FRAME_PENDING;
            }
            crsfFrame.frame.frameLength = CRSF_FRAME_RC_CHANNELS_PAYLOAD_SIZE + CRSF_FRAME_LENGTH_TYPE_CRC;

            // unpack the RC channels
            const crsfPayloadRcChannelsPacked_t* rcChannels = (crsfPayloadRcChannelsPacked_t*)&crsfFrame.frame.payload;
            crsfChannelData[0] = rcChannels->chan0;
            crsfChannelData[1] = rcChannels->chan1;
            crsfChannelData[2] = rcChannels->chan2;
            crsfChannelData[3] = rcChannels->chan3;
            crsfChannelData[4] = rcChannels->chan4;
            crsfChannelData[5] = rcChannels->chan5;
            crsfChannelData[6] = rcChannels->chan6;
            crsfChannelData[7] = rcChannels->chan7;
            crsfChannelData[8] = rcChannels->chan8;
            crsfChannelData[9] = rcChannels->chan9;
            crsfChannelData[10] = rcChannels->chan10;
            crsfChannelData[11] = rcChannels->chan11;
            crsfChannelData[12] = rcChannels->chan12;
            crsfChannelData[13] = rcChannels->chan13;
            crsfChannelData[14] = rcChannels->chan14;
            crsfChannelData[15] = rcChannels->chan15;
            return RX_FRAME_COMPLETE;
        }
        else if (crsfFrame.frame.type == CRSF_FRAMETYPE_LINK_STATISTICS) {
            // CRC includes type and payload of each frame
            const uint8_t crc = crsfFrameCRC();
            if (crc != crsfFrame.frame.payload[CRSF_FRAME_LINK_STATISTICS_PAYLOAD_SIZE]) {
                return RX_FRAME_PENDING;
            }
            crsfFrame.frame.frameLength = CRSF_FRAME_LINK_STATISTICS_PAYLOAD_SIZE + CRSF_FRAME_LENGTH_TYPE_CRC;

            const crsfPayloadLinkStatistics_t* linkStats = (crsfPayloadLinkStatistics_t*)&crsfFrame.frame.payload;
            const uint8_t crsftxpowerindex = (linkStats->uplinkTXPower < CRSF_POWER_COUNT) ? linkStats->uplinkTXPower : 0;

            rxLinkStatistics.uplinkRSSI = -1* (linkStats->activeAntenna ? linkStats->uplinkRSSIAnt2 : linkStats->uplinkRSSIAnt1);
            rxLinkStatistics.uplinkLQ = linkStats->uplinkLQ;
            rxLinkStatistics.uplinkSNR = linkStats->uplinkSNR;
            rxLinkStatistics.rfMode = linkStats->rfMode;
            rxLinkStatistics.uplinkTXPower = crsfTxPowerStatesmW[crsftxpowerindex];
            rxLinkStatistics.activeAntenna = linkStats->activeAntenna;

            if (rxLinkStatistics.uplinkLQ > 0) {
                int16_t uplinkStrength;   // RSSI dBm converted to %
                uplinkStrength = constrain((100 * sq((osdConfig()->rssi_dbm_max - osdConfig()->rssi_dbm_min)) - (100 * sq((osdConfig()->rssi_dbm_max  - rxLinkStatistics.uplinkRSSI)))) / sq((osdConfig()->rssi_dbm_max - osdConfig()->rssi_dbm_min)),0,100);
                if (rxLinkStatistics.uplinkRSSI >= osdConfig()->rssi_dbm_max )
                    uplinkStrength = 99;
                else if (rxLinkStatistics.uplinkRSSI < osdConfig()->rssi_dbm_min)
                    uplinkStrength = 0;
                lqTrackerSet(rxRuntimeConfig->lqTracker, scaleRange(uplinkStrength, 0, 99, 0, RSSI_MAX_VALUE));
            }
            else
                lqTrackerSet(rxRuntimeConfig->lqTracker, 0);

            // This is not RC channels frame, update channel value but don't indicate frame completion
            return RX_FRAME_PENDING;
        }
    }
    return RX_FRAME_PENDING;
}

3.3 crsfReadRawRC

获取当前某个通道的摇杆值。

STATIC_UNIT_TESTED uint16_t crsfReadRawRC(const rxRuntimeConfig_t *rxRuntimeConfig, uint8_t chan)
{
    UNUSED(rxRuntimeConfig);
    /* conversion from RC value to PWM
     *       RC     PWM
     * min  172 ->  988us
     * mid  992 -> 1500us
     * max 1811 -> 2012us
     * scale factor = (2012-988) / (1811-172) = 0.62477120195241
     * offset = 988 - 172 * 0.62477120195241 = 880.53935326418548
     */
    return (crsfChannelData[chan] * 1024 / 1639) + 881;
}

3.4 crsfDataReceive

支持以下报文：

  1. CRSF_FRAMETYPE_RC_CHANNELS_PACKED
  2. CRSF_FRAMETYPE_LINK_STATISTICS
  3. CRSF_FRAMETYPE_MSP_REQ and CRSF_FRAMETYPE_MSP_WRITE

以轮训遍历的方式发送电传报文，根据目前5个电传报文按照500Hz速率，10ms轮询一次。

// Receive ISR callback, called back from serial port
STATIC_UNIT_TESTED void crsfDataReceive(uint16_t c, void *rxCallbackData)
{
    UNUSED(rxCallbackData);

    static uint8_t crsfFramePosition = 0;
    const timeUs_t now = micros();

#ifdef DEBUG_CRSF_PACKETS
    debug[2] = now - crsfFrameStartAt;
#endif

    if (now > crsfFrameStartAt + CRSF_TIME_NEEDED_PER_FRAME_US) {
        // We've received a character after max time needed to complete a frame,
        // so this must be the start of a new frame.
        crsfFramePosition = 0;
    }

    if (crsfFramePosition == 0) {
        crsfFrameStartAt = now;
    }
    // assume frame is 5 bytes long until we have received the frame length
    // full frame length includes the length of the address and framelength fields
    const int fullFrameLength = crsfFramePosition < 3 ? 5 : crsfFrame.frame.frameLength + CRSF_FRAME_LENGTH_ADDRESS + CRSF_FRAME_LENGTH_FRAMELENGTH;

    if (crsfFramePosition < fullFrameLength) {
        crsfFrame.bytes[crsfFramePosition++] = (uint8_t)c;
        crsfFrameDone = crsfFramePosition < fullFrameLength ? false : true;
        if (crsfFrameDone) {
            crsfFramePosition = 0;
            if (crsfFrame.frame.type != CRSF_FRAMETYPE_RC_CHANNELS_PACKED) {
                const uint8_t crc = crsfFrameCRC();
                if (crc == crsfFrame.bytes[fullFrameLength - 1]) {
                    switch (crsfFrame.frame.type)
                    {
#if defined(USE_MSP_OVER_TELEMETRY)
                        case CRSF_FRAMETYPE_MSP_REQ:
                        case CRSF_FRAMETYPE_MSP_WRITE: {
                            uint8_t *frameStart = (uint8_t *)&crsfFrame.frame.payload + CRSF_FRAME_ORIGIN_DEST_SIZE;
                            if (bufferCrsfMspFrame(frameStart, CRSF_FRAME_RX_MSP_FRAME_SIZE)) {
                                crsfScheduleMspResponse();
                            }
                            break;
                        }
#endif
                        default:
                            break;
                    }
                }
            }
        }
    }
}

4. 参考资料

【1】iNavFlight之RC遥控MSP协议

lida2003
关注
  • 2
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
模型遥控器 CRSF 协议数据格式
03-08
模型遥控器 CRSF 协议数据格式
常用遥控器 CRSF数据协议格式，也称黑羊协议，现在的ELRS都用的这个协议
11-28
常用遥控器 CRSF数据协议格式，也称黑羊协议，现在的ELRS都用的这个协议
ELRS接收机CRSF协议数据包的简单解析（STM32单片机解析）
2301_79968250的博客
03-02 1001
对于许多穿越机爱好者来说，elrs是一款性价比十分不错的接收机,恰巧我最近在学习stm32，于是便想通过单片机对CRSF进行解析。问过许多航模界的大佬，他们似乎并没有过对CRSF协议的解析，网上的资料有比较少，而网络上的协议说明大多都要付费，所以我只好自己进行数据解析，也方便有兴趣的UU们手搓飞控。 ELRS使用的是usart串口通信，相比于sbus、dbus更为基础，无需在硬件上取反，直接使用stm32最小系统板就可以进行处理。
CRSF数据包格式.pdf
07-05
CROSSFIRE 数据包协议
csrf-ssrf
jinhezhai的博客
10-12 1493
title: csrf，ssrf小结 date: 2021-03-17 20:17:40 csrf，ssrf小结 csrf和ssrf的区别 csrf 概念 CSRF跨站点请求伪造(Cross—Site Request Forgery)，跟XSS攻击一样，存在巨大的危害性。你可以这样来理解： 攻击者盗用了你的身份，以你的名义发送恶意请求，对服务器来说这个请求是完全合法的，但是却完成了攻击者所期望的一个操作，比如以你的名义发送邮件、发消息，盗取你的账号，添加系统管理员，甚至于购买商品、.
iNavFlight之RC遥控MSP协议
lida2003的专栏
12-15 1727
该遥控器模拟了一个RC遥控器，通过MSP协议将RC摇杆信息的发送给飞控。鉴于摇杆信息从使用场景上看，主要是两种类型和十三种串行遥控器协议。所以，从整体上设计上需要考虑这些种类的摇杆信息输入。如果真有朋友有兴趣，请评论留言，我有机会一一整理。因此，这里也就给第三方提供了遥控控制MSP协议接口，通过这个链路将可以给飞控发送RC摇杆信息。这个不难理解，无非就是MSP协议的RC摇杆只有两种状态：PENDING or COMPLETE。本章重点介绍MSP摇杆的代码设计，当然我们依然按照逻辑思路和抽象化设计概念走。
对黑羊、Elrs等使用的crsf协议的简单解析
m0_63043961的博客
12-16 9063
对黑羊、Elrs等使用的crsf协议的简单解析
CSRF详解
m0_65041566的博客
05-25 1188
目录 什么时csrf CSRF的特点 CSRF攻击 CSRF防御 CSRF绕过 什么时csrf 跨站请求伪造，伪造来自受网站信任的用户的请求来利用该网站 xss：窃取cookie csrf：借用cookie 利用条件： User登录了受信任的网站，且生成了cookie 在不登出该网站的情况下登录了别的危险网站 利用方法： 盗取身份发送邮件，信息等 修改用户信息 。。。 CSRF的特点 一般发起在第三方网站，而不是被攻击网站，所以被攻击网站无法防御 CSRF只能冒
无人机/FPV穿越机航模的遥控器/接收机等配件厂商
HDHunter的专栏
09-27 7524
本人最近迷恋上了穿越机。整理一些资料，方便后来人学习。。有其他更新资料，欢迎留言，争取打造成好的工具书。 飞控，图传，电调，穿越机品牌，FC飞控，betafFlight
Web安全-CSRF-基础01
qq_45927819的博客
03-01 1074
CSRF的介绍以及利用方式一、什么是CRSF?二、利用GET请求方式的CSRF漏洞。2.1 场景介绍2.2 登陆2.3 CSRF漏洞利用2.4 CSRF漏洞触发2.5登陆管理员账号并验证三、利用POST请求方式的CSRF漏洞。 一、什么是CRSF? 跨站请求伪造（Cross-site request forgery），也被称为 one-click attack 或者 session riding，通常缩写为 CSRF 或者 XSRF， 是一种挟制用户在当前已登录的Web应用程序上执行非本意的操作的攻击方法
betaflight-crsf-tx-scripts:脚本集，通过CRSF从TX配置Betaflight
05-09
betaflight-crsf-tx-scripts 脚本集，用于通过CRSF从TX配置Betaflight。 支持的收音机 FrSky Taranis QX7，QX7S，X9D，X9D + 安装 升级到Betaflight 3.4（内部版本792或更高版本）。 将crsfdp.lua文件复制到crsfdp.lua上的/SCRIPTS/TELEMETRY/ crsfdp.lua /SCRIPTS/TELEMETRY/目录中。 配置您的遥控器以将脚本加载为“遥测”屏幕。 不支持从SD卡手动运行脚本，并且无法正常运行 加载遥测屏幕，CMS菜单应开始流式传输到您的遥控器。 指示 一旦将此脚本配置为遥测屏幕，就可以通过按住页面按钮来调用它。 该脚本将从FC请求菜单，从而使数据开始流式传输到您的发送器。 使用操纵杆导航菜单，而不是按钮或滚轮！ 该脚本的操作方式与OSD上CMS菜单的操作方式相同
跨站脚本 CRSF Unicode
09-10
Unicode Transformations:Finding Elusive Vulnerabilities Unicode Transformations Agenda Unicode crash course •Root Causes •Attack Vectors •Tools –Watcher –Unibomber
模型遥控器 CRSF 协议数据格式.zip
04-16
模型遥控器 CRSF 协议数据格式
模型遥控器 CRSF 协议数据格式.docx.zip
04-16
模型遥控器 CRSF 协议数据格式.docx
STM32 单片机 GPIO 的八种工作模式是什么？
qq_64919823的博客
04-28 979
GPIO、UART、SPI和I2C是STM32中常用的外设，它们为嵌入式系统的开发提供了丰富的功能和灵活性。了解这些外设的特性和应用可以帮助开发者更好地设计和实现STM32应用程序。
STM32中断之TIM定时器详解
最新发布
TENET123的博客
04-28 825
文章详细解释了STM32中断之TIM定时，并且包含代码示例。
stm32单片机开发一、中断之外部中断实验
qq_40170041的博客
04-27 612
stm32单片机的外部中断和定时器中断、ADC中断等都由stm32的内核中的NVIC模块控制，stm32的中断有很多中，比如供电不足中断，当供电不足时，会产生的一种中断，这么多中断如果都接在CPU上，或者说CPU去处理，一定会占用过多的资源，所以stm32单片机设计了NVIC去管理这些中断，NVIC有很多输入口，所有的中断都会进入NVIC，NVIC判断每个中断的优先级分配中断的先后顺序，最后将筛选出来的这个中断交给CPU去运行处理，这样CPU只需要去做处理就可以了。以下程序中所使用的是PB14的GPIO。
基于单片机的煤气泄漏报警系统设计
weixin_45905610的博客
04-27 912
本文设计了一种基于单片机控制的煤气泄漏检测报警系统，该系统以AT89S52单片机为核心，通过气敏电阻传感器MQ-7将采样到的 一氧化碳气体转换为电信号经处理后送给单片机，单片机对获取的信号进行分析，控制声光报警系统进行声光报警。该系统可以对室内空 气中的CO含量是否超标进行检测并报警，使人们及时发现险情，以防止煤气泄漏带来的不良后果。
crsf协议数据格式
07-26
CSRF（Cross-Site Request Forgery）是一种网络攻击方式，攻击者利用用户在已认证的网站上的身份，向其他网站发送恶意请求。为了防止CSRF攻击的发生，通常会使用CSRF协议来限制恶意请求。 CSRF协议的数据格式通常包含以下几个关键部分： 1. 随机生成的令牌：服务器会在用户进行身份认证时生成一个随机的令牌，将其与用户的会话相关联。这个令牌会以隐藏字段的形式嵌入到页面中，并在用户提交请求时一同发送到服务器。服务器在收到请求时会校验令牌的有效性，从而判断请求是否为合法请求。 2. 请求参数：除了令牌外，CSRF协议的数据格式还包含其他必要的请求参数，如操作类型、目标网址等。这些参数可以帮助服务器对请求进行合理的解析和响应。 3. 可选的附加信息：CSRF协议的数据格式还可以包含其他的附加信息，用于进一步验证请求的合法性。例如，可以包含用户的身份标识、操作时间戳等。 综上所述，CSRF协议的数据格式一般包含一个随机生成的令牌，用于验证请求的合法性，并携带其他必要的请求参数和可选的附加信息。通过在请求中加入这些数据，服务器可以有效地防止CSRF攻击的发生，并确保只有合法的请求被处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值