select count(*) as count2, sum(count1) as coun3 from (select 1 , case when is_pdcp_busy_week =1 then 1 else 0 end as count1 from d_wx_expansion_oarea2023 )t union all SELECT COUNT(DISTINCT CASE WHEN unique_id_station IS NOT NULL THEN unique_id_station END) as count1, COUNT(DISTINCT CASE WHEN is_pdcp_busy_week = 1 AND unique_id_station IS NOT NULL THEN unique_id_station END) as count4 FROM d_wx_expansion_oarea2023将结果分别展示

对于第一个 SQL 查询，结果展示如下：

| count2 | count3 |
|--------|--------|
| 1 | count1的总和 |

其中，count2 的值为 1，表示只有一条结果。count3 的值为 count1 的总和，表示 is_pdcp_busy_week 为 1 的记录数。

对于第二个 SQL 查询，结果展示如下：

| count1 | count4 |
|--------|--------|
| 不为空的 unique_id_station 记录数 | is_pdcp_busy_week 为 1 且 unique_id_station 不为空的记录数 |

其中，count1 的值为不为空的 unique_id_station 记录数，count4 的值为 is_pdcp_busy_week 为 1 且 unique_id_station 不为空的记录数。注意，这里使用了 DISTINCT 关键字，表示去重后的记录数。

相关问题

条件1.使用stm32f103c8t6,c语言编程条件2.使用PA1,PA2,PA3,PA4,PA5，PA6配置成上拉输入,根据6个引脚的电平高低生成。例如000000表示6引脚电平全为0,统计该二进制数中0的次数记作zeo_count;将该二进制数转成16进制数，并作为条件3中的数据。条件3.串口1发数据,满足串口数据校验 (包头0xee)(数据长度)(...数据...)(数据长度反码)(包尾0xef),按照串口协议通信发送条件2中的二进制数;串口1收数据,满足串口数据校验 (包头0xee)(数据长度)(...数据...)(数据长度反码)(包尾0xef);不满足重新接收。直到成功接收。条件4.规定zeo_count_old.默认值为6;若串口1接收数据为“0xee0x010x010x010xef”则zeo_count_old=1;若串口1接收数据为“0xee0x010x020x010xef”则zeo_count_old=2;若串口1接收数据为“0xee0x010x030x010xef”则zeo_count_old=3;若串口1接收数据为“0xee0x010x040x010xef”则zeo_count_old=4;若串口1接收数据为“0xee0x010x050x010xef”则zeo_count_old=5;若串口1接收数据为“0xee0x010x060x010xef”则zeo_count_old=6;条件5.若zeo_count_old大于zeo_count,打开蜂鸣器;则若zeo_count_old小于zeo_count,串口发送字符串"规定设备未取完",等待1分钟后将zeo_count_old更新为zeo_coun的值;若zeo_count_old等于zeo_count,串口发送字符串"设备数量正常";

以下是参考代码，仅供参考，需要根据实际情况进行修改：

#include "stm32f10x.h"
#include "stdio.h"

#define BUFSIZE 100

uint16_t zero_count_old = 6;
uint16_t zero_count = 0;
uint8_t uart_buf[BUFSIZE];
uint8_t uart_buf_index = 0;

void USART1_IRQHandler(void) {
    uint8_t ch;
    if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) {
        ch = USART_ReceiveData(USART1);
        if (uart_buf_index == 0 && ch != 0xee) {
            return;
        }
        uart_buf[uart_buf_index++] = ch;
        if (uart_buf_index == 4) {
            if (uart_buf[1] != 0x01 || uart_buf[2] > 0x06) {
                // 数据长度不对，重新接收
                uart_buf_index = 0;
            }
        } else if (uart_buf_index == uart_buf[1]+4) {
            uint8_t sum = 0;
            for (uint8_t i = 0; i < uart_buf[1]+2; i++) {
                sum += uart_buf[i];
            }
            sum = ~sum;
            if (sum != uart_buf[uart_buf_index-2] || uart_buf[uart_buf_index-1] != 0xef) {
                // 校验错误，重新接收
                uart_buf_index = 0;
            } else {
                // 收到正确的数据，更新 zero_count_old
                zero_count_old = uart_buf[2];
                uart_buf_index = 0;
            }
        }
    }
}

