SmartPDCode/f407/applications/main.c

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2018-11-06     SummerGift   first version
 * 2018-11-19     flybreak     add stm32f407-atk-explorer bsp
 * 2023-12-03     Meco Man     support nano version
 */

#include <board.h>
#include <rtthread.h>
#include <drv_gpio.h>
#include <drv_usbh.h>
#include <dfs_fs.h>

#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include "web.h"
#include "fs.h"

//https://embedded-rd.blog.csdn.net/article/details/109643188

extern void lwip_sys_init(void);
#define LED0_PIN    GET_PIN(F, 9)
#define LED1_PIN    GET_PIN(F, 10)

static void led_init(void)
{
    rt_pin_mode(LED0_PIN, PIN_MODE_OUTPUT);
    rt_pin_mode(LED1_PIN, PIN_MODE_OUTPUT);
}
static void led_toggle(void)
{
    static rt_ssize_t v=PIN_LOW;
    rt_pin_write(LED0_PIN, v);
    rt_pin_write(LED1_PIN, v);
    v = (v==PIN_LOW)?PIN_HIGH:PIN_LOW;
}

static rt_device_t serial;
static int log_init(void)
{
    serial = rt_device_find("uart1");
    return 0;
}
static void log_print(char *ss)
{
    rt_device_write(serial, 0, ss, (sizeof(ss)));
}


static int net_init(const char *ip, int port)
{
#define SERVER_PORT 8080
#define BUFF_SIZE 128
    
    int sock, client_fd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_addr_len;
    char buff[BUFF_SIZE];
    int bytes_read;
    int ret;
    
    /* ??socket */
    sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock == -1) {
        rt_kprintf("socket create failed!\n");
        return -1;
    }
 
    /* ??????? */
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    server_addr.sin_addr.s_addr = inet_addr(ip);
 
    /* ??????? */
    ret = bind(sock, (struct sockaddr *)&server_addr, sizeof(server_addr));
    if (ret == -1) {
        rt_kprintf("bind failed!\n");
        goto __exit;
    }
 
    /* ?????? */
    ret = listen(sock, 5);
    if (ret == -1) {
        rt_kprintf("listen failed!\n");
        goto __exit;
    }
 
    rt_kprintf("TCP server waiting for client on port %d...\n", port);
 
    /* ??????? */
    client_addr_len = sizeof(client_addr);
    client_fd = accept(sock, (struct sockaddr *)&client_addr, &client_addr_len);
    if (client_fd == -1) {
        rt_kprintf("accept failed!\n");
        goto __exit;
    }
 
    rt_kprintf("Client accepted!\n");
 
    /* ????????? */
    while (1) {
        bytes_read = recv(client_fd, buff, BUFF_SIZE, 0);
        if (bytes_read <= 0) {
            rt_kprintf("recv failed, errno=%d\n", errno);
            break;
        }
        /* ????????????? */
        ret = send(client_fd, buff, bytes_read, 0);
        if (ret < 0) {
            rt_kprintf("send failed, errno=%d\n", errno);
            break;
        }
    }
 
__exit:
    if (client_fd >= 0) close(client_fd);
    if (sock >= 0) close(sock);
    return ret;
}


static int user_init(void)
{
    
    led_init();
    
    //rt_hw_lcd_init();
    
    rt_thread_mdelay(3000);
    fs_mount("sd", 1);
    
    lwip_sys_init();
    web_init();
    //net_init("0.0.0.0", SERVER_PORT);
    
    return 0;
}

#define THRAD_MAX  8
static int flags[THRAD_MAX];
static void my_thread(void *arg)
{
    int p=*(int*)arg;
    while(1) {
        rt_kprintf("____thread %d\n", p);
    }
}
static void my_start(void)
{
    int i;
    
    for(i=0; i<THRAD_MAX; i++) {
        flags[i] = i;
        rt_thread_t tid = rt_thread_create(NULL, my_thread, &flags[i], 2048, 5, 20);
        if(tid==NULL) {
            rt_kprintf("___ thread create failed\n");
        }
        rt_thread_startup(tid);
    }
}


int main(void)
{
    user_init();
    
    //my_start();
    while (1) {
        led_toggle();
        rt_thread_mdelay(500);
    }
}