【NanoPi NEO2试用体验】智能家庭控制器--结项

       智能家庭控制器这个项目忙活了将近一个多月，我的工作重点放在了图像传输和音频传输上，而控制方面我这没有做太多工作，因为之前做Orangepi Zero的时候已经做过了很多这些任务，参考以前的帖子，包括GPIO的控制、LCD5110的控制，I2C读取MPU6050等等，这里不再多做重复的工作，将重点放在核心上。
       前面几个帖子已经介绍了使用UVC摄像头进行图像采集并进行jpeg图像转换的工作，后面我又做了一些音频方面的工作，在linux下进行音频采集和播放我使用的是基于oss框架的程序设计，alsa框架稍微麻烦一点。进行声音播放和录制其实很简单，和其他的设备使用方式一样就是打开、读写和关闭设备就行了。打开的设备是dsp设备，打开之后设置采集音频的参数包括采样率、量化位数、声道数。然后调用read函数就能进行进行录音了，获得的数据就是原始的PCM数据也就是原始音频数据，这些数据可以直接write到dsp设备上进行播放。下面就是使用dsp设备进行数据采集和播放的程序段：

1. #define LENGTH                8                //录音时间,秒
   
2. #define RATE                8000        //采样频率
   
3. #define SIZE                8                //量化位数
   
4. #define CHANNELS        1                //声道数目
   
5. #define RSIZE                8192        //buf的大小
   
6. 
   
7. static int recoder_fd = -1;
   
8. 
   
9. int OpenRecoder()
   
10. {
    
11.         recoder_fd = open("/dev/dsp", O_RDWR);
    
12.         if (recoder_fd < 0)
    
13.         {
    
14.                 perror("Cannot open /dev/dsp device");
    
15.                 return 1;
    
16.         }
    
17. 
    
18.         int arg = SIZE;
    
19.         if (ioctl(recoder_fd, SOUND_PCM_WRITE_BITS, &arg) == -1)    //设置量化位数
    
20.         {
    
21.                 perror("Cannot set SOUND_PCM_WRITE_BITS ");
    
22.                 return 1;
    
23.         }
    
24. 
    
25.         arg = CHANNELS;
    
26.         if (ioctl(recoder_fd, SOUND_PCM_WRITE_CHANNELS, &arg) == -1)   //设置声道数
    
27.         {
    
28.                 perror("Cannot set SOUND_PCM_WRITE_CHANNELS");
    
29.                 return 1;
    
30.         }
    
31.        
    
32.         arg = RATE;
    
33.         if (ioctl(recoder_fd, SOUND_PCM_WRITE_RATE, &arg) == -1)      //设置采样率
    
34.         {
    
35.                 perror("Cannot set SOUND_PCM_WRITE_WRITE");
    
36.                 return 1;
    
37.         }
    
38. }
    
39. 
    
40. void CloseRecoder()
    
41. {
    
42.         if(recoder_fd > 0)
    
43.                 close(recoder_fd);
    
44. }
    
45. 
    
46. int Recording(unsigned char *buff,int len)
    
47. {
    
48.         if(recoder_fd > 0)
    
49.                 return read(recoder_fd, buff, len);
    
50.         else
    
51.                 return 0;
    
52. }
    
53. 
    
54. int Playing(unsigned char *buff,int len)
    
55. {
    
56.         if(recoder_fd > 0)
    
57.                 write(recoder_fd, buff, len);
    
58. }
    

复制代码

采集到的数据是不能直接保存成文件在Windows等系统识别，需要进行格式封装，这里进行的是wav格式的封装，wav的格式可以参考：http://blog.csdn.net/mlkiller/article/details/12567139，wav的数据格式表如下：

偏移地址	大小 字节	数据块 类型	内容
00H~03H	4	4字符	资源交换文件标志（RIFF）
04H~07H	4	长整数	从下个地址开始到文件尾的总字节数
08H~0BH	4	4字符	WAV文件标志（WAVE）
0CH~0FH	4	4字符	波形格式标志（fmt ），最后一位空格。
10H~13H	4	整数	过滤字节（一般为00000010H）
14H~15H	2	整数	格式种类（值为1时，表示数据为线性PCM编码）
16H~17H	2	整数	通道数，单声道为1，双声道为2
18H~1BH	4	长整数	采样频率
1CH~1FH	4	长整数	波形数据传输速率（每秒平均字节数）
20H~21H	2	整数	DATA数据块长度，字节。
22H~23H	2	整数	PCM位宽
24H~27H	4	4字符	“fact”,该部分一下是可选部分，即可能有，可能没有,一般到WAV文件由某些软件转换而成时，包含这部分。
28H~2BH	4	长整数	size,数值为4