void delay_ms(uint32_t ms) {
    for (uint32_t i = 0; i < ms*8000; i++);
}

void init_uart(void) {
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    // 打开 GPIO 和 USART1 时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO | RCC_APB2Periph_USART1, ENABLE);

    // 配置 USART1 引脚
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    // 配置 USART1
    USART_InitStructure.USART_BaudRate = 115200;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
    USART_Init(USART1, &USART_InitStructure);

    // 配置 USART1 中断
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    // 打开 USART1
    USART_Cmd(USART1, ENABLE);
}

void init_gpio(void) {
    GPIO_InitTypeDef GPIO_InitStructure;

    // 打开 GPIO 时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    // 配置 PA1-PA6 为上拉输入
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
}

uint8_t get_gpio_value(void) {
    uint8_t value = 0;
    for (uint8_t i = 1; i <= 6; i++) {
        if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0+i)) {
            value |= (1<<(6-i));
        }
    }
    return value;
}

void send_data(uint8_t *data, uint8_t len) {
    uint8_t sum = 0;
    USART_SendData(USART1, 0xee);
    USART_SendData(USART1, len);
    for (uint8_t i = 0; i < len; i++) {
        USART_SendData(USART1, data[i]);
        sum += data[i];
    }
    sum = ~sum;
    USART_SendData(USART1, sum);
    USART_SendData(USART1, 0xef);
}

int main(void) {
    init_gpio();
    init_uart();
    while (1) {
        zero_count = __builtin_popcount(get_gpio_value());
        if (zero_count_old > zero_count) {
            // 打开蜂鸣器
        }
        if (zero_count_old < zero_count) {
            send_data("规定设备未取完", sizeof("规定设备未取完")-1);
            delay_ms(60000); // 等待 1 分钟
            zero_count_old = zero_count;
        }
        if (zero_count_old == zero_count) {
            send_data("设备数量正常", sizeof("设备数量正常")-1);
        }
        delay_ms(1000);
    }
}

if (usart1_task)//上位机发来数据 { /*编码后发给有人模块（串口8）*/ USART_SendBytes(USART8, usr_buf, encodeing(usart1_buf, usr_buf, usart1_counter, CENTRAL_TO_TERMINAL)); uint8_t data = 0xFF; USART_SendBytes(USART1, &data, 1); waiting_back_tim = 60; waiting_back = 1;//等待回示 usart1_counter = 0; usart1_task = 0; } if (usart8_task)//有人模块发来数据没有处理完，每处理完一帧减一 { /*解码数据，并根据功能码执行*/ rd_fifo_is = 1; while (rd_fifo_is) { fifo_read(&usart8_fifo, &rd_fifo_tmp, 1);//从环队读取一个数据 switch (rd_fifo_tmp)//判断数据内容 { case HEAD: rd_fifo_coun = 0; break; case END: rd_fifo_is = 0; //结束循环 break; case ESCAPE://转义符，下个数据需要转义 escape = 1; break; default: if (escape) { rd_fifo_buf[rd_fifo_coun++] = rd_fifo_tmp ^ 0x30; escape = 0; } else { rd_fifo_buf[rd_fifo_coun++] = rd_fifo_tmp; } break; } }

这也是一段代码，主要是用于处理串口数据的收发。当接收到来自上位机的数据时，代码会对数据进行编码，并通过串口8发送给“有人模块”，并等待“有人模块”的返回。同时，代码会将接收缓冲区计数器清零，并将任务标志位清零。当接收到来自“有人模块”的数据时，代码会对数据进行解码，并根据功能码执行相应的操作。此处使用了FIFO缓冲区来完成数据的读写操作。具体而言，代码会不断从FIFO缓冲区中读取数据，并根据数据内容进行相应的处理，直到读取到结束符（END）为止。并且在解码时，还考虑了转义符（ESCAPE）的情况，从而确保数据的正确性。