TinyOS 点对基站通信

🕗 发布于 2024-10-10 12:46 开发语言

文章目录

一、前言
- 1.1 发包的BlinkToRadio的数据包格式
二、混淆基站源码分析

一、前言

1.1 发包的BlinkToRadio的数据包格式

如下，注意：AM层类型(1byte)即handlerID使可以在组件中修改的。
在这里插入图片描述

二、混淆基站源码分析

2.1 Makefile

COMPONENT=BaseStationC
CFLAGS += -DCC2420_NO_ACKNOWLEDGEMENTS
CFLAGS += -DCC2420_NO_ADDRESS_RECOGNITION
CFLAGS += -DTASKLET_IS_TASK
CFLAGS += -DCC2420_DEF_CHANNEL=14
include $(MAKERULES)

这里加多了几句，就可以监听同样信道中的消息

CFLAGS += -DCC2420_NO_ACKNOWLEDGEMENTS
这个表示不返回ACK
CFLAGS += -DCC2420_NO_ACKNOWLEDGEMENTS
表示不开启地址识别

CFLAGS += -DCC2420_NO_ACKNOWLEDGEMENTS
CFLAGS += -DCC2420_NO_ADDRESS_RECOGNITION
CFLAGS += -DTASKLET_IS_TASK

2.2 组件连接



configuration BaseStationC {
}
implementation {
  components MainC, BaseStationP, LedsC;
  components SerialActiveMessageC as Serial;
  
  MainC.Boot <- BaseStationP;

  BaseStationP.RadioControl -> Radio;
  BaseStationP.SerialControl -> Serial;
  
  BaseStationP.UartSend -> Serial;
  BaseStationP.UartReceive -> Serial.Receive;
  BaseStationP.UartPacket -> Serial;
  BaseStationP.UartAMPacket -> Serial;
  
  //radio
  components ActiveMessageC as Radio
  BaseStationP.RadioSend -> Radio;
  BaseStationP.RadioReceive -> Radio.Receive;
  BaseStationP.RadioSnoop -> Radio.Snoop;
  BaseStationP.RadioPacket -> Radio;
  BaseStationP.RadioAMPacket -> Radio;
  
  BaseStationP.Leds -> LedsC;
}

BaseStationP.RadioSnoop -> Radio.Snoop;
通过这个接口去拿监听的包

2.3 主逻辑代码


#include "AM.h"
#include "Serial.h"

module BaseStationP @safe() {
  uses {
    interface Boot;
    interface SplitControl as SerialControl;
    interface SplitControl as RadioControl;

    interface AMSend as UartSend[am_id_t id];
    interface Receive as UartReceive[am_id_t id];
    interface Packet as UartPacket;
    interface AMPacket as UartAMPacket;
    
    interface AMSend as RadioSend[am_id_t id];
    interface Receive as RadioReceive[am_id_t id];
    interface Receive as RadioSnoop[am_id_t id];
    interface Packet as RadioPacket;
    interface AMPacket as RadioAMPacket;

    interface Leds;
  }
}