wav是我见过的最简单的文件格式，封装wav的函数也很简单：

1. struct WAV_HEADER wavehead =
   
2. {
   
3.         .RIFF = {'R','I','F','F'},
   
4.         .WAVE = {'W','A','V','E'},
   
5.         .fmt = {'f','m','t',' '},
   
6.         .appendinfo = 16,
   
7.         .format = 1,
   
8.         .desc = {'d','a','t','a'},
   
9. };
   
10. 
    
11. //保存采样率8000，采样深度8位，1声道的数据
    
12. void SavePCM2WAV(unsigned char *buff,int len,char *file)
    
13. {
    
14.         system("rm a.wav");
    
15.         system("touch a.wav");
    
16.        
    
17.         wavehead.lenth = len + sizeof(struct WAV_HEADER) - 8;
    
18.         wavehead.channel = 1;
    
19.         wavehead.freq = 8000;
    
20.         wavehead.rate = 8000*8/8;
    
21.         wavehead.sampling = 1;
    
22.         wavehead.datalenth = len;
    
23.         wavehead.depth = 8;
    
24.        
    
25.         int fd = open("a.wav",O_RDWR);
    
26.         if(fd > 0)
    
27.         {
    
28.                 int ret = write(fd,(unsigned char*)(&wavehead),sizeof(struct WAV_HEADER));
    
29.                 if(ret != sizeof(struct WAV_HEADER))
    
30.                 {
    
31.                         printf("write header errorrn");
    
32.                         system("rm a.wav");
    
33.                         return;
    
34.                 }
    
35.                 ret = write(fd,buff,len);
    
36.                 if(ret != len)
    
37.                 {
    
38.                         printf("write data errorrn");
    
39.                         system("rm a.wav");
    
40.                         return;
    
41.                 }
    
42.                 close(fd);
    
43.         }
    
44. }
    

复制代码

wav格式的文件虽然简单但是文件很大，不利于网络传输，这里可以使用命令将wav文件转成成mp3文件，文件大小会被压缩很多，使用的是lame库，可以自己安装或者编译lame源码：
lame sample.wav sample.mp3
得到的mp3文件就能进行网络传输了。
图像和音频基本上搞定了下面就是做主要的程序部分了，包括网络部分和硬件电路部分，由于NanoPi NEO2没有接出mic和扬声器我需要自己设计一个mic和扬声器放大的电路，我准备自己做一个PCB板，包含mic电路和扬声器放大电路，但是这里我犯了一个极为***的错误，我把可爱的NanoPi NEO2当成了orangepi zero了，我做板的时候都是按照orangepi zero的尺寸和电路做的，我真的是。。。看错电路拿错板子。不过我想程序都是Linux通用的，哪里跑都是一样的，我先用这个orangepi zero板子实验了就，因为pcb打板要很长的时间，我没时间等待了，现在就发出了结项贴了，实在抱歉。电路板的图片如下：

上面有mic和喇叭接口，喇叭是有功放的，声音很大。电路图如下：

功放电路

mic电路

USB扩展电路

等我的NanoPi NEO2的板子做好了得等一个多星期，到时候补一个帖子吧。主要还是创作的分享过程，硬件上大同小异，不过NanoPi NEO2的小巧身材的确加了很多分。我很喜欢，要是自带wifi的话就好了。

电路弄好了下面就是程序了。服务器使用的是公司的不开源的一个小型的服务器，并不是很牛的服务器，而是因为商业原因没有开源，所以只能使用不能研究了。控制器的核心网络部分的代码是一个状态机程序：

1. void* network_thread(void *arg)
   
