Ubuntu 如何在COOJA中禁用警告

我是Cooja的初学者，我正在运行一个简单的项目，使用Makefile作为

CONTIKI = /home/user/contiki-2.7
all: service_discovery_IoT.c    
include $(CONTIKI)/Makefile.include

C文件是

#include "contiki.h"
#include "net/rime.h"
#include "random.h"
#include "lib/memb.h"
#include "node-id.h"
#include "lib/list.h"
#include "net/rime.h"
#include <stdio.h>

struct service {
  struct service *next;
  rimeaddr_t service_provider;
  char service_name[15];
};

struct broadcast_message {
  char service_name[15];
  uint8_t seqno;
};

#define MAX_SERVICES 32

MEMB(services_memb, struct service, MAX_SERVICES);

LIST(services_list);

static struct broadcast_conn broadcast;
static struct unicast_conn unicast;

/*---------------------------------------------------------------------------*/
PROCESS(service_advertisement_process, "Service Advertisment for Internet of Things");
PROCESS(service_request_process, "Service Request for Internet of Things");
/*----------------------------------------------------------------------------*/
AUTOSTART_PROCESSES(&service_advertisement_process, &service_request_process);

/*---Broadcast functions ------------------------------------------------------*/
static void
broadcast_recv(struct broadcast_conn *c, const rimeaddr_t *from)
{
  struct broadcast_message *m;
  struct service *e;

  m = (struct broadcast_message *)packetbuf_dataptr();
  for(e = list_head(services_list); e != NULL; e = e->next) {
    if(rimeaddr_cmp(from, &e->service_provider)) {
        break;
    }
  }
  if(e==NULL)
  {
     e = memb_alloc(&services_memb);
     if(e == NULL)
      return;
      
     rimeaddr_copy(&e->service_provider, from);
     strcpy(e->service_name, m->service_name);
     list_add(services_list, e);
  }
  printf("Service advertisement received from %d.%d: '%s'\n",
    from->u8[0], from->u8[1], m->service_name);
}
static const struct broadcast_callbacks broadcast_call = {broadcast_recv};
static void
rec_req_srv(struct unicast_conn *c, const rimeaddr_t *from)
{
    printf("received service request from %d\n", from->u8[0]);
}

static const struct unicast_callbacks unicast_callbacks = {rec_req_srv};
PROCESS_THREAD(service_advertisement_process, ev, data)
{
  static struct etimer et;
  struct broadcast_message msg;
  static char m[15];
  
  int service_types = 3;

  PROCESS_EXITHANDLER(broadcast_close(&broadcast);)

  PROCESS_BEGIN();

  list_init(services_list);

  broadcast_open(&broadcast, 129, &broadcast_call);

  while(1) {

    /* Delay 2-4 seconds */
    etimer_set(&et, CLOCK_SECOND * 4 + random_rand() % (CLOCK_SECOND * 4));

    PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
    
    int nid = node_id;
    nid = nid%service_types;
    if(nid==0) 
       nid = service_types;
    char m[15] = "Service-";

    char dg[5];
    sprintf(dg, "%d", nid);
    strcat(m, dg);

    strcpy(msg.service_name, m);

    packetbuf_copyfrom(&msg, sizeof(struct broadcast_message));
    broadcast_send(&broadcast);
    printf("advertisement sent for %s\n", msg.service_name);
  }

  PROCESS_END();
}
/*------------------ Service Request---------------------------------------*/
PROCESS_THREAD(service_request_process, ev, data)
{
  char* req_service_name = "Service-2";

  PROCESS_EXITHANDLER(unicast_close(&unicast);)
    
  PROCESS_BEGIN();

  unicast_open(&unicast, 146, &unicast_callbacks);

  while(1) {
    static struct etimer et;
    struct service *n;

    etimer_set(&et, CLOCK_SECOND * 8 + random_rand() % (CLOCK_SECOND * 8));
    
    PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
    if(list_length(services_list) > 0) 
    {   
     struct service *selected_service;
     for(n = list_head(services_list); n != NULL; n = n->next) 
     {
        int cmp = strcmp(req_service_name, n->service_name);
        if(cmp == 0) {
            selected_service = n;
            printf("examined node %d (%s)\n", n->service_provider.u8[0], n->service_name);          
        }
     }
     if(selected_service != NULL)
     {
         printf("Sent request for (%s) to %d.%d\n", selected_service->service_name, selected_service->service_provider.u8[0], selected_service->service_provider.u8[1]);
         unicast_send(&unicast, &selected_service->service_provider);
     }
    } // end if
    else 
      printf("Service list is Empty.\n");
  }
  PROCESS_END();
}