implementation
{
  enum {
    UART_QUEUE_LEN = 12,
    RADIO_QUEUE_LEN = 12,
  };

  message_t  uartQueueBufs[UART_QUEUE_LEN];
  message_t  * ONE_NOK uartQueue[UART_QUEUE_LEN];
  uint8_t    uartIn, uartOut;
  bool       uartBusy, uartFull;

  message_t  radioQueueBufs[RADIO_QUEUE_LEN];
  message_t  * ONE_NOK radioQueue[RADIO_QUEUE_LEN];
  uint8_t    radioIn, radioOut;
  bool       radioBusy, radioFull;

  task void uartSendTask();
  task void radioSendTask();

  void dropBlink() {
    call Leds.led2Toggle();
  }

  void failBlink() {
    call Leds.led2Toggle();
  }

  event void Boot.booted() {
    uint8_t i;

    for (i = 0; i < UART_QUEUE_LEN; i++)
      uartQueue[i] = &uartQueueBufs[i];
    uartIn = uartOut = 0;
    uartBusy = FALSE;
    uartFull = TRUE;

    for (i = 0; i < RADIO_QUEUE_LEN; i++)
      radioQueue[i] = &radioQueueBufs[i];
    radioIn = radioOut = 0;
    radioBusy = FALSE;
    radioFull = FALSE;

    call RadioControl.start();
    call SerialControl.start();
  }

  event void RadioControl.startDone(error_t error) {
    if (error == SUCCESS) {
      radioFull = FALSE;
    }
  }

  event void SerialControl.startDone(error_t error) {
    if (error == SUCCESS) {
      uartFull = FALSE;
    }
  }

  event void SerialControl.stopDone(error_t error) {}
  event void RadioControl.stopDone(error_t error) {}

  uint8_t count = 0;

  message_t* ONE receive(message_t* ONE msg, void* payload, uint8_t len);
  
  event message_t *RadioSnoop.receive[am_id_t id](message_t *msg,
    void *payload,
    uint8_t len) {
    return receive(msg, payload, len);
  }
  
  event message_t *RadioReceive.receive[am_id_t id](message_t *msg,
    void *payload,
    uint8_t len) {
    return receive(msg, payload, len);
  }

  message_t* receive(message_t *msg, void *payload, uint8_t len) {
    message_t *ret = msg;

    atomic {
      if (!uartFull)
{
  ret = uartQueue[uartIn];
  uartQueue[uartIn] = msg;

  uartIn = (uartIn + 1) % UART_QUEUE_LEN;

  if (uartIn == uartOut)
    uartFull = TRUE;

  if (!uartBusy)
    {
      post uartSendTask();
      uartBusy = TRUE;
    }
}
      else
dropBlink();
    }
    
    return ret;
  }

  uint8_t tmpLen;
  
  task void uartSendTask() {
    uint8_t len;
    am_id_t id;
    am_addr_t addr, src;
    message_t* msg;
    atomic
      if (uartIn == uartOut && !uartFull)
{
  uartBusy = FALSE;
  return;
}

    msg = uartQueue[uartOut];
    tmpLen = len = call RadioPacket.payloadLength(msg);
    id = call RadioAMPacket.type(msg);
    addr = call RadioAMPacket.destination(msg);
    src = call RadioAMPacket.source(msg);
    call UartPacket.clear(msg);
    call UartAMPacket.setSource(msg, src);

    if (call UartSend.send[id](addr, uartQueue[uartOut], len) == SUCCESS)
      call Leds.led1Toggle();
    else
      {
failBlink();
post uartSendTask();
      }
  }

  event void UartSend.sendDone[am_id_t id](message_t* msg, error_t error) {
    if (error != SUCCESS)
      failBlink();
    else
      atomic
if (msg == uartQueue[uartOut])
  {
    if (++uartOut >= UART_QUEUE_LEN)
      uartOut = 0;
    if (uartFull)
      uartFull = FALSE;
  }
    post uartSendTask();
  }

  event message_t *UartReceive.receive[am_id_t id](message_t *msg,
   void *payload,
   uint8_t len) {
    message_t *ret = msg;
    bool reflectToken = FALSE;

    atomic
      if (!radioFull)
{
  reflectToken = TRUE;
  ret = radioQueue[radioIn];
  radioQueue[radioIn] = msg;
  if (++radioIn >= RADIO_QUEUE_LEN)
    radioIn = 0;
  if (radioIn == radioOut)
    radioFull = TRUE;

  if (!radioBusy)
    {
      post radioSendTask();
      radioBusy = TRUE;
    }
}
      else
dropBlink();

    if (reflectToken) {
      //call UartTokenReceive.ReflectToken(Token);
    }
    
    return ret;
  }

  task void radioSendTask() {
    uint8_t len;
    am_id_t id;
    am_addr_t addr,source;
    message_t* msg;
    
    atomic
      if (radioIn == radioOut && !radioFull)
{
  radioBusy = FALSE;
  return;
}

    msg = radioQueue[radioOut];
    len = call UartPacket.payloadLength(msg);
    addr = call UartAMPacket.destination(msg);
    source = call UartAMPacket.source(msg);
    id = call UartAMPacket.type(msg);

    call RadioPacket.clear(msg);
    call RadioAMPacket.setSource(msg, source);
    
    if (call RadioSend.send[id](addr, msg, len) == SUCCESS)
      call Leds.led0Toggle();
    else
      {
failBlink();
post radioSendTask();
      }
  }

  event void RadioSend.sendDone[am_id_t id](message_t* msg, error_t error) {
    if (error != SUCCESS)
      failBlink();
    else
      atomic
if (msg == radioQueue[radioOut])
  {
    if (++radioOut >= RADIO_QUEUE_LEN)
      radioOut = 0;
    if (radioFull)
      radioFull = FALSE;
  }
    
    post radioSendTask();
  }
}