2. {
   
3.         int i;
   
4.         printf("network_thread startrn");
   
5.         while(1)
   
6.         {
   
7.                 if(network_stm == 0)
   
8.                 {
   
9.                         if(NetworkInit() == 0)
   
10.                         {
    
11.                                 printf("Network Initialize successfullyrn");
    
12.                                 network_stm = 1;
    
13.                         }
    
14.                         else
    
15.                         {
    
16.                                 printf("Network Initialize failedrn");
    
17.                                 usleep(5000000);        //网络初始化失败的话延时一会再重连
    
18.                         }
    
19.                 }
    
20.                 else if(network_stm == 1)
    
21.                 {
    
22.                         sprintf(login_string,"lock,%s,",key);
    
23.                         printf("login_string:%srn",login_string);
    
24.                         // write(sock_client,str,strlen(str));
    
25.                         SendNetFrame(login_string,strlen(login_string));
    
26.                         int len = read(sock_client,read_buff,1024);
    
27.                         // printf("%drn",len);
    
28.                         if(len > 0)
    
29.                         {
    
30.                                 read_buff[len] = 0;
    
31.                                 printf("%srn",read_buff);
    
32.                                 if(strcmp(read_buff,"success") == 0)
    
33.                                 {
    
34.                                         printf("login successfullyrn");
    
35.                                         network_stm = 2;
    
36.                                 }
    
37.                                 else
    
38.                                 {
    
39.                                         printf("login failedrn");
    
40.                                         close(sock_client);
    
41.                                         network_stm = 0;
    
42.                                         usleep(5000000);        //登录失败，关闭socket然后回到状态0
    
43.                                 }
    
44.                         }
    
45.                         else if(len == 0)
    
46.                         {
    
47.                                 printf("connection closed by serverrn");
    
48.                                 network_stm = 0;
    
49.                         }
    
50.                 }
    
51.                 else if(network_stm == 2)
    
52.                 {
    
53.                         int len = read(sock_client,read_buff,1024);
    
54.                         if(len > 0)
    
55.                         {
    
56.                                 // printf("read_buff len:%d,",len);
    
57.                                 // read_buff[len] = 0;
    
58.                                 // printf("%srn",read_buff);
    
59.                                 for(i=0;i
60.                                 {
    
61.                                         InputData(read_buff[i]);
    
62.                                         if(IsDataReady == 1)
    
63.                                         {
    
64.                                                 IsDataReady = 0;
    
65.                                                 input_frame[input_frame_len] = 0;        //最后补0，防止进行字符串比较的时候数组越界
    
66.                                                 printf("frame is ready,length:%drn",input_frame_len);
    
67.                                                
    
68.                                                 if(input_frame[0] == 'p')        //如果收到的是语言数据
    
69.                                                 {
    
70.                                                         printf("frame type:PCM datarn");
    
71.                                                         OpenRecoder();
    
72.                                                         Playing(input_frame+1,input_frame_len-1);
    
73.                                                         CloseRecoder();
    
74.                                                 }
    
75.                                                 else if(input_frame[0] == 'c')        //如果收到的是控制命令
    
76.                                                 {
    
77.                                                         printf("frame type:command:%srn",input_frame);
    
78.                                                         if(strstr(input_frame,"get picture") != 0)
    
79.                                                         {
    
80.                                                                 FLAG_GET_AND_SEND_PIC = 1;
    
81.                                                         }
    
82.                                                         else if(strstr(input_frame,"open lock") != 0)
    
83.                                                         {
    
84.                                                                 FLAG_OPENDOOR = 1;
    
85.                                                         }
    
86.                                                         else if(strstr(input_frame,"stream_on_off") != 0)
    
87.                                                         {
    
88.                                                                 FLAG_GET_VIDEO_STREAM = FLAG_GET_VIDEO_STREAM?0:1;
    
89.                                                         }
    
90.                                                 }
    
91.                                         }
    
92.                                 }
    
93.                                
    
94.                         }
    
95.                         else if(len == 0)
    
96.                         {
    
97.                                 printf("connection closed by serverrn");
    
98.                                 network_stm = 0;
    
99.                         }
    
100.                 }
     
101.                 usleep(1000);
     
102.         }
     
103. }
     

复制代码

用于解析接收到的网络数据，这是程序的核心，其他的摄像头和音频的部分前面都有程序不再说了。当收到来自手机端发来的命令的时候网络线程就会处理接收到的命令判断是拍照命令还是来自手机上的音频数据等等。安卓手机上的程序我也是简单的做了一个，我不是专门做安卓的所以做的很粗糙，只是一个大致的结构：

手机端连接上手机之后就和NanoPi进行通信了：

还可以进行双边语言通信，通信方式和微信类似，按下说话松开发送，安卓这块的代码写的很垃圾，仅供参考：

1. public class MainActivity extends AppCompatActivity {
   
2.     static Socket socket = null;
   
3.     OutputStream ou;
   
4.     InputStream in;
   
5. 
   
6.     LinearLayout main_linear_layout;
   
7.     ImageView image_view;
   
8.     ImageView big_image_view;
   
9.     Button btn_openlock;
   
10.     Button btn_getpic;
    
11.     Button btn_setup;
    
12.     Button btn_record;
    
13.     Handler handler = new Handler();
    
14. 
    
15.     byte send_buff[];   //发送数据缓冲区
    
16.     int send_buff_len;   //发送数据缓冲区长度
    
17.     byte raw_data_buff[] = new byte[1024 * 1024];   //读取socket得到的原始数据
    
18.     byte frame_buff[] = new byte[1024*1024];    //原始数据解析得到的有效数据帧
    
19.     boolean IsFrameReady = false;
    
20.     int frame_buffLen;
    
21.     int state = 0;
    
22.     int count = 0;
    
23. 
    
24.     Bitmap bitmap;
    
25. 
    
26.     byte[] img_buf = new byte[1024 * 1024];     //接收到的jpeg图片数据
    
27.     byte[] mp3_buf = new byte[1024 * 1024];     //接收到的mp3数据
    
28. 
    
29.     private NotificationManager notificationManager;
    
30. 
    
31.     Thread RecordThread = null;
    
32.     AudioRecord audioRecord = null;
    
33.     byte[] RecordBuffer = new byte[8000 * 20];
    
34.     int RecordBufferLen = 0;
    
35.     int audioSource = MediaRecorder.AudioSource.MIC;
    
36.     //设置音频采样率，44100是目前的标准，但是某些设备仍然支持22050，16000，11025
    
37.     int sampleRateInHz = 8000;
    
38.     //设置音频的录制的声道CHANNEL_IN_STEREO为双声道，CHANNEL_CONFIGURATION_MONO为单声道
    
39.     int channelConfig = AudioFormat.CHANNEL_CONFIGURATION_MONO;
    
40.     //音频数据格式:PCM 16位每个样本。保证设备支持。PCM 8位每个样本。不一定能得到设备支持。
    
41.     int audioFormat = AudioFormat.ENCODING_PCM_8BIT;
    
42.     int bufferSizeInBytes;
    
43. 
    
44.     @Override
    
45.     protected void onCreate(Bundle savedInstanceState) {
    
46.         super.onCreate(savedInstanceState);
    
47.         supportRequestWindowFeature(Window.FEATURE_NO_TITLE);
    
48.         getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON, WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    
49.         setContentView(R.layout.activity_main);
    
50. 
    
51.         main_linear_layout = (LinearLayout)findViewById(R.id.main_linear_layout);
    
52. 
    
53.         image_view = (ImageView)findViewById(R.id.image_view);
    
54.         image_view.setOnClickListener(new View.OnClickListener() {
    
55.             @Override
    
56.             public void onClick(View v) {
    
57.                 big_image_view.setVisibility(View.VISIBLE);
    
58.                 main_linear_layout.setVisibility(View.GONE);
    
59.             }
    
60.         });
    
61.         big_image_view = (ImageView)findViewById(R.id.big_image_view);
    
62.         big_image_view.setOnClickListener(new View.OnClickListener() {
    
63.             @Override
    
64.             public void onClick(View v) {
    
65.                 big_image_view.setVisibility(View.GONE);
    
66.                 main_linear_layout.setVisibility(View.VISIBLE);
    
67.             }
    
68.         });
    
69. 
    
70.         btn_openlock = (Button)findViewById(R.id.btn_openlock);
    
71.         btn_openlock.setOnClickListener(btn_openlock_OnClickListener);
    
72. 
    
73.         btn_setup = (Button)findViewById(R.id.btn_setup);
    
74.         btn_setup.setOnClickListener(btn_setup_OnClickListener);
    
75. 
    
76.         btn_getpic = (Button)findViewById(R.id.btn_getpic);
    
77.         btn_getpic.setOnClickListener(btn_getpic_OnClickListener);
    
78. 
    
79.         btn_record = (Button)findViewById(R.id.btn_record);
    
80. //        btn_record.setOnClickListener(btn_record_OnClickListener);
    
81.         btn_record.setOnTouchListener(btn_record_OnTouchListener);
    
82. 
    
83.         ReadThread.start();
    
84. 
    
85.         // 第一步：通过getSystemService（）方法得到NotificationManager对象；
    
86.         notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    
87. 
    
88.         //动态申请权限，高版本的安卓系统需要动态申请权限才行，只修改manifest文件没用
    
89.         ActivityCompat.requestPermissions(MainActivity.this,new String[]{Manifest.permission.RECORD_AUDIO},0);
    
90.     }
    
91. 
    
92.     //动态申请权限回调函数
    
93.     public void onRequestPermissionsResult(int requestCode,String permissions[], int[] grantResults) {
    
94.         switch (requestCode) {
    
95.             case 0: {
    
96.                 // If request is cancelled, the result arrays are empty.
    
97.                 if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
    
98.                     Log.i("tangquan", "permission RECORD_AUDIO request success");
    
99.                 } else {
    
100.                     Log.i("tangquan", "permission RECORD_AUDIO request failed");
     
101.                 }
     
102.                 return;
     
103.             }
     
104.         }
     
105.     }
     
106. 
     
107.     //帧控制输入一个字节的数据
     
108.     void InputData(byte data)
     
109.     {
     
110.         if(state == 0)
     
111.         {
     
112.             if(IsFrameReady == false)
     
113.             {
     
114.                 if(data == 'T')
     
115.                 {
     
116.                     state = 1;
     
117.                     count = 0;
     
118.                 }
     
119.             }
     
120.         }
     
121.         else if(state == 1)
     
122.         {
     
123.             if(data == '\')
     
124.             {
     
125.                 state = 2;
     
126.             }
     
127.             else if(data == 'Q')
     
128.             {
     
129.                 state = 0;
     
130.                 IsFrameReady = true;
     
131.                 frame_buffLen = count;
     
132.             }
     
133.             else
     
134.             {
     
135.                 frame_buff[count++] = data;
     
136.             }
     
137.         }
     
138.         else if(state == 2)
     
139.         {
     
140.             state = 1;
     
141.             frame_buff[count++] = data;
     
142.         }
     
143.     }
     
144. 
     
145.     void SendFrame(char type,byte[] buff)
     
146.     {
     
147.         byte frame[] = new byte[buff.length * 2];
     
148.         int i,j = 0;        //j用于计数frame的长度
     
149.         frame[j++] =  'T';
     
150.         frame[j++] = (byte)type;
     
151.         for(i=0;i
152.         {
     
153.             if(buff[i] == 'T' || buff[i] == 'Q' || buff[i] == '\')
     
154.             {
     
155.                 frame[j] = '\';        //插入一个转义字符
     
156.                 j++;
     
157.             }
     
158.             frame[j] = buff[i];
     
159.             j++;
     
160.         }
     
161.         frame[j] = 'Q';
     
162.         j++;
     
163.         SocketSendBytes(frame,j);
     
164.     }
     
165. 
     
166.     void SendFrame(char type,byte[] buff,int len)
     
167.     {
     
168.         byte frame[] = new byte[buff.length * 2];
     
169.         int i,j = 0;        //j用于计数frame的长度
     
170.         frame[j++] =  'T';
     
171.         frame[j++] = (byte)type;
     
172.         for(i=0;i
173.         {
     
174.             if(buff[i] == 'T' || buff[i] == 'Q' || buff[i] == '\')
     
175.             {
     
176.                 frame[j] = '\';        //插入一个转义字符
     
177.                 j++;
     
178.             }
     
179.             frame[j] = buff[i];
     
180.             j++;
     
181.         }
     
182.         frame[j] = 'Q';
     
183.         j++;
     
184.         SocketSendBytes(frame,j);
     
185.     }
     
186. 
     
187.     Thread ReadThread = new Thread()
     
188.     {
     
189.         public void run()
     
190.         {
     
191.             socket = new Socket();
     
192.             try
     
193.             {
     
194. //                socket.connect(new InetSocketAddress("192.168.1.106",5000),1000);
     
195.                 socket.connect(new InetSocketAddress("103.76.85.83",5000),1000);
     
196.                 ou = socket.getOutputStream();
     
197.                 in = socket.getInputStream();
     
198. 
     
199.                 SocketSendStr("phone,AAAAEqo7V7dNvVP8,");//发送账号和密码
     
200.                 int len = in.read(raw_data_buff,0,100);//read是阻塞式的，用SocketChannel可以不阻塞
     
201.                 if(len > 0)
     
202.                 {
     
203.                     //需要进行截断，不然直接把result转成字符串那么这个字符串的长度是result的长度
     
204.                     String res_str = new String(Arrays.copyOfRange(raw_data_buff, 0, len));
     
205.                     if(res_str.equals("success"))
     
206.                     {
     
207.                         PostToast("连接成功");
     
208.                     }
     
209.                     else
     
210.                     {
     
211.                         PostToast("账号错误");
     
212.                         socket.close();//关闭socket连接
     
213.                         socket = null;
     
214.                         return;
     
215.                     }
     
216.                 }
     
217.             }
     
218.             catch(Exception e)
     
219.             {
     
220.                 socket = null;
     
221.                 PostToast("连接失败");
     
222.                 return;
     
223.             }
     
224. 
     
225.             while(socket != null)
     
226.             {
     
227.                 try {
     
228.                     int len = in.read(raw_data_buff,0,raw_data_buff.length);
     
229.                     if(len > 0)
     
230.                     {
     
231. //                        PostToast("len:" + String.valueOf(len));
     
232.                         for(int i=0;i
233.                         {
     
234.                             InputData(raw_data_buff[i]);
     
235. 
     
236.                             //是否接受到一帧数据
     
237.                             if(IsFrameReady)
     
238.                             {
     
239.                                 IsFrameReady = false;
     
240. //                                PostToast("get one frame,len:"+String.valueOf(frame_buffLen)+",type:"+String.valueOf((char)frame_buff[0]));
     
241.                                 Log.i("tangquan","get one frame,len:"+String.valueOf(frame_buffLen)+",type:"+String.valueOf((char)frame_buff[0]));
     
242.                                 if((char)frame_buff[0] == 'j')
     
243.                                 {
     
244. //                                    showNotification("tangquan","content","contenttext",0,0);
     
245. 
     
246.                                     for(int j=1;j
247.                                     {
     
248.                                         img_buf[j - 1] = frame_buff[j];
     
249.                                     }
     
250.                                     handler.post(new Runnable()
     
251.                                     {
     
252.                                         @Override
     
253.                                         public void run(){
     
254.                                             bitmap = BitmapFactory.decodeByteArray(img_buf,0,frame_buffLen-1);
     
255.                                             image_view.setImageBitmap(bitmap);
     
256.                                             big_image_view.setImageBitmap(bitmap);
     
257.                                         }
     
258.                                     });
     
259.                                 }
     
260.                                 else if((char)frame_buff[0] == 'm')
     
261.                                 {
     
262.                                     Log.i("tangquan", "get mp3 data");
     
263.                                     for(int j=1;j
264.                                         mp3_buf[j - 1] = frame_buff[j];
     
265. 
     
266.                                     String filename = "a.mp3";
     
267.                                     File file = new File(MainActivity.this.getFilesDir(),filename);
     
268. 
     
269.                                     FileOutputStream outputStream;
     
270.                                     try{
     
271.                                         outputStream = openFileOutput(filename, Context.MODE_PRIVATE);
     
272.                                         outputStream.write(mp3_buf);
     
273.                                         outputStream.close();
     
274.                                     } catch(Exception e) {
     
275.                                         e.printStackTrace();
     
276.                                     }
     
277. 
     
278.                                     Log.i("tangquan", MainActivity.this.getFilesDir()+"/"+filename);
     
279.                                     MediaPlayer mp = new MediaPlayer();
     
280.                                     mp.setDataSource(MainActivity.this.getFilesDir()+"/"+filename);
     
281.                                     mp.prepare();
     
282.                                     mp.start();
     
283.                                 }
     
284.                             }
     
285.                         }
     
286.                     }
     
287.                 } catch (IOException e) {
     
288.                     e.printStackTrace();
     
289.                 }
     
290.                 try {
     
291.                     sleep(10);
     
292.                 } catch (Exception ignored) {}
     
293.             }
     
294.         }
     
295.     };
     
296. 
     
297. 
     
298.     View.OnClickListener btn_openlock_OnClickListener = new View.OnClickListener() {
     
299.         @Override
     
300.         public void onClick(View v) {
     
301.             PostToast("btn_openlock_OnClickListener");
     
302. //            showNotification("tangquan","content","contenttext",0,0);
     
303.             SendFrame('c',"open lock".getBytes());
     
304.         }
     
305.     };
     
306. 
     
307.     View.OnClickListener btn_getpic_OnClickListener = new View.OnClickListener() {
     
308.         @Override
     
309.         public void onClick(View v) {
     
310.             SendFrame('c',"get picture".getBytes());
     
311.         }
     
312.     };
     
313. 
     
314.     View.OnClickListener btn_record_OnClickListener = new View.OnClickListener() {
     
315.         @Override
     
316.         public void onClick(View v) {
     
317.             Log.i("tangquan", "btn_setup press");
     
318.         }
     
319.     };
     
320. 
     
321.     boolean isRecording = false;
     
322.     View.OnTouchListener btn_record_OnTouchListener = new View.OnTouchListener() {
     
323.         @Override
     
324.         public boolean onTouch(View v, MotionEvent event) {
     
325.             if(event.getAction() == MotionEvent.ACTION_DOWN)
     
326.             {
     
327.                 Log.i("tangquan", "btn_record pressed");
     
328.                 RecordThread = new Thread()
     
329.                 {
     
330.                     public void run()
     
331.                     {
     
332.                         // Create a new AudioRecord object to record the audio.
     
333.                         // 获得满足条件的最小缓冲区大小
     
334.                         bufferSizeInBytes = AudioRecord.getMinBufferSize(sampleRateInHz, channelConfig, audioFormat);
     
335.                         Log.i("tangquan", "bufferSizeInBytes:" + String.valueOf(bufferSizeInBytes));
     
336.                         // 创建AudioRecord对象
     
337.                         audioRecord = new AudioRecord(audioSource, sampleRateInHz,channelConfig, audioFormat, bufferSizeInBytes);
     
338.                         if(audioRecord != null)
     
339.                         {
     
340.                             audioRecord.startRecording();
     
341.                             isRecording = true;
     
342.                             RecordBufferLen = 0;
     
343.                             while (isRecording) {
     
344.                                 RecordBufferLen += audioRecord.read(RecordBuffer, RecordBufferLen, bufferSizeInBytes);
     
345.                                 Log.i("tangquan", String.valueOf(RecordBufferLen));
     
346.                             }
     
347.                             audioRecord.stop();
     
348.                             audioRecord.release();// 释放资源
     
349.                             audioRecord = null;
     
350.                         }
     
351.                         else
     
352.                         {
     
353.                             Log.i("tangquan", "create AudioRecord failed");
     
354.                         }
     
355.                     }
     
356.                 };
     
357.                 RecordThread.start();
     
358.             }
     
359.             else if(event.getAction() == MotionEvent.ACTION_UP)
     
360.             {
     
361.                 Log.i("tangquan", "btn_record released");
     
362.                 if(RecordThread != null && audioRecord != null)
     
363.                 {
     
364.                     isRecording = false;
     
365.                     new Thread()
     
366.                     {
     
367.                         public void run()
     
368.                         {
     
369. //                            AudioTrack audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRateInHz, channelConfig, audioFormat,bufferSizeInBytes, AudioTrack.MODE_STREAM);
     
370. //                            audioTrack.play();  //放音
     
371. //                            try {
     
372. //                                audioTrack.write(RecordBuffer, 0, RecordBufferLen);
     
373. //                            } catch (Exception e) {
     
374. //                                Log.e("AudioTrack", "Playback Failed");
     
375. //                            }
     
376.                             SendFrame('p',RecordBuffer,RecordBufferLen);
     
377.                         }
     
378.                     }.start();
     
379.                 }
     
380.             }
     
381.             return false;
     
382.         }
     
383.     };
     
384. 
     
385.     View.OnClickListener btn_setup_OnClickListener = new View.OnClickListener() {
     
386.         @Override
     
387.         public void onClick(View v) {
     
388. 
     
389.         }
     
390.     };
     
391. 
     
392.     void SocketSendBytes(byte[] buff,int len) {
     
393.         send_buff = buff;
     
394.         send_buff_len = len;
     
395. //        Log.i("tangquan", String.valueOf(send_buff_len));
     
396.         new Thread()
     
397.         {
     
398.             @Override
     
399.             public void run() {
     
400.                 if (socket == null)
     
401.                     return;
     
402.                 try {
     
403.                     ou.write(send_buff,0,send_buff_len);
     
404.                 } catch (IOException e) {
     
405.                     e.printStackTrace();
     
406.                 }
     
407.             }
     
408.         }.start();
     
409.     }
     
410. 
     
411.     void SocketSendStr(String str) {
     
412.         send_buff = str.getBytes();
     
413.         new Thread()
     
414.         {
     
415.             @Override
     
416.             public void run() {
     
417.                 if (socket == null)
     
418.                     return;
     
419.                 try {
     
420.                     ou.write(send_buff);
     
421.                 } catch (IOException e) {
     
422.                     e.printStackTrace();
     
423.                 }
     
424.             }
     
425.         }.start();
     
426.     }
     
427. 
     
428.     //在线程中调用Toast会出错，不知道具体原因，但是网上说用 handler.post可以做
     
429.     //所以弄了一个类和一个函数，类是实现了Runnable接口，同时添加了一个字符串变量
     
430.     class MyRunnable implements Runnable
     
431.     {
     
432.         String Message;
     
433.         public MyRunnable(String msg)
     
434.         {
     
435.             Message = msg;
     
436.         }
     
437.         public void run(){
     
438. 
     
439.         }
     
440.     }
     
441.     void PostToast(String msg)
     
442.     {
     
443.         handler.post(new MyRunnable(msg)
     
444.         {
     
445.             @Override
     
446.             public void run(){
     
447.                 Toast.makeText(MainActivity.this, Message, Toast.LENGTH_SHORT).show();
     
448.             }
     
449.         });
     
450.     }
     
451. 
     
452.     // 第二步：对Notification的一些属性进行设置比如：内容，图标，标题，相应notification的动作进行处理等等；
     
453.     public void showNotification(String tickerText, String contentTitle, String contentText, int iconId, int notiId) {
     
454.         Notification myNotify = new Notification();
     
455.         myNotify.icon = R.drawable.lock;
     
456.         myNotify.tickerText = "TickerText:您有新短消息，请注意查收！";
     
457.         myNotify.when = System.currentTimeMillis();
     
458. //        myNotify.flags = Notification.FLAG_NO_CLEAR;// 不能够自动清除  
     
459. //        rv.setTextViewText(R.id.text_content, "hello wrold!");
     
460. //        myNotify.contentView = rv;
     
461.         Intent intent = new Intent(Intent.ACTION_MAIN);
     
462.         PendingIntent contentIntent = PendingIntent.getActivity(this, 1,intent, FLAG_UPDATE_CURRENT);
     
463.         myNotify.contentIntent = contentIntent;
     
464.         notificationManager.notify(2, myNotify);
     
465.     }
     
466. 
     
467.     // 6步:使用notificationManager对象的cancelAll()方法取消
     
468.     public void clearNoti(View v) {
     
469.         notificationManager.cancelAll();// 清除所有
     
470.     }
     
471. }
     

复制代码

至此家庭控制器已经做完了，可以进行家庭拍照和家庭语言对讲，唯一的不足时PCB做错了，这点真的很懊恼，PCB制版费还真不便宜，诶。这一个月的使用我对NanoPi有一些小感触，不得不说NanoPi的做工真的很好，说实话我不是可以夸大NanoPi贬低Orangepi，NanoPi的做工比Orangepi好很多，我看了一下板子的布线，NanoPi以如此小的面积布出这样的板子实在是厉害，真的很喜欢NanoPi NEO2，太小了太强大了，希望后面能够使用NEO2做更多有趣的东西，谢谢电子发烧友提供的机会！

楼主有视频嘛？

小麦地 发表于 2017-7-18 09:35
楼主有视频嘛？

没拍呢，没想过有人想看我的这个的视频，哈哈，做的很挫。

牛，利害了楼主！！！！

我顶呀，学习喽