设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › MCU综合技术区 › STM32 wifi无线遥控器设计 在网页端控制单片机LED的亮灭
返回列表 发新帖
查看: 5727|回复: 0
打印 上一主题 下一主题
收起左侧

STM32 wifi无线遥控器设计 在网页端控制单片机LED的亮灭

[复制链接]
跳转到指定楼层
楼主
ID:288604 发表于 2018-3-7 11:20 | 显示全部楼层 |只看大图 回帖奖励 |倒序浏览 |阅读模式
无线遥控器设计的课程作业
简化的设计，在网页端控制开发板LED的亮灭。
使用udp传输协议，可以较好的穿透内网，
实现端端之间的直接通信。




STM32MARVELL88芯片主控

单片机源程序如下:
  1. #define DEBUG
  2. #include "drivers.h"
  3. #include "app.h"
  4. #include "api.h"

  6. #include "cfg80211.h"
  7. #include "defs.h"
  8. #include "type.h"
  9. #include "types.h"

  11. #include "moal_sdio.h"
  12. #include "lwip/pbuf.h"
  13. #include "lwip/sys.h"
  14. #include "wpa.h"

  16. #include "moal_main.h"
  17. #include "moal_uap.h"
  18. #include "moal_uap_priv.h"
  19. #include "mlan_ioctl.h"

  21. #include "oled.h"

  23. /*
  24. *分为station和ap两个设备,其接口函数是不一样的
  25. *所以在不同的模式下我们选择相对应的设备进行操作
  26. *wifi_dev指向当前设备
  27. */
  28. struct net_device *sta_wifi_dev = NULL;
  29. struct net_device *ap_wifi_dev = NULL;
  30. struct net_device *direct_wifi_dev = NULL;

  32. struct net_device *wifi_dev = NULL;

  34. struct net_device *get_wifi_dev()
  35. {
  36.         return wifi_dev;
  37. }

  39. int is_hw_ok()
  40. {
  41.         return wifi_dev?1:0;
  42. }

  44. /**
  45. * @brief  设置wifi模式,只是切换模式,不对ap参数进行配置
  46. * @param  type : MODE_AP, MODE_STATION, MODE_ADHOC
  47. * @retval ok: 0, err: -1
  48. */
  49. int wifi_set_mode(int type)
  50. {
  51.         int ret = -1;
  52.         int set_type;
  53.         moal_private *priv;
  54.         struct net_device *saved_dev = wifi_dev;

  56.         priv = (moal_private *)wifi_dev->ml_priv;
  57.         //暂不支持ap+sta同时存在，切换模式前先关闭wifi
  58.         if(priv->bss_role == MLAN_BSS_ROLE_UAP)
  59.                 wifi_stop_ap();
  60.         else
  61.                 wifi_disconnect();
  62.         if(0)
  63.                 ;
  64. #ifdef UAP_SUPPORT               
  65.         else if(type == MODE_AP){
  66.                 set_type = NL80211_IFTYPE_AP;
  67.                 wifi_dev = ap_wifi_dev;
  68.                 OLED_ShowString(16,2,"  MODE:AP   ");
  69.                 OLED_ShowString(0,0,"IP:");
  70.                 OLED_ShowString(24,0,"192.168.1.8");
  71.                 p_dbg("IP:192.168.1.8");
  72.         }
  73. #endif
  74. #ifdef STA_SUPPORT       
  75.         else if(type == MODE_STATION){
  76.                 wifi_dev = sta_wifi_dev;
  77.                 set_type = NL80211_IFTYPE_STATION;
  78.                 OLED_ShowString(16,2,"MODE:STATION");
  79.         }

  81.         else if(type == MODE_ADHOC){
  82.                 wifi_dev = sta_wifi_dev;
  83.                 set_type = NL80211_IFTYPE_ADHOC;
  84.                 OLED_ShowString(16,2," MODE:ADHOC ");
  85.         }
  86. #endif
  87. #ifdef WIFI_DIRECT_SUPPORT       
  88.         else if(type == MODE_P2P_GO){
  89.                 wifi_dev = direct_wifi_dev;
  90.                 set_type = NL80211_IFTYPE_P2P_GO;
  91.         }
  92.         else if(type == MODE_P2P_GC){
  93.                 wifi_dev = direct_wifi_dev;
  94.                 set_type = NL80211_IFTYPE_P2P_CLIENT;
  95.         }
  96. #endif
  97.         else{
  98.                 p_err("type %d not support", type);
  99.                 return -1;
  100.         }

  102.         if(wifi_dev == NULL){
  103.                
  104.                 wifi_dev = saved_dev;
  105.                 p_err("%s not support", __FUNCTION__);
  106.                 return -1;
  107.         }

  109.         if(wifi_dev->cfg80211_ops->change_virtual_intf){
  110.                 priv = (moal_private *)wifi_dev->ml_priv;

  112.                 //ap和sta指向相同的change_virtual_intf
  113.                 ret = wifi_dev->cfg80211_ops->change_virtual_intf(priv->wdev->wiphy, wifi_dev, (enum nl80211_iftype)set_type, 0, 0);
  114.                 if(ret != 0)
  115.                 {
  116.                         wifi_dev = saved_dev;
  117.                 }
  118.         }else
  119.                 p_err("%s not support", __FUNCTION__);

  121.         return ret;
  122. }


  125. /**
  126. * @brief  设置硬件的多播、广播、混杂模式
  127. * @param  flags :  IFF_PROMISC        接收所有的包
  128.                                 IFF_ALLMULTI 接收所有的多播包(暂时采用接收所有多播报的简单方式，
  129.                                 不处理多播地址表)

  131. * @retval ok: 0, err: -1
  132. */
  133. int wifi_set_multicast(uint32_t flags)
  134. {
  135.         if(!wifi_dev)
  136.                 return -1;
  137.        
  138.         wifi_dev->flags |= flags;

  140.         if(wifi_dev->netdev_ops && wifi_dev->netdev_ops->ndo_set_multicast_list)
  141.                 wifi_dev->netdev_ops->ndo_set_multicast_list(wifi_dev);
  142.        
  143.         return 0;
  144. }


  147. /**
  148. * @brief  设置为混杂模式
  149. * @param  
  150. * @retval ok: 0, err: -1
  151. */
  152. int wifi_set_promisc()
  153. {
  154.         return wifi_set_multicast(IFF_PROMISC);
  155. }


  158. /**
  159. * @brief  设置wifi频道,for ap
  160. * @param  channel : 1 - 14
  161. * @retval ok: 0, err: -1
  162. */
  163. int wifi_set_channel(int channel)
  164. {
  165.         int ret = -1;
  166.         struct ieee80211_channel ch;
  167.         moal_private *priv;

  169.         //sta和ap的cfg80211_ops接口是不一样的,必须检查其成员是否有效,下同
  170.         if(wifi_dev->cfg80211_ops->set_channel){
  171.                 priv = (moal_private *)wifi_dev->ml_priv;

  173.                 memset(&ch, 0, sizeof(struct ieee80211_channel));
  174.                 ch.hw_value = channel;
  175.                 ch.band = IEEE80211_BAND_2GHZ;
  176.                 ch.center_freq = ieee80211_channel_to_frequency(ch.hw_value, ch.band);
  177.                
  178.                 //ap和sta指向相同的change_virtual_intf
  179.                 ret = wifi_dev->cfg80211_ops->set_channel(priv->wdev->wiphy, wifi_dev, &ch, NL80211_CHAN_NO_HT);
  180.         }else
  181.                 p_err("%s not support", __FUNCTION__);
  182.        
  183.         return ret;
  184. }


  187. /**
  188. * @brief  设置wifi模式为AP参数
  189. *
  190. * @param  name : 网络名称
  191. * @param  key:密码
  192. * @param  key_type:加密模式,可选参数KEY_NONE, KEY_WEP,KEY_WPA,KEY_WPA2
  193. * @param  channel:频道
  194. * @param  max_client:最大允许客户端数量,1 - MAX_STA_COUNT(SDK预设为10)
  195. *
  196. * @retval ok: 0, err: -1
  197. */
  198. int wifi_ap_cfg(char *name, char *key, int key_type, int channel, int max_client)
  199. {
  200.         int ret = -1;
  201.         char str_tmp[64];
  202.         /* example
  203.         char *cmd = "ASCII_CMD=AP_CFG,"\
  204.         "SSID=QWERT,"\
  205.         "SEC=wep128,"\
  206.         "KEY=12345,"\
  207.         "CHANNEL=8,"\
  208.         "MAX_SCB=4,"\
  209.         "END";
  210.         */

  212.         //配置ap参数我们没有使用cfg80211_ops提供的, 而是使用更简单的netdev_ops接口
  213.         //netdev_ops接口比较丰富,这里做一个参考
  214.         if(wifi_dev->netdev_ops && wifi_dev->netdev_ops->ndo_do_ioctl)
  215.         {
  216.                 struct iwreq *wrq = (struct iwreq *)mem_calloc(256, 1);

  218.                 if(!wrq)
  219.                         return ret;
  220.                
  221.                 wrq->u.data.pointer = wrq + 1;
  222.                 strcpy(wrq->u.data.pointer, "ASCII_CMD=AP_CFG,");

  224.                 snprintf(str_tmp, 64, "SSID=%s,", name);
  225.                 strcat(wrq->u.data.pointer, str_tmp);

  227.                 if (key_type == KEY_NONE)
  228.                         strcpy(str_tmp, "SEC=open,");
  229.                 else if (key_type == KEY_WEP)
  230.                         strcpy(str_tmp, "SEC=wep128,");
  231.                 else if (key_type == KEY_WPA)
  232.                         strcpy(str_tmp, "SEC=wpa-psk,");
  233.                 else if (key_type == KEY_WPA2)
  234.                         strcpy(str_tmp, "SEC=wpa2-psk,");
  235.                 else
  236.                         strcpy(str_tmp, "SEC=open,");
  237.                
  238.                 strcat(wrq->u.data.pointer, str_tmp);

  240.                 snprintf(str_tmp, 64, "KEY=%s,", key);
  241.                 strcat(wrq->u.data.pointer, str_tmp);

  243.                 snprintf(str_tmp, 64, "CHANNEL=%d,", channel);
  244.                 strcat(wrq->u.data.pointer, str_tmp);

  246.                 snprintf(str_tmp, 64, "MAX_SCB=%d,", max_client);
  247.                 strcat(wrq->u.data.pointer, str_tmp);

  249.                 strcat(wrq->u.data.pointer, "END");

  251.                 wrq->u.data.length = strlen(wrq->u.data.pointer);
  252.                
  253.                 ret = wifi_dev->netdev_ops->ndo_do_ioctl(wifi_dev, (void*)wrq, WOAL_UAP_FROYO_AP_SET_CFG);
  254.                 if(ret == 0)
  255.                         ret = wifi_dev->netdev_ops->ndo_do_ioctl(wifi_dev, 0, WOAL_UAP_FROYO_AP_BSS_START);

  257.                 mem_free(wrq);

  259.         }else
  260.                 p_err("%s not support", __FUNCTION__);
  261.        
  262.         return ret;
  263. }


  266. int wifi_stop_ap()
  267. {
  268.         int ret = -1;
  269.        
  270.         if(wifi_dev->netdev_ops && wifi_dev->netdev_ops->ndo_do_ioctl)
  271.         {
  272.                 ret = wifi_dev->netdev_ops->ndo_do_ioctl(wifi_dev, 0, WOAL_UAP_FROYO_AP_BSS_STOP);
  273.         }
  274.         return ret;
  275. }


  278. /**
  279. * @brief
  280. */
  281. int wifi_join_adhoc(char *ssid, char *key, int ch)
  282. {
  283.         int ret = -1;
  284.         moal_private *priv;
  285.         struct cfg80211_ibss_params params;
  286.         struct ieee80211_channel channel;
  287.         int key_len = strlen(key);
  288.        
  289.         memset(¶ms, 0, sizeof(struct cfg80211_ibss_params));
  290.         memset(&channel, 0 ,sizeof(struct ieee80211_channel));

  292.         params.channel = &channel;
  293.        
  294.         params.beacon_interval = 100;
  295.         params.ssid = (u8*)ssid;
  296.         params.ssid_len = strlen(ssid);
  297.         params.channel_fixed = TRUE;
  298.         params.channel->band = IEEE80211_BAND_2GHZ;
  299.         params.channel->hw_value = ch;
  300.         params.channel->center_freq = ieee80211_channel_to_frequency(params.channel->hw_value,
  301.                 params.channel->band);
  302.         if(key_len)
  303.         {
  304.                 params.key = key;
  305.                 params.key_len = key_len;
  306.                 params.privacy = TRUE;        //使能wep加密
  307.         }
  308.        
  309.         priv = (moal_private *)wifi_dev->ml_priv;
  310.         if(wifi_dev->cfg80211_ops && wifi_dev->cfg80211_ops->join_ibss)
  311.         {
  312.                 ret = wifi_dev->cfg80211_ops->join_ibss(priv->wdev->wiphy, wifi_dev, ¶ms);

  314.         }else
  315.                 p_err("%s not support", __FUNCTION__);
  316.        
  317.         return ret;
  318. }


  321. int wifi_leave_adhoc()
  322. {
  323.         int ret = -1;
  324.         moal_private *priv;
  325.        
  326.         priv = (moal_private *)wifi_dev->ml_priv;
  327.         if(wifi_dev->cfg80211_ops && wifi_dev->cfg80211_ops->leave_ibss)
  328.         {
  329.                 ret = wifi_dev->cfg80211_ops->leave_ibss(priv->wdev->wiphy, wifi_dev);

  331.         }else
  332.                 p_err("%s not support", __FUNCTION__);
  333.        
  334.         return ret;
  335. }

  337. #ifdef UAP_SUPPORT
  338. int wifi_get_sta_list(mlan_ds_sta_list *p_list)
  339. {
  340.         int ret = -1;
  341.        
  342.         if(wifi_dev->netdev_ops && wifi_dev->netdev_ops->ndo_do_ioctl)
  343.         {
  344.                 struct iwreq *wrq = (struct iwreq *)mem_calloc(sizeof(struct iwreq), 1);
  345.                 if(wrq)
  346.                 {
  347.                         wrq->u.data.pointer = p_list;
  348.                
  349.                         ret = wifi_dev->netdev_ops->ndo_do_ioctl(wifi_dev, (void*)wrq, UAP_GET_STA_LIST);

  351.                         mem_free(wrq);
  352.                 }
  353.                
  354.         }else
  355.                 p_err("%s not support", __FUNCTION__);
  356.        
  357.         return ret;
  358.        
  359. }
  360. #endif

  362. struct cfg80211_scan_request *new_scan_req(moal_private *priv, char *ssid, u8_t ssid_len)
  363. {
  364.         struct wiphy *wiphy = priv->wdev->wiphy;
  365.         struct cfg80211_scan_request *creq = NULL;
  366.         int i, n_channels = 0;
  367.         enum ieee80211_band band;

  369.         for (band = (enum ieee80211_band)0; band < IEEE80211_NUM_BANDS; band++) {
  370.                 if (wiphy->bands[band])
  371.                         n_channels += wiphy->bands[band]->n_channels;
  372.         }

  374.         p_dbg("_new_connect_scan_req,channels:%d,creq_size:%d\n",n_channels,sizeof(*creq) + sizeof(struct cfg80211_ssid) +
  375.                        n_channels * sizeof(void *));
  376.         creq = (struct cfg80211_scan_request *)mem_calloc(sizeof(*creq) + sizeof(struct cfg80211_ssid) +
  377.                        n_channels * sizeof(void *),1);
  378.         if (!creq)
  379.                 return NULL;
  380.         /* SSIDs come after channels */
  381.         creq->wiphy = wiphy;
  382.         creq->ssids = (void *)&creq->channels[n_channels];
  383.         creq->n_channels = n_channels;
  384.         if(ssid_len)
  385.                 creq->n_ssids = 1;

  387.         /* Scan all available channels */
  388.         i = 0;
  389.         for (band = (enum ieee80211_band)0; band < IEEE80211_NUM_BANDS; band++) {
  390.                 int j;

  392.                 if (!wiphy->bands[band])
  393.                         continue;

  395.                 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
  396.                         /* ignore disabled channels */
  397.                         if (wiphy->bands[band]->channels[j].flags &
  398.                                                 IEEE80211_CHAN_DISABLED)
  399.                                 continue;

  401.                         creq->channels[i] = &wiphy->bands[band]->channels[j];
  402.                         i++;
  403.                 }
  404.         }
  405.         if (i) {
  406.                 /* Set real number of channels specified in creq->channels[] */
  407.                 creq->n_channels = i;

  409.                 /* Scan for the SSID we're going to connect to */
  410.                 memcpy(creq->ssids[0].ssid, ssid, ssid_len);
  411.                 creq->ssids[0].ssid_len = ssid_len;
  412.         } else {
  413.                 /* No channels found... */
  414.                 mem_free(creq);
  415.                 creq = NULL;
  416.         }

  418.         return creq;
  419. }


  422. /**
  423. * @brief  扫描附近的AP,usr_scan_result_callback是我们自定义的一个回调接口
  424. *                每扫描到一个ap就会在wlan_ret_802_11_scan->handle_user_scan_result调用一次,其参数scan_result_data包含一些基本
  425. *                的ap信息,一般已经够用,如果要更详细的ap的信息请直接在handle_user_scan_result里面取
  426. * @param
  427. * @retval ok: 0, err: -1
  428. */
  429. extern void (*usr_scan_result_callback)(struct scan_result_data *res_data);

  431. int wifi_scan(void (*scan_result_callback)(struct scan_result_data *res_data),
  432.                 char *essid)
  433. {
  434.         moal_private *priv;
  435.         struct cfg80211_scan_request *scan_request;
  436.        
  437.         if(!wifi_dev)
  438.                 return -1;
  439.         priv = (moal_private *)wifi_dev->ml_priv;

  441.         if(priv->bss_role == MLAN_BSS_ROLE_UAP)
  442.         {
  443.                 p_err("AP模式下不支持scan，请先切换到STA模式");
  444.                 return 0;
  445.         }
  446.        
  447.         usr_scan_result_callback = scan_result_callback;
  448.         scan_request = new_scan_req(priv, essid, strlen(essid));
  449.         wifi_dev->cfg80211_ops->scan(priv->wdev->wiphy, wifi_dev, scan_request);

  451.         //scan是异步实现的,这里调用完会马上退出
  452.         //扫描完成后驱动会自动调用cfg80211_scan_done函数

  454.         return 0;
  455. }


  458. /**
  459. * @brief  wifi 是否已经连接
  460. *
  461. */
  462. int is_wifi_connected()
  463. {

  465.         int ret = 0;
  466.         moal_private *priv;
  467.         priv = (moal_private *)wifi_dev->ml_priv;
  468.        
  469.         if(priv->media_connected)
  470.                 ret = 1;

  472.         return ret;
  473. }

  475. /**
  476. * @brief  wifi连接,驱动自动处理加密模式和频道,用户只需提供路由器名称和密码
  477. * @param
  478. *                                                       
  479. *                essid: 即AP名称
  480. *                key: 明文密码       
  481. * @retval ok: 0, err: -1
  482. */
  483. int wifi_connect( char *essid, char *key)
  484. {

  486.         int result_ret = 0;
  487.         moal_private *priv;
  488.         int essid_len = strlen(essid);
  489.         int key_len = strlen(key);
  490.         struct cfg80211_connect_params *smee = 0;
  491.        
  492.         p_dbg("enter %s\n", __FUNCTION__);
  493.         OLED_ShowString(0,4,"SSID:");
  494.         OLED_ShowString(0,6,"KEY:");

  496.         OLED_ShowString(48,4,(u8 *)essid);
  497.         OLED_ShowString(48,6,(u8 *)key);

  499.         if(essid_len > 32 || key_len > 32)
  500.         {
  501.                 result_ret = -1;
  502.                 goto ret;
  503.         }
  504.         smee = (struct cfg80211_connect_params *)mem_malloc(sizeof(struct cfg80211_connect_params));
  505.         if(smee == 0)
  506.         {
  507.                 result_ret = -1;
  508.                 goto ret;
  509.         }

  511.         priv = (moal_private *)wifi_dev->ml_priv;
  512.         memset(smee,0,sizeof(struct cfg80211_connect_params));
  513.         smee->bssid = 0;
  514.        
  515.         memcpy(smee->ssid,essid,essid_len);
  516.         smee->ssid[essid_len] = 0;
  517.        
  518.         smee->ssid_len = essid_len;
  519.        
  520.         memcpy(smee->key,key,key_len);
  521.         smee->key[key_len] = 0;
  522.        
  523.         smee->key_len = key_len;
  524.         smee->auth_type = NL80211_AUTHTYPE_AUTOMATIC;
  525.         smee->crypto.wpa_versions = NL80211_WPA_VERSION_2;
  526.         smee->crypto.cipher_group = MLAN_ENCRYPTION_MODE_CCMP;
  527.         smee->crypto.n_ciphers_pairwise = 1;
  528.         smee->crypto.ciphers_pairwise[0] = MLAN_ENCRYPTION_MODE_CCMP;

  530. /*
  531. *smee结构只填充了部分成员，其他成员将在连接的时候自动填充(根据目标ap的信息)
  532. */
  533.        
  534.         result_ret = wifi_dev->cfg80211_ops->wifi_connect(priv->wdev->wiphy, wifi_dev,smee);
  535. ret:
  536.         if(smee)
  537.                 mem_free(smee);
  538.         if(result_ret)
  539.                 p_err("user_link_app err:%d\n",result_ret);

  541.         p_dbg("exit %s\n", __FUNCTION__);
  542.        
  543.         return result_ret;
  544. }

  546. /**
  547. * @brief  断开连接
  548. */
  549. int wifi_disconnect()
  550. {
  551.         int ret = -1;
  552.         moal_private *priv;
  553.        
  554.         priv = (moal_private *)wifi_dev->ml_priv;
  555.         if(wifi_dev->cfg80211_ops && wifi_dev->cfg80211_ops->disconnect)
  556.         {
  557.                 ret = wifi_dev->cfg80211_ops->disconnect(priv->wdev->wiphy, wifi_dev, 0);

  559.         }else
  560.                 p_err("%s not support", __FUNCTION__);
  561.        
  562.        
  563.         return ret;
  564. }


  567. /**
  568. * @brief  读取mac地址，mac地址从8782芯片读取
  569. * @param  mac_addr : mac地址 6BYTE
  570. */
  571. int wifi_get_mac(unsigned char *mac_addr)
  572. {
  573.        
  574.         memcpy(mac_addr, wifi_dev->dev_addr, ETH_ALEN);
  575.         return 0;
  576. }


  579. /**
  580. * @brief  获取WIFI连接的统计信息(信号强度...)
  581. * @param  pStats : 指向station_info的指针
  582. * @param  mac : 指向需要获取的station的地址
  583. */
  584. int wifi_get_stats(uint8_t *mac,struct station_info *sinfo)
  585. {
  586.         int ret = -1;
  587.         moal_private *priv;
  588.        
  589.         priv = (moal_private *)wifi_dev->ml_priv;
  590.         if(wifi_dev->cfg80211_ops && wifi_dev->cfg80211_ops->get_station)
  591.         {
  592.                 ret = wifi_dev->cfg80211_ops->get_station(priv->wdev->wiphy, wifi_dev, mac,sinfo);

  594.         }else
  595.                 p_err("%s not support", __FUNCTION__);
  596.        
  597.         return ret;
  598. }

  600. /**
  601. * @brief  配置省电模式,在保持连接的情况下可达到很可观省电效果
  602. *                省电模式下的耗电量由数据收发量决定
  603. *                此外用户可以配置更加细节的电源管理参数,比如DTIM间隔
  604. *                一般情况下使用此函数已经够用
  605. *
  606. * @param  power_save_level : 取值 0,1,2;
  607. *        0代表关闭省电模式(CAM)
  608. *        1采用DTIM省电方式
  609. *    2采用INACTIVITY省电方式
  610. * @param  mac : 指向需要获取的station的地址
  611. */
  612. int wifi_power_cfg(uint8_t power_save_level)
  613. {
  614.         int ret = -1;
  615.         moal_private *priv;

  617.         priv = (moal_private *)wifi_dev->ml_priv;
  618.         if(priv->bss_role == MLAN_BSS_ROLE_UAP)
  619.         {
  620.                 if(wifi_dev->netdev_ops && wifi_dev->netdev_ops->ndo_do_ioctl)
  621.                 {
  622.                         struct iwreq *wrq = (struct iwreq *)mem_calloc(sizeof(struct iwreq), 1);
  623.                         if(wrq)
  624.                         {
  625.                                 /*
  626.                                 if(sleep)
  627.                                 {
  628.                                         deep_sleep_para param;
  629.                                         memset(¶m, 0, sizeof(deep_sleep_para));
  630.                                         wrq->u.data.pointer = ¶m;
  631.                                         param.subcmd = UAP_DEEP_SLEEP;
  632.                                         param.action = MLAN_ACT_SET;
  633.                                         param.deep_sleep = TRUE;
  634.                                         param.idle_time = 1000;
  635.                                         ret = wifi_dev->netdev_ops->ndo_do_ioctl(wifi_dev, (void*)wrq, UAP_IOCTL_CMD);
  636.        
  637.                                 }else
  638.                                 */
  639.                                 {
  640.                                         mlan_ds_ps_mgmt ps_mgmt;

  642.                                         memset(&ps_mgmt, 0, sizeof(mlan_ds_ps_mgmt));
  643.                                         wrq->u.data.pointer = &ps_mgmt;

  645.                                         ps_mgmt.flags = PS_FLAG_PS_MODE;
  646.                                         if(power_save_level == 0)
  647.                                                 ps_mgmt.ps_mode = PS_MODE_DISABLE;
  648.                                         else if(power_save_level == 1)
  649.                                                 ps_mgmt.ps_mode = PS_MODE_PERIODIC_DTIM;
  650.                                         else if(power_save_level == 2)
  651.                                                 ps_mgmt.ps_mode = PS_MODE_INACTIVITY;
  652.                                         else
  653.                                                 ps_mgmt.ps_mode = PS_MODE_DISABLE;
  654.                                        
  655.                                         ret = wifi_dev->netdev_ops->ndo_do_ioctl(wifi_dev, (void*)wrq, UAP_POWER_MODE);
  656.                                 }

  658.                                 mem_free(wrq);
  659.                         }
  660.                 }
  661.         }

  663.         if(priv->bss_role == MLAN_BSS_ROLE_STA)
  664.         {
  665.                 if(wifi_dev->cfg80211_ops && wifi_dev->cfg80211_ops->set_power_mgmt)
  666.                 {
  667.                         bool enable;
  668.                         if(power_save_level == 0)
  669.                                 enable = FALSE;
  670.                         else
  671.                                 enable = TRUE;
  672.                         ret = wifi_dev->cfg80211_ops->set_power_mgmt(priv->wdev->wiphy, wifi_dev,enable, 0);
  673.                 }
  674.         }
  675.        
  676.         return ret;
  677. }



  681. /**
  682. * @brief  这里不再提供WIFI事件的回调
  683. *
  684. * ap模式下请参考wlan_ops_uap_process_event函数
  685. * sta模式下请参考wlan_ops_sta_process_event函数
  686. */

  688. int event_callback(int type)
  689. {

  691.         return 0;
  692. }

  694. extern uint8_t g_mac_addr[6];


  697. /**
  698. * @brief  通过CPU_ID计算出一个随机数用于填充MAC地址的低3字节
  699. *
  700. *
  701. */
  702. int create_mac(unsigned char *mac)
  703. {
  704.         char psk[33], id[12];
  705. ……………………

  707. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
无线遥控器设计.zip (9.01 MB, 下载次数: 47)


评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表