步骤如下：

上电开机后
1.1 初始化队列
1.2 开启无线控制器call RadioControl.start();
1.3 开启串口控制器call SerialControl.start();
编写接收窃听到的包的回调函数
2.1 通过串口把数据输出

event message_t *RadioSnoop.receive[am_id_t id](message_t *msg, void *payload,uint8_t len) 
{
    return receive(msg, payload, len);
}

原文地址：https://blog.csdn.net/weixin_43871650/article/details/109698801

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：git merge 之提交分支远程合并后再同步本地合并时冲突
下一篇：Android App系统签名

成为一名厉害的黑客，必须知道的12个步骤，黑客入门
与许多较老的UNIX书籍不同，这是一本相对较新的Linux书籍，这本书是由Michael Kerrisk编写的，他是Linux手册的维护成员之一，与许多作者一样，他从1987年开始研究UNIX，并从2
阅读更多2024-10-10
麒麟桌面版v10 SP1以docker方式安装达梦数据库
的构建版本信息：使用的是麒麟（Kylin）桌面版系统，具体版本为Kylin-Desktop V10-SP1-hwe，构建日期为2021年8月20日。直接 GitHub 下载：docker/compos
阅读更多2024-10-10
【Unity游戏开发】PlayerInput最佳实践，自动生成actions代码
新输入系统主要有两种方式，一种是全局的InputActions直接用new获取另一种是在组件上挂载PlayerInpput，好处是可以区分不同玩家，精细的禁用单个行为，但是使用比较麻烦最重要的还是要用
阅读更多2024-10-10
ubuntu 18.04虚拟机以太网网段与地平线J6板端连接配置
板端ip可以ping通，同时联网也可以。选择自动获取IP地址。
阅读更多2024-10-10
k8s部署学习
8s的架构一个kubernetes集群主要是由控制节点(master)、工作节点(node)构成，每个节点上都会安装不同的组件1 master：集群的控制平面，负责集群的决策ApiServer : 资
阅读更多2024-10-10
【技术支持】家里智能电视不能联网重置小米路由器之路
本文记录了由于家庭中小米盒子网络问题，进而引发使用小米路由器重置网络的一系列操作
阅读更多2024-10-10
python 自学总结
位置传递的不定长， def 函数名（*args）: 传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，args是元组的类型，这就是位置传递。# 关键字传递的不定长 de
阅读更多2024-10-10
JavaScript 第2章基本语法
通过这些示例，读者可以更好地理解JavaScript的基本语法，并学会如何在实际的业务场景中应用这些语法。通过这些示例，读者可以进一步理解JavaScript中的变量声明、数据类型、运算符以及语句的使
阅读更多2024-10-10
java内置的四种函数式接口
四种内置函数式接口
阅读更多2024-10-10
系统移植二和网卡移植实验和私有驱动LED的移植
驱动文件的集成：通过修改 Kconfig 和 Makefile 文件，将驱动集成到内核中，并在 menuconfig 中显示配置项。驱动的编译方式：可以选择将驱动编译到内核中（内建）或编译为模块（动态
阅读更多2024-10-10