Hardware components | ||||||
_xcg7vos8ax_LjVH1Q6mKB.png?auto=compress%2Cformat&w=48&h=48&fit=fill&bg=ffffff) |
| × | 1 | |||
 |
| × | 1 | |||
 |
| × | 1 | |||
1. Install RP2040-HAT-AZURE-C on Github
https://github.com/Wiznet/RP2040-HAT-AZURE-C.git
open example/main.c file
2. Add ADC sensing code
Get the pico-examples/adc/microphone_adc/microphone_adc.c code and put it in main.c file.
define data
#define ADC_NUM 0
#define ADC_PIN (26 + ADC_NUM)
#define ADC_VREF 3.3
#define ADC_RANGE (1 << 12)
#define ADC_CONVERT (ADC_VREF / (ADC_RANGE - 1))
#define ADC_CLK_VAL 2999add ADC set code
stdio_init_all();
printf("Beep boop, listening...\n");
bi_decl(bi_program_description("Analog microphone example for Raspberry Pi Pico")); // for picotool
bi_decl(bi_1pin_with_name(ADC_PIN, "ADC input pin"));
adc_init();
adc_gpio_init( ADC_PIN);
adc_select_input( ADC_NUM);ADC FIFO setup
adc_fifo_setup(
true, // Write each completed conversion to the sample FIFO
true, // Enable DMA data request (DREQ)
1, // DREQ (and IRQ) asserted when at least 1 sample present
true, // We won't see the ERR bit because of 8 bit reads; disable.
false // Shift each sample to 8 bits when pushing to FIFO
);ADC CLK setup
adc sampling rate = 48Mhz /(1+ 2999) = 16kS/s
adc_set_clkdiv(ADC_CLK_VAL);//2999= 16kS/s3. Add W5100 Code
Add variabls
static wiz_NetInfo g_net_info =
{
.mac = {0x00, 0x08, 0xDC, 0x12, 0x34, 0x68}, // MAC address
.ip = {192, 168, 15, 125}, // IP address
.sn = {255, 255, 255, 0}, // Subnet Mask
.gw = {192, 168, 0, 1}, // Gateway
.dns = {8, 8, 8, 8}, // DNS server
#ifdef _DHCP
.dhcp = NETINFO_DHCP // DHCP enable/disable
#else
// this example uses static IP
.dhcp = NETINFO_STATIC
#endif
};
typedef struct TCP_S_RSV_DATA_1
{
uint8_t DestIP[4];
uint16_t Port;
uint16_t RCV_Size;
uint8_t *RCV_DATA;
}TCP_S_RSV_DATA;
typedef struct ADC_DATA_STATUS_t
{
uint8_t sendPosition;
uint8_t sendFlag;
uint8_t sendComplete;
uint8_t inputPosition;
uint16_t dataCount;
uint8_t sendStatus;
uint8_t DATA[2][2048];
}ADC_DATA_STATUS;
typedef union h2f_var_t
{
uint32_t hdata;
float fdata;
}h2f_var;add function
uint16_t TCP_Server(uint8_t sn, uint16_t port)
{
int32_t ret;
uint8_t destip[4];
uint16_t destport;
switch(getSn_SR(sn))
{
case SOCK_ESTABLISHED :
//TCP_S_Recv(sn);
#if 0
if(getSn_IR(sn) & Sn_IR_CON)
{
#ifdef _LOOPBACK_DEBUG_
getSn_DIPR(sn, destip);
destport = getSn_DPORT(sn);
printf("%d:Connected - %d.%d.%d.%d : %d\r\n",sn, destip[0], destip[1], destip[2], destip[3], destport);
#endif
setSn_IR(sn,Sn_IR_CON);
}
#endif
return 17;
break;
case SOCK_CLOSE_WAIT :
#ifdef TCP_S_DEBUG_
printf("%d:CloseWait\r\n",sn);
#endif
if((ret = disconnect(sn)) != SOCK_OK) return ret;
#ifdef TCP_S_DEBUG_
printf("%d:Socket Closed\r\n", sn);
#endif
break;
case SOCK_INIT :
#ifdef TCP_S_DEBUG_
printf("%d:Listen, TCP server, port [%d]\r\n", sn, port);
#endif
if( (ret = listen(sn)) != SOCK_OK) return ret;
break;
case SOCK_CLOSED:
#ifdef TCP_S_DEBUG_
//printf("%d:TCP server loopback start\r\n",sn);
#endif
if((ret = socket(sn, Sn_MR_TCP, port, 0x00)) != sn) return ret;
#ifdef TCP_S_DEBUG_
printf("%d:Socket opened\r\n",sn);
#endif
break;
default:
break;
}
return 1;
}
//TCP_S_RSV_DATA *TCP_S_Recv(uint8_t sn)
uint8_t *TCP_S_Recv(uint8_t sn, uint16_t *rcv_size)
{
#if 0
TCP_S_RSV_DATA *temp_data = 0;
temp_data->RCV_DATA = 0;
#endif
uint16_t size;
int ret;
uint8_t destip[4];
uint16_t destport;
uint8_t *buff=0;
if(getSn_IR(sn) & Sn_IR_CON)
{
#ifdef TCP_S_DEBUG_
printf("Connected in function\r\n");
#if 0
getSn_DIPR(sn, temp_data->DestIP);
temp_data->Port = getSn_DPORT(sn);
printf("%d:Connected - %d.%d.%d.%d : %d\r\n",sn, temp_data->DestIP[0], temp_data->DestIP[1], temp_data->DestIP[2], temp_data->DestIP[3], temp_data->Port);
#endif
getSn_DIPR(sn, destip);
destport = getSn_DPORT(sn);
printf("%d:Connected - %d.%d.%d.%d : %d\r\n",sn, destip[0], destip[1], destip[2], destip[3], destport);
#endif
setSn_IR(sn,Sn_IR_CON);
}
//if((temp_data->RCV_Size = getSn_RX_RSR(sn)) > 0) // Don't need to check SOCKERR_BUSY because it doesn't not occur.
if((size = getSn_RX_RSR(sn)) > 0) // Don't need to check SOCKERR_BUSY because it doesn't not occur.
{
if(size > DATA_BUF_SIZE) size = DATA_BUF_SIZE;
printf("recv Data size : %d \r\n", size);
buff = (uint8_t *)calloc(size, sizeof(uint8_t));
if(buff == 0)
{
printf("calloc error \r\n");
return 0;
}
ret = recv(sn, buff, size);
if(ret <= 0)
{
free(buff);
*rcv_size = ret;
return 0; // check SOCKERR_BUSY & SOCKERR_XXX. For showing the occurrence of SOCKERR_BUSY.
}
}
*rcv_size = size;
return buff;
}
uint16_t TCP_client(uint8_t sn, uint8_t* destip, uint16_t destport)
{
int32_t ret; // return value for SOCK_ERRORs
uint16_t size = 0, sentsize=0;
// Destination (TCP Server) IP info (will be connected)
// >> loopback_tcpc() function parameter
// >> Ex)
// uint8_t destip[4] = {192, 168, 0, 214};
// uint16_t destport = 5000;
// Port number for TCP client (will be increased)
static uint16_t any_port = 50000;
// Socket Status Transitions
// Check the W5500 Socket n status register (Sn_SR, The 'Sn_SR' controlled by Sn_CR command or Packet send/recv status)
switch(getSn_SR(sn))
{
case SOCK_ESTABLISHED :
#if 0
if(getSn_IR(sn) & Sn_IR_CON) // Socket n interrupt register mask; TCP CON interrupt = connection with peer is successful
{
#ifdef _LOOPBACK_DEBUG_
printf("%d:Connected to - %d.%d.%d.%d : %d\r\n",sn, destip[0], destip[1], destip[2], destip[3], destport);
#endif
setSn_IR(sn, Sn_IR_CON); // this interrupt should be write the bit cleared to '1'
}
//////////////////////////////////////////////////////////////////////////////////////////////
// Data Transaction Parts; Handle the [data receive and send] process
//////////////////////////////////////////////////////////////////////////////////////////////
if((size = getSn_RX_RSR(sn)) > 0) // Sn_RX_RSR: Socket n Received Size Register, Receiving data length
{
if(size > DATA_BUF_SIZE) size = DATA_BUF_SIZE; // DATA_BUF_SIZE means user defined buffer size (array)
ret = recv(sn, buf, size); // Data Receive process (H/W Rx socket buffer -> User's buffer)
if(ret <= 0) return ret; // If the received data length <= 0, receive failed and process end
size = (uint16_t) ret;
sentsize = 0;
// Data sentsize control
while(size != sentsize)
{
ret = send(sn, buf+sentsize, size-sentsize); // Data send process (User's buffer -> Destination through H/W Tx socket buffer)
if(ret < 0) // Send Error occurred (sent data length < 0)
{
close(sn); // socket close
return ret;
}
sentsize += ret; // Don't care SOCKERR_BUSY, because it is zero.
}
}
#endif
return 17;
//////////////////////////////////////////////////////////////////////////////////////////////
break;
case SOCK_CLOSE_WAIT :
#ifdef _LOOPBACK_DEBUG_
//printf("%d:CloseWait\r\n",sn);
#endif
if((ret=disconnect(sn)) != SOCK_OK) return ret;
#ifdef _LOOPBACK_DEBUG_
printf("%d:Socket Closed\r\n", sn);
#endif
break;
case SOCK_INIT :
#ifdef _LOOPBACK_DEBUG_
printf("%d:Try to connect to the %d.%d.%d.%d : %d\r\n", sn, destip[0], destip[1], destip[2], destip[3], destport);
#endif
if( (ret = connect(sn, destip, destport)) != SOCK_OK) return ret; // Try to TCP connect to the TCP server (destination)
break;
case SOCK_CLOSED:
close(sn);
if((ret=socket(sn, Sn_MR_TCP, any_port++, 0x00)) != sn){
if(any_port == 0xffff) any_port = 50000;
return ret; // TCP socket open with 'any_port' port number
}
#ifdef _LOOPBACK_DEBUG_
//printf("%d:TCP client loopback start\r\n",sn);
//printf("%d:Socket opened\r\n",sn);
#endif
break;
default:
break;
}
return 1;
}
int32_t udps_status(uint8_t sn, uint8_t* buf, uint16_t port)
{
int32_t ret;
uint16_t size, sentsize;
uint8_t destip[4];
uint16_t destport;
switch(getSn_SR(sn))
{
case SOCK_UDP :
if((size = getSn_RX_RSR(sn)) > 0)
{
if(size > DATA_BUF_SIZE) size = DATA_BUF_SIZE;
ret = recvfrom(sn, buf, size, destip, (uint16_t*)&destport);
if(ret <= 0)
{
#ifdef _LOOPBACK_DEBUG_
printf("%d: recvfrom error. %ld\r\n",sn,ret);
#endif
return ret;
}
size = (uint16_t) ret;
sentsize = 0;
while(sentsize != size)
{
ret = sendto(sn, buf+sentsize, size-sentsize, destip, destport);
if(ret < 0)
{
#ifdef _LOOPBACK_DEBUG_
printf("%d: sendto error. %ld\r\n",sn,ret);
#endif
return ret;
}
sentsize += ret; // Don't care SOCKERR_BUSY, because it is zero.
}
}
return SOCK_UDP;
break;
case SOCK_CLOSED:
#ifdef _LOOPBACK_DEBUG_
//printf("%d:UDP loopback start\r\n",sn);
#endif
if((ret = socket(sn, Sn_MR_UDP, port, 0x00)) != sn)
return ret;
#ifdef _LOOPBACK_DEBUG_
printf("%d:Opened, UDP, port [%d]\r\n", sn, port);
#endif
break;
default :
break;
}
return 1;
}open a socket and receive data to execute cmd
if(TCP_S_status == 17)
{
//TCP_Server_Buf = TCP_S_Recv(TCP_S_SOCKET);
//tcp_rcv_data = TCP_S_Recv(TCP_S_SOCKET);
tcp_rcv_data = TCP_S_Recv(TCP_S_SOCKET, &tcp_rcv_size);
if(tcp_rcv_data != 0)
{
printf("rcv[%d] : %s \r\n",tcp_rcv_size, tcp_rcv_data);
if(UDP_S_status == 0x22)
{
//UDP_ret = sendto(UDP_SOCKET, tcp_rcv_data, tcp_rcv_size, UDP_BroadIP, UDP_SPORT);
if(UDP_ret < 0)
{
printf("sendto Error \r\n");
}
}
if(strncmp(tcp_rcv_data, "start", 5) == 0)
{
printf(" data send start[%s]\r\n", tcp_rcv_data + 6);
udp_send_port = atoi(tcp_rcv_data + 6);
printf("recv port = %d \r\n", udp_send_port);
//UDP_ret = sendto(UDP_SOCKET, "START", 5, UDP_BroadIP, UDP_SPORT);
adc_run(true);
adc_fifo_drain();
data_send_status = 1;
//adc_data.sendStatus = 1;
}
else if(strncmp(tcp_rcv_data, "stop", 4) == 0)
{
printf("data send stop \r\n");
data_send_status = 0;
//adc_data.sendStatus = 0;
adc_run(false);
}
free(tcp_rcv_data);
}
}4. sensing data send data
if(data_send_status == 1)
{
for(i= 0; i<250; i++)
{
adc_raw = adc_fifo_get_blocking();
adc_raw1 = (adc_raw&0x0fff) - (1<<10);
mic_Data[mic_cnt++] = adc_raw1 & 0x00ff;
mic_Data[mic_cnt++] = (adc_raw1 >> 8) & 0x00ff;
}
mic_cnt = 0;
send_count++;
sendto(UDP_SOCKET, mic_Data, 500, UDP_BroadIP, udp_send_port);
}
if(send_count >= 2000)
{
UDP_ret = sendto(UDP_SOCKET, "STOP", 5, UDP_BroadIP, udp_send_port);
printf("send finish %d\r\n", send_count);
data_send_status = 0;
send_count = 0;
adc_run(false);
}5. hardware setup
pico w5100 evb + mic
wiznet w5100evb + mic
6. Raspberry pi Program
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include<arpa/inet.h>
#define MAXLINE 2048
#define BLOCK 255
#define FILENAME "buf.dat"
int main(int argc, char *argv[]) {
struct sockaddr_in servaddr, cliaddr;
int s, nbyte, addrlen = sizeof(struct sockaddr);
char buf[MAXLINE+1];
FILE *stream;
char tcp_send_msg[100] = "start";
int tcp_send_size = 0;
char save_file_name[100];
int tcp_sock;
struct sockaddr_in tcp_serv_addr;
if((argc ==2)&&(strcmp(argv[1],"/h") == 0))
{
printf("help cmd [UDP PORT] [TCP IP] [TCP PORT] [FILE NAME]\r\n");
return 0;
}
if(argc < 4) {
printf("usage: %d %s port\n", argc,argv[0]);
exit(0);
}
if(argc == 4)
{
strcpy(save_file_name , FILENAME);
}
else
{
strcpy(save_file_name , argv[4]);
}
printf("Save File name : [%s]\r\n", save_file_name);
if((s = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket fail");
exit(0);
}
tcp_sock = socket(PF_INET,SOCK_STREAM,0); //1踰�
if(tcp_sock == -1)
printf("socket error \n");
memset(&tcp_serv_addr,0,sizeof(tcp_serv_addr));
tcp_serv_addr.sin_family = AF_INET;
tcp_serv_addr.sin_addr.s_addr=inet_addr(argv[2]);
tcp_serv_addr.sin_port=htons(atoi(argv[3]));
memset(&cliaddr, 0, addrlen); //bzero((char *)&cliaddr, addrlen);
memset(&servaddr, 0, addrlen); //bzero((char *)&servaddr,addrlen);
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(atoi(argv[1])); /
if(connect(tcp_sock,(struct sockaddr*)&tcp_serv_addr,sizeof(tcp_serv_addr))==-1) //2踰�
printf("connect error\n");
if(bind(s, (struct sockaddr *)&servaddr, addrlen) < 0) {
perror("bind fail");
exit(0);
}
if((stream = fopen(save_file_name, "w")) == 0){
printf("Faile open error\n");
exit(1);
}
puts("Server : waiting request.");
tcp_send_size = sprintf(tcp_send_msg, "start %s", argv[1]);
write(tcp_sock, tcp_send_msg, tcp_send_size);
while(1)
{
//puts("Server : waiting request.");
nbyte = recvfrom(s, buf, MAXLINE , 0, (struct sockaddr *)&cliaddr, &addrlen);
if(nbyte< 0) {
perror("recvfrom fail");
exit(1);
}
buf[nbyte] = 0; //留덉��留� 媛믪뿉 0
//if(!strncmp(buf, "end of file", 10)) {
if(!strncmp(buf, "STOP", 4))
{
printf("file close");
fclose(stream); //stream
break; //while
}
else {
//printf("%d byte recv: %s\n",nbyte, buf);
printf("%d byte recv\r\n",nbyte);
//fputs(buf, stream); //
fwrite(buf, sizeof(char), nbyte, stream);
}
}
close(s);
return 0;
}7. Raspberrypi compile probram
gcc mic_rec_test.c -o mic_rec_test
./mic_rec_test /h
help cmd [UDP PORT] [TCP IP] [TCP PORT] [FILE NAME]8. Program Diagram
9. program start
pico probram log
raspberry pi log
start
end
Wireshark packet log
10. Result Data
File generation
Audacity input data
Audacity play
my sorce code
Comments