#包括“contiki.h”
#包括“net/inite.h”
#包括“random.h”
#包括“lib/memb.h”
#包括“node-id.h”
#包括“lib/list.h”
#包括“net/inite.h”
#包括
结构服务{
结构服务*下一步；
rimeaddr服务提供商；
字符服务名称[15]；
};
结构广播消息{
字符服务名称[15]；
单元8_t亮片编号；
};
#定义MAX_服务32
MEMB（services\u MEMB、struct service、MAX\u services）；
清单（服务清单）；
静态结构广播\连接广播；
静态结构单播\连接单播；
/*---------------------------------------------------------------------------*/
流程（服务广告流程，“物联网服务广告”）；
流程（服务请求流程，“物联网服务请求”）；
/*----------------------------------------------------------------------------*/
自动启动流程（服务发布流程和服务请求流程）；
/*---广播功能------------------------------------------------------*/
静态空隙
广播接收（结构广播连接c，常数从）
{
结构广播消息*m；
结构服务*e；
m=（结构广播消息*）包buf_dataptr（）；
对于（e=list\u head（services\u list）；e！=NULL；e=e->next）{
if（rimeaddr\U cmp（来自，&e->服务提供商））{
打破
}
}
如果（e==NULL）
{
e=成员分配（和服务成员）；
如果（e==NULL）
返回；
rimeaddr_副本（&e->服务提供商，来自）；
strcpy（e->service\u name，m->service\u name）；
列表添加（服务列表，e）；
}
printf（“从%d.%d收到的服务广告：“%s”\n”，
from->u8[0]，from->u8[1]，m->service\u name）；
}
static const struct broadcast\u callbacks broadcast\u call={broadcast\u recv}；
静态空隙
记录请求srv（结构单播连接，常数从）
{
printf（“从%d\n收到服务请求”，从->u8[0]）；
}
静态const struct unicast_callbacks unicast_callbacks={rec_req_srv}；
进程线程（服务、广告、进程、ev、数据）
{
静态结构；
结构广播消息消息消息；
静态字符m[15]；
int服务类型=3；
进程_EXITHANDLER（广播_关闭（&broadcast）；）
进程_BEGIN（）；
列表初始（服务列表）；
广播开放（和广播、129和广播通话）；
而(1){
/*延迟2-4秒*/
etimer_集（&et，时钟秒*4+随机随机随机数（）%（时钟秒*4））；
进程等待事件直到（etimer过期（&et））；
int nid=节点id；
nid=nid%服务类型；
如果（nid==0）
nid=服务类型；
字符m[15]=“服务-”；
char-dg[5]；
sprintf（dg，“%d”，nid）；
strcat（m，dg）；
strcpy（msg.service_name，m）；
packetbuf_copyfrom（&msg，sizeof（struct broadcast_message））；
广播发送（和广播）；
printf（“为%s\n发送的广告”，消息服务\u名称）；
}
进程_END（）；
}
/*------------------服务请求---------------------------------------*/
进程线程（服务请求进程、ev、数据）
{
char*req\u service\u name=“service-2”；
进程_EXITHANDLER（单播_close（&unicast）；）
进程_BEGIN（）；
单播打开（单播、146和单播回调）；
而(1){
静态结构；
结构服务*n；
etimer_集（&et，时钟秒*8+随机随机数（）%（时钟秒*8））；
进程等待事件直到（etimer过期（&et））；
如果（列表长度（服务列表）>0）
{   
结构服务*所选的_服务；
对于（n=list\u head（services\u list）；n！=NULL；n=n->next）
{
int cmp=strcmp（请求服务名称，n->服务名称）；
如果（cmp==0）{
所选服务=n；
printf（“已检查节点%d（%s）\n”，n->service\u provider.u8[0]，n->service\u name）；
}
}
如果（所选服务！=NULL）
{
printf（“已将（%s）的请求发送到%d.%d\n”，选择了服务->服务名称，选择了服务->服务提供程序.u8[0]，选择了服务->服务提供程序.u8[1]）；
单播发送（单播和所选服务->服务提供商）；
}
}//如果结束，则结束
其他的
printf（“服务列表为空。\n”）；
}
进程_END（）；
}

在将其编译为skymote时，我收到的警告被视为错误

我的尝试

我在编译选项中添加了这个

同样的错误

我试着在contiki-2.7/cpu/msp430/makefile.msp430中这样做

我只找到一行带有

CFLAGSWERROR=-WERROR

的代码，我将其更改为

CFLAGSWERROR=-Wno ERROR

我在别处寻找解决办法，但找不到

我找不到任何额外的makefile，我不知道还能在哪里找到cflags等