diff --git a/bsp/bsp_common/audio/audio_core.c b/bsp/bsp_common/audio/audio_core.c deleted file mode 100644 index 27ac7266..00000000 --- a/bsp/bsp_common/audio/audio_core.c +++ /dev/null @@ -1,78 +0,0 @@ -/** - * @file audio_proto.c - * - * Copyright (c) 2021 Bouffalolab team - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. The - * ASF licenses this file to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance with the - * License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - * - */ -#include "drv_device.h" -#include "audio_core.h" -#include "hal_dma.h" - -volatile int (*buffer_ready_callback_func)(char bufIndex); -volatile audio_core_t * audio_core_cfg_store; -volatile int bufferIndex = 0; - -void audio_core_transfer_done(struct device *dev, void *args, uint32_t size, uint32_t state){ - - if(!state){ - if(buffer_ready_callback_func){ - buffer_ready_callback_func(bufferIndex); - } - - if(bufferIndex){ - bufferIndex = 0; - device_write(audio_core_cfg_store->audio_device,0,audio_core_cfg_store->buff1,audio_core_cfg->buff_size); - }else{ - bufferIndex = 1; - device_write(audio_core_cfg_store->audio_device,0,audio_core_cfg_store->buff2,audio_core_cfg->buff_size); - } - } -} - -int audio_core_init(audio_core_t * audio_core_cfg){ - - if(audio_core_cfg->audio_dma == NULL || - audio_core_cfg->buff_size == NULL|| - audio_core_cfg->buff1 == NULL || - audio_core_cfg->buff2 == NULL){ - return -1; - } - - - memset(audio_core_cfg->buff1,0,audio_core_cfg->buff_size); - memset(audio_core_cfg->buff2,0,audio_core_cfg->buff_size); - - device_control(audio_core_cfg->audio_device,DEVICE_CTRL_ATTACH_TX_DMA,(void*)audio_core_cfg->audio_dma); - - device_set_callback(audio_core_cfg->audio_dma, audio_core_transfer_done); - - buffer_ready_callback_func = audio_core_cfg->buffer_ready_callback; - audio_core_cfg_store = audio_core_cfg; - - device_control(audio_core_cfg->audio_dma, DEVICE_CTRL_SET_INT, NULL); - -} - -int audio_core_start(void){ - device_write(audio_core_cfg_store->audio_device,0,audio_core_cfg_store->buff1,audio_core_cfg_store->buff_size); -} - -int audio_core_stop(void){ - dma_channel_stop(audio_core_cfg_store->audio_dma); -} - diff --git a/bsp/bsp_common/audio/bl_audio_structure.md b/bsp/bsp_common/audio/bl_audio_structure.md deleted file mode 100644 index 86497707..00000000 --- a/bsp/bsp_common/audio/bl_audio_structure.md +++ /dev/null @@ -1,42 +0,0 @@ -# bl音频协议框架 - -## 核心音频播放组件 - -如下图所示 - -[![c1Q8qe.jpg](https://z3.ax1x.com/2021/04/06/c1Q8qe.jpg)](https://imgtu.com/i/c1Q8qe) - - -整体框架分为两个部分，一个部分是由核心组件提供的双缓存结构，另一个部分是用户的实际使用代码。 - -**核心组件需要两个构件** - -1 双缓存，用户需要在自己的应用中开辟两块长度相同的内存块，将其指针传入核心组件。 - -2 dma组件，用户需要将配置好了的 dma device 指针传入核心组件，此dma的作用是将设备的数据通过P->M写回Buffer 或者 将数据通过M->P写入Device。搬运的request需要在device的配置参数中给定。 - - - -**核心组件后的运行逻辑** - -当用户打开音频构架的核心组件代码后 -组件会首先初始化Buffer1和Buffer2的内容，初始化为0，并且立即打开DMA搬运。 -当DMA搬运结束，会触发Buffer_Ready中断回调。 - -在录音的应用下 - -打开核心组件后，DMA会根据Device的DMA Request，把录音数据搬运到Buffer1和Buffer2，用户需要做的是在Buffer_Ready中断回调发生后，将对应Buffer取出来，保存、或者通过下文提到的协议发送。 - -在播放音频的应用下 - -打开核心组件后，DMA会立即播放Buffer1和Buffer2的数据，但是因为最开始的时候已经初始化Buffer数据为0，所以不会有任何声音播放。用户需要在Buffer_Ready中断回调发生后，以合适的方式，将需要播放的PCM音频数据更新到Buffer中（此过程必须在下一个Buffer消耗完成之前，否则会产生问题），如果在buffer2的数据消耗结束之前还没能完成buffer1的数据更新，那么需要考虑如何加快数据更新速度，或者增加Buffer的size以提供更多操作时间。 - - -## 2 通讯协议约定 - -当用户代码部分需要与外界进行通讯时，需要统一规范一个交互的协议，这样不同的音频应用可以兼容相同的audio_cube。 - -1 传输音频文件流（目前仅支持wav格式播放） -2 每次传输的字节数，使用规范的约定字节数 -3 是否支持校验 -4 播放/暂停 停止 音量调整的固定协议 \ No newline at end of file diff --git a/bsp/bsp_common/audio/wav_info_parser.c b/bsp/bsp_common/audio/wav_info_parser.c deleted file mode 100644 index 8cf00117..00000000 --- a/bsp/bsp_common/audio/wav_info_parser.c +++ /dev/null @@ -1,76 +0,0 @@ -/** - * @file wav_info_parser.c - * @brief - * - * Copyright (c) 2021 Bouffalolab team - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. The - * ASF licenses this file to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance with the - * License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - * - */ - -#include "wav_info_parser.h" - -/* get File pointer from top of file*/ -int wav_data_parser(uint8_t buff[1024], wav_information_t *wav_information) -{ - uint32_t offset=0; - uint32_t chunk_id; - - /* RIFF WAVE Chunk */ - chunk_id = ((chunk_riff_t *)&buff[offset])->chunk_id; - if(chunk_id == 0x46464952) - { - wav_information->chunk_riff_offset = offset; - wav_information->chunk_riff = *((chunk_riff_t *)&buff[offset]); - offset += sizeof(chunk_riff_t); - }else{ - wav_information->chunk_riff_offset = -1; - return 1; - } - /* Format Chunk */ - chunk_id = ((chunk_format_t *)&buff[offset])->chunk_id; - if(chunk_id == 0x20746D66 && offset<1000) /* fmt */ - { - wav_information->chunk_format_offset = offset; - wav_information->chunk_format = *((chunk_format_t *)&buff[offset]); - offset += ((chunk_format_t*)&buff[offset])->chunk_size + 8; - }else - { - wav_information->chunk_format_offset = -1; - return 1; - } - /* Fact/list Chunk */ - chunk_id = ((chunk_fact_t *)&buff[offset])->chunk_id; - if((chunk_id == 0X74636166 || chunk_id == 0X5453494C) && offset<1000) /*fact or list*/ - { - wav_information->chunk_fact_offset = offset; - wav_information->chunk_fact = *((chunk_fact_t *)&buff[offset]); - offset += ((chunk_fact_t*)&buff[offset])->chunk_size + 8; - }else{ - wav_information->chunk_fact_offset = -1; - } - /* Data Chunk */ - chunk_id = ((chunk_data_t *)&buff[offset])->chunk_id; - if(chunk_id == 0X61746164 && offset<1000 ) - { - wav_information->chunk_data_offset = offset; - wav_information->chunk_data = *((chunk_data_t *)&buff[offset]); - }else{ - wav_information->chunk_data_offset = -1; - return 1; - } - return 0; -} \ No newline at end of file diff --git a/bsp/bsp_common/audio/wav_info_parser.h b/bsp/bsp_common/audio/wav_info_parser.h deleted file mode 100644 index 608401c5..00000000 --- a/bsp/bsp_common/audio/wav_info_parser.h +++ /dev/null @@ -1,89 +0,0 @@ -/** - * @file wav_info_parser.h - * @brief - * - * Copyright (c) 2021 Bouffalolab team - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. The - * ASF licenses this file to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance with the - * License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - * - */ - -#ifndef __WAV_INFO_PARSER__ -#define __WAV_INFO_PARSER__ - -#include "bl_common.h" - -/* RIFF (RIFF WAVE Chunk) */ -typedef struct __attribute__((packed)) -{ - uint32_t chunk_id; - uint32_t chunk_size; - uint32_t format; -}chunk_riff_t ; - -/* fmt (Format Chunk)*/ -typedef struct __attribute__((packed)) -{ - uint32_t chunk_id; - uint32_t chunk_size ; - uint16_t audio_format; - uint16_t num_of_channels; - uint32_t sample_rate; - uint32_t byte_rate; - uint16_t block_align; - uint16_t bits_per_sample; -}chunk_format_t; - -//fact (Fact Chunk) -typedef struct __attribute__((packed)) -{ - uint32_t chunk_id; - uint32_t chunk_size ; - uint32_t data_fact_size; -}chunk_fact_t; - -//data (Data Chunk) -typedef struct __attribute__((packed)) -{ - uint32_t chunk_id; - uint32_t chunk_size ; -}chunk_data_t; - -// -typedef enum -{ - CHUNK_RIFF, - CHUNK_FORMAT, - CHUNK_FACT, - CHUNK_DATA, -}mav_chunk_t; - -//.wav information -typedef struct -{ - int chunk_riff_offset; - chunk_riff_t chunk_riff; - int chunk_format_offset; - chunk_format_t chunk_format; - int chunk_fact_offset; - chunk_fact_t chunk_fact; - int chunk_data_offset; - chunk_data_t chunk_data; -}wav_information_t; - -int wav_data_parser(uint8_t buff[1024], wav_information_t *wav_information); - -#endif \ No newline at end of file diff --git a/bsp/bsp_common/il9341/bsp_il9341.c b/bsp/bsp_common/il9341/bsp_il9341.c index 218d6104..99a06b22 100644 --- a/bsp/bsp_common/il9341/bsp_il9341.c +++ b/bsp/bsp_common/il9341/bsp_il9341.c @@ -24,6 +24,7 @@ #include "bsp_il9341.h" #include "hal_spi.h" #include "hal_dma.h" + /** @addtogroup BL702_Peripheral_Case * @{ */ @@ -66,9 +67,14 @@ * @{ */ -struct device* spi0; -struct device* dma_ch3; -struct device* dma_ch4; +static struct device* spi0; +static struct device* dma_ch3; +static struct device* dma_ch4; + +void dma_ch3_callback(struct device *dev, void *args, uint32_t size, uint32_t event) +{ + +} /*@} end of group TFT_LCD_Private_Functions */ @@ -77,43 +83,64 @@ struct device* dma_ch4; */ void spi0_init(void) { - - spi_register(SPI0_INDEX,"spi0",DEVICE_OFLAG_RDWR); - dma_register(DMA0_CH3_INDEX, "dma0_ch3", DEVICE_OFLAG_RDWR); - dma_register(DMA0_CH4_INDEX, "dma0_ch4", DEVICE_OFLAG_RDWR); gpio_set_mode(LCD_CS_PIN,GPIO_OUTPUT_MODE); gpio_set_mode(LCD_DC_PIN,GPIO_OUTPUT_MODE); gpio_write(LCD_CS_PIN,1); //CS1 - gpio_write(LCD_DC_PIN,1);//DC + gpio_write(LCD_DC_PIN,1); //DC + spi0 = device_find("spi0"); if(spi0) + { + device_close(spi0); + } + else{ + spi_register(SPI0_INDEX,"spi0",DEVICE_OFLAG_RDWR); + spi0 = device_find("spi0"); + } + if(spi0) { device_open(spi0,DEVICE_OFLAG_STREAM_TX|DEVICE_OFLAG_STREAM_RX); } dma_ch3 = device_find("dma0_ch3"); + if(dma_ch3) + { + device_close(dma_ch3); + } + else{ + dma_register(DMA0_CH3_INDEX, "dma0_ch3", DEVICE_OFLAG_RDWR); + dma_ch3 = device_find("dma0_ch3"); + } if (dma_ch3) { - ((dma_device_t*)dma_ch3)->direction = DMA_MEMORY_TO_PERIPH; - ((dma_device_t*)dma_ch3)->transfer_mode = DMA_LLI_ONCE_MODE; - ((dma_device_t*)dma_ch3)->src_req = DMA_REQUEST_NONE; - ((dma_device_t*)dma_ch3)->dst_req = DMA_REQUEST_SPI0_TX; - ((dma_device_t*)dma_ch3)->src_width = DMA_TRANSFER_WIDTH_8BIT; - ((dma_device_t*)dma_ch3)->dst_width = DMA_TRANSFER_WIDTH_8BIT; + DMA_DEV(dma_ch3)->direction = DMA_MEMORY_TO_PERIPH; + DMA_DEV(dma_ch3)->transfer_mode = DMA_LLI_ONCE_MODE; + DMA_DEV(dma_ch3)->src_req = DMA_REQUEST_NONE; + DMA_DEV(dma_ch3)->dst_req = DMA_REQUEST_SPI0_TX; + DMA_DEV(dma_ch3)->src_width = DMA_TRANSFER_WIDTH_8BIT; + DMA_DEV(dma_ch3)->dst_width = DMA_TRANSFER_WIDTH_8BIT; device_open(dma_ch3, 0); device_set_callback(dma_ch3, NULL); device_control(dma_ch3, DEVICE_CTRL_SET_INT, NULL); } dma_ch4 = device_find("dma0_ch4"); + if(dma_ch4) + { + device_close(dma_ch4); + } + else{ + dma_register(DMA0_CH4_INDEX, "dma0_ch4", DEVICE_OFLAG_RDWR); + dma_ch4 = device_find("dma0_ch4"); + } if (dma_ch4) { - ((dma_device_t*)dma_ch4)->direction = DMA_PERIPH_TO_MEMORY; - ((dma_device_t*)dma_ch4)->transfer_mode = DMA_LLI_ONCE_MODE; - ((dma_device_t*)dma_ch4)->src_req = DMA_REQUEST_SPI0_RX; - ((dma_device_t*)dma_ch4)->dst_req = DMA_REQUEST_NONE; - ((dma_device_t*)dma_ch4)->src_width = DMA_TRANSFER_WIDTH_8BIT ; - ((dma_device_t*)dma_ch4)->dst_width = DMA_TRANSFER_WIDTH_8BIT ; + DMA_DEV(dma_ch4)->direction = DMA_PERIPH_TO_MEMORY; + DMA_DEV(dma_ch4)->transfer_mode = DMA_LLI_ONCE_MODE; + DMA_DEV(dma_ch4)->src_req = DMA_REQUEST_SPI0_RX; + DMA_DEV(dma_ch4)->dst_req = DMA_REQUEST_NONE; + DMA_DEV(dma_ch4)->src_width = DMA_TRANSFER_WIDTH_8BIT ; + DMA_DEV(dma_ch4)->dst_width = DMA_TRANSFER_WIDTH_8BIT ; device_open(dma_ch4, 0); device_set_callback(dma_ch4, NULL); device_control(dma_ch4, DEVICE_CTRL_CLR_INT, NULL); @@ -187,6 +214,50 @@ void LCD_WR_Word(uint32_t data) CS1_HIGH; } +void LCD_WR_SPI_DMA(uint16_t *img, uint32_t len) +{ + DMA_DEV(dma_ch3)->src_width = DMA_TRANSFER_WIDTH_32BIT; + DMA_DEV(dma_ch3)->src_burst_size =0; + DMA_DEV(dma_ch3)->dst_burst_size =1; + device_control(spi0,DEVICE_CTRL_TX_DMA_RESUME,NULL); + CS1_LOW; + DC_HIGH; + dma_reload(dma_ch3, (uint32_t)img, (uint32_t)DMA_ADDR_SPI_TDR, len); + dma_channel_start(dma_ch3); + while(dma_channel_check_busy(dma_ch3)); + device_control(spi0,DEVICE_CTRL_TX_DMA_SUSPEND,NULL); + CS1_HIGH; +} + +/****************************************************************************//** + * @brief LCD set dir + * + * @param dir: dir + * + * @return None + * +*******************************************************************************/ +void LCD_Set_Dir(uint8_t dir ) +{ + LCD_WR_Cmd(0x36); + switch (dir) + { + case 0 : + LCD_WR_Byte(0x08); + break; + case 1 : + LCD_WR_Byte(0xA8); + break; + case 2 : + LCD_WR_Byte(0xC8); + break; + case 3 : + LCD_WR_Byte(0x68); + break; + default: + break; + } +} /****************************************************************************//** * @brief LCD set address @@ -201,6 +272,7 @@ void LCD_WR_Word(uint32_t data) *******************************************************************************/ void LCD_Set_Addr(uint32_t x1,uint32_t y1,uint32_t x2,uint32_t y2) { + LCD_WR_Cmd(0x2a); LCD_WR_Word(x2<<24 | (x2<<8&0xff0000) | (x1<<8&0xff00) | (x1>>8&0xff)); @@ -265,6 +337,8 @@ void LCD_Init(void) LCD_WR_HalfWord(0x1800); LCD_WR_Cmd(0xb6); /* Display Function Control */ LCD_WR_HalfWord(0xa20a); + LCD_WR_Cmd(0x0c); /* display pixel format */ + LCD_WR_Byte(0xd5); /* RGB 16bits,MCU 16bits */ LCD_WR_Cmd(0xf2); /* 3Gamma Function Disable */ LCD_WR_Byte(0x00); LCD_WR_Cmd(0xf7); @@ -474,6 +548,17 @@ void LCD_DrawPicture(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2,uint16_t* p } } +void LCD_DrawPicture_cam(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2,uint16_t* picture) +{ + uint32_t i; + LCD_Set_Addr(x1,y1,x2,y2); + for(i=0;i>8&0xff)); - - LCD_WR_Cmd(0x2b); - LCD_WR_Word(y2<<24 | (y2<<8&0xff0000) | (y1<<8&0xff00) | (y1>>8&0xff)); - - LCD_WR_Cmd(0x2C); -} - - -/****************************************************************************//** - * @brief SPI LCD init - * - * @param None - * - * @return None - * -*******************************************************************************/ -void LCD_Init(void) -{ - spi_lcd_init(); - - LCD_WR_Cmd(0x11); /* Exit sleep */ - bflb_platform_delay_ms(60); - - LCD_WR_Cmd(0xcf); - LCD_WR_HalfWord(0xd900); - LCD_WR_Byte(0X30); - - LCD_WR_Cmd(0xed); - LCD_WR_Word(0x81120364); - - LCD_WR_Cmd(0xe8); - LCD_WR_HalfWord(0x1085); - LCD_WR_Byte(0x78); - - LCD_WR_Cmd(0xcb); - LCD_WR_Word(0x34002c39); - LCD_WR_Byte(0x02); - - LCD_WR_Cmd(0xf7); - LCD_WR_Byte(0x20); - - LCD_WR_Cmd(0xea); - LCD_WR_HalfWord(0x0000); - - LCD_WR_Cmd(0xc0); /* Power control */ - LCD_WR_Byte(0x23); /* VRH[5:0] */ - LCD_WR_Cmd(0xc1); /* Power control */ - LCD_WR_Byte(0x12); /* SAP[2:0];BT[3:0] */ - LCD_WR_Cmd(0xc2); - LCD_WR_Byte(0x11); - LCD_WR_Cmd(0xC5); /* VCM control */ - LCD_WR_HalfWord(0x3040); - LCD_WR_Cmd(0xc7); /* VCM control2 */ - LCD_WR_Byte(0xa9); - LCD_WR_Cmd(0x3a); - LCD_WR_Byte(0x55); - LCD_WR_Cmd(0x36); /* Memory Access Control */ - LCD_WR_Byte(0x08); - LCD_WR_Cmd(0xb1); /* Frame Rate Control */ - LCD_WR_HalfWord(0x1800); - LCD_WR_Cmd(0xb6); /* Display Function Control */ - LCD_WR_HalfWord(0xa20a); - LCD_WR_Cmd(0xf2); /* 3Gamma Function Disable */ - LCD_WR_Byte(0x00); - LCD_WR_Cmd(0xf7); - LCD_WR_Byte(0x20); - LCD_WR_Cmd(0x26); /* Gamma curve selected */ - LCD_WR_Byte(0x01); - LCD_WR_Cmd(0xe0); /* Set Gamma */ - LCD_WR_Word(0x0b23241f); - LCD_WR_Word(0xd850080f); - LCD_WR_Word(0x000a083b); - LCD_WR_HalfWord(0x0000); - LCD_WR_Byte(0x00); - LCD_WR_Cmd(0Xe1); /* Set Gamma */ - LCD_WR_Word(0x041c1b00); - LCD_WR_Word(0x272f0710); - LCD_WR_Word(0x0f150744); - LCD_WR_HalfWord(0x3f3f); - LCD_WR_Byte(0x1f); - LCD_WR_Cmd(0x29); /* Display on */ -} - - -/****************************************************************************//** - * @brief LCD clear display - * - * @param color: Color to fill - * - * @return None - * -*******************************************************************************/ -void LCD_Clear(uint16_t color) -{ - uint16_t i,j; - LCD_Set_Addr(0,0,LCD_W-1,LCD_H-1); - for(i=0;i absY){ - for(i=0;i0){ - LCD_DrawPoint(x1+i,y1+temp,color); - }else{ - LCD_DrawPoint(x1-i,y1+temp,color); - } - } - } - else{ - for(i=0;i0){ - LCD_DrawPoint(x1+temp,y1+i,color); - }else{ - LCD_DrawPoint(x1+temp,y1-i,color); - } - } - } -} - - -/****************************************************************************//** - * @brief LCD draw rectangle - * - * @param x1: Coordinate x start - * @param y1: Coordinate y start - * @param x2: Coordinate x end - * @param y2: Coordinate y end - * @param color: Color of the rectangle - * - * @return None - * -*******************************************************************************/ -void LCD_DrawRectangle(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2,uint16_t color) -{ - LCD_DrawLine(x1,y1,x2,y1,color); - LCD_DrawLine(x2,y1,x2,y2,color); - LCD_DrawLine(x2,y2,x1,y2,color); - LCD_DrawLine(x1,y2,x1,y1,color); -} - - -/****************************************************************************//** - * @brief LCD draw circle - * - * @param x: Center coordinate x - * @param y: Center coordinate y - * @param r: Radius - * @param color: Color of the circle - * - * @return None - * -*******************************************************************************/ -void LCD_DrawCircle(uint16_t x,uint16_t y,uint16_t r,uint16_t color) -{ - int a = 0,b; - int di; - b = r; - di = 3-(r<<1); - while(a <= b) - { - LCD_DrawPoint(x-b,y-a,color); - LCD_DrawPoint(x+b,y-a,color); - LCD_DrawPoint(x-a,y+b,color); - LCD_DrawPoint(x-b,y-a,color); - LCD_DrawPoint(x-a,y-b,color); - LCD_DrawPoint(x+b,y+a,color); - LCD_DrawPoint(x+a,y-b,color); - LCD_DrawPoint(x+a,y+b,color); - LCD_DrawPoint(x-b,y+a,color); - a++; - if(di<0){ - di += 4*a+6; - }else{ - di += 10+4*(a-b); - b--; - } - LCD_DrawPoint(x+a,y+b,color); - } -} - - -/****************************************************************************//** - * @brief LCD fill the area with color - * - * @param x1: Coordinate x start - * @param y1: Coordinate y start - * @param x2: Coordinate x end - * @param y2: Coordinate y end - * @param color: Color to fill - * - * @return None - * -*******************************************************************************/ -void LCD_DrawArea(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2,uint16_t color) -{ - uint16_t i,j; - LCD_Set_Addr(x1,y1,x2,y2); - for(i=y1;i<=y2;i++) - { - for(j=x1;j<=x2;j++)LCD_WR_HalfWord(color); - } -} - - -/****************************************************************************//** - * @brief LCD draw picture - * - * @param x1: Coordinate x start - * @param y1: Coordinate y start - * @param x2: Coordinate x end - * @param y2: Coordinate y end - * @param picture: Color array of the picture - * - * @return None - * -*******************************************************************************/ -void LCD_DrawPicture(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2,uint16_t* picture) -{ - uint32_t i; - LCD_Set_Addr(x1,y1,x2,y2); - for(i=0;i>3)<<3|(g>>5)|(g>>2)<<13|(b>>3)<<8)&0xffff) -/* Calculate 32-bit or 16-bit absolute value */ -#define ABS32(value) ((value^(value>>31))-(value>>31)) -#define ABS16(value) ((value^(value>>15))-(value>>15)) - -/*@} end of group TFT_LCD_Public_Macros */ - -/** @defgroup TFT_LCD_Public_Functions - * @{ - */ - -/** - * @brief Tft_lcd Functions - */ -void LCD_WR_Cmd(uint8_t command); -void LCD_WR_Byte(uint8_t data); -void LCD_WR_HalfWord(uint16_t data); -void LCD_WR_Word(uint32_t data); -void LCD_Set_Addr(uint32_t x1,uint32_t y1,uint32_t x2,uint32_t y2); -void LCD_Init(void); -void LCD_Clear(uint16_t color); -void LCD_DrawPoint(uint16_t x,uint16_t y,uint16_t color); -void LCD_DrawLine(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2,uint16_t color); -void LCD_DrawRectangle(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2,uint16_t color); -void LCD_DrawCircle(uint16_t x,uint16_t y,uint16_t r,uint16_t color); -void LCD_DrawArea(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2,uint16_t color); -void LCD_DrawPicture(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2,uint16_t* picture); -// void LCD_UartDrawPicture(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2,UART_ID_Type uartId); -void LCD_DrawChinese(uint16_t x,uint16_t y,uint8_t* character,uint16_t bColor,uint16_t cColor); - -/*@} end of group TFT_LCD_Public_Functions */ - -/*@} end of group TFT_LCD */ - -/*@} end of group BL702_Peripheral_Driver */ - -#endif /* __TFT_LCD_H__ */ diff --git a/bsp/bsp_common/image_sensor/bsp_image_sensor.c b/bsp/bsp_common/image_sensor/bsp_image_sensor.c new file mode 100644 index 00000000..06851664 --- /dev/null +++ b/bsp/bsp_common/image_sensor/bsp_image_sensor.c @@ -0,0 +1,835 @@ +/** + * @file bsp_gc0308.c + * @brief + * + * Copyright (c) 2021 Bouffalolab team + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. The + * ASF licenses this file to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + * + */ +#include "bsp_image_sensor.h" +#include "bl702_glb.h" +#include "hal_gpio.h" +#include "hal_timer.h" +#include "hal_i2c.h" +#include "hal_cam.h" +#include "hal_mjpeg.h" +#include "hal_clock.h" + +#define IMAGE_SENSOR_BF2013 0 +#define IMAGE_SENSOR_GC0308 1 +#define IMAGE_SENSOR_USE IMAGE_SENSOR_GC0308 + +/* sensor out format */ +#define RGB565 0 +#define UYVY 1 +#define FORMAT_SEL RGB565 + +#if (IMAGE_SENSOR_USE == IMAGE_SENSOR_BF2013) +#define I2C_CAMERA_ADDR 0x6E +#define BF2013_ID_MSB 0xFC +#define BF2013_ID_LSB 0xFD +#elif (IMAGE_SENSOR_USE == IMAGE_SENSOR_GC0308) +#define I2C_CAMERA_ADDR 0x21 +#define GC0308_ID 0x00 +#endif + +struct device *image_sensor_i2c = NULL; + +static const uint8_t sensorRegList[][2] = + { +#if (IMAGE_SENSOR_USE == IMAGE_SENSOR_BF2013) + {0x12, 0x80}, + {0x67, 0x00}, + {0x68, 0x00}, + //{0xb9, 0x80},//use Test pattern + //{0x69,0x20}, + {0x3a, 0x02}, + {0x09, 0x01}, + {0x15, 0x02}, + {0x12, 0x00}, + {0x1e, 0x00}, + {0x13, 0x00}, + {0x01, 0x14}, + {0x02, 0x21}, + {0x8c, 0x02}, + {0x8d, 0x64}, + {0x87, 0x18}, + {0x13, 0x07}, + //{0x11,0x80},//pclk=mclk + {0x11, 0x30}, //pclk=mclk/8 + {0x2b, 0x20}, + {0x92, 0x40}, + {0x9d, 0x99}, + {0x06, 0xe0}, + {0x29, 0x54}, + {0xeb, 0x30}, + {0xbb, 0x20}, + {0xf5, 0x21}, + {0xe1, 0x3c}, + {0x16, 0x01}, + {0xe0, 0x0b}, + {0x2f, 0xf6}, + {0x33, 0x20}, + {0x34, 0x08}, + {0x35, 0x50}, + {0x65, 0x4a}, + {0x66, 0x50}, + {0x36, 0x05}, + {0x37, 0xf6}, + {0x38, 0x46}, + {0x9b, 0xf6}, + {0x9c, 0x46}, + {0xbc, 0x01}, + {0xbd, 0xf6}, + {0xbe, 0x46}, + {0x82, 0x14}, + {0x83, 0x23}, + {0x9a, 0x23}, + {0x70, 0x6f}, + {0x72, 0x3f}, + {0x73, 0x3f}, + {0x74, 0x27}, + {0x77, 0x90}, + {0x79, 0x48}, + {0x7a, 0x1e}, + {0x7b, 0x30}, + {0x84, 0x1a}, + {0x85, 0x20}, + {0x89, 0x02}, + {0x8a, 0x64}, + {0x86, 0x30}, + {0x96, 0xa6}, + {0x97, 0x0c}, + {0x98, 0x18}, + {0x80, 0x55}, + {0x24, 0x70}, + {0x25, 0x80}, + {0x94, 0x0a}, + {0x1f, 0x20}, + {0x22, 0x20}, + {0x26, 0x20}, + {0x56, 0x40}, + {0x61, 0xd3}, + {0x79, 0x48}, + {0x3b, 0x60}, + {0x3c, 0x20}, + {0x39, 0x80}, + {0x3f, 0xb0}, + {0x39, 0x80}, + {0x40, 0x58}, + {0x41, 0x54}, + {0x42, 0x4e}, + {0x43, 0x44}, + {0x44, 0x3e}, + {0x45, 0x39}, + {0x46, 0x35}, + {0x47, 0x31}, + {0x48, 0x2e}, + {0x49, 0x2b}, + {0x4b, 0x29}, + {0x4c, 0x27}, + {0x4e, 0x23}, + {0x4f, 0x20}, + {0x50, 0x1e}, + {0x51, 0x05}, + {0x52, 0x10}, + {0x53, 0x0b}, + {0x54, 0x15}, + {0x57, 0x87}, + {0x58, 0x72}, + {0x59, 0x5f}, + {0x5a, 0x7e}, + {0x5b, 0x1f}, + {0x5c, 0x0e}, + {0x5d, 0x95}, + {0x60, 0x28}, + {0xb0, 0xe0}, + {0xb1, 0xc0}, + {0xb2, 0xb0}, + {0xb3, 0x88}, + {0x6a, 0x01}, + {0x23, 0x66}, + {0xa0, 0x03}, + {0xa1, 0x31}, + {0xa2, 0x0b}, + {0xa3, 0x26}, + {0xa4, 0x05}, + {0xa5, 0x25}, + {0xa6, 0x06}, + {0xa7, 0x80}, + {0xa8, 0x80}, + {0xa9, 0x20}, + {0xaa, 0x20}, + {0xab, 0x20}, + {0xac, 0x3c}, + {0xad, 0xf0}, + {0xc8, 0x18}, + {0xc9, 0x20}, + {0xca, 0x17}, + {0xcb, 0x1f}, + {0xaf, 0x00}, + {0xc5, 0x18}, + {0xc6, 0x00}, + {0xc7, 0x20}, + {0xae, 0x80}, + {0xcc, 0x40}, + {0xcd, 0x58}, + {0xee, 0x4c}, + {0x8e, 0x07}, + {0x8f, 0x79}, + +#elif (IMAGE_SENSOR_USE == IMAGE_SENSOR_GC0308) + {0xfe, 0x80}, + {0xfe, 0x00}, //set page0 + {0xd2, 0x00}, //close/en AEC; d2[7] set 1b'0 en AEC + {0x22, 0x55}, //close AWB + {0x5a, 0x56}, + {0x5b, 0x40}, + {0x5c, 0x4a}, + {0x22, 0x57}, //Open AWB +#if 0 + //config for 39 FPS + {0x01 , 0x6a},//HB 106 + //{0x02 , 0x70},//VB 112 + {0x02 , 0x0c},//change VB from 112 to 12 + {0x0f , 0x00}, + {0xe2 , 0x00},//anti-flicker step [11:8] + {0xe3 , 0x96},//anti-flicker step [7:0] + {0xe4 , 0x01},//exp level 1 50.00fps or 20ms + {0xe5 , 0x2c}, + {0xe6 , 0x03},//exp level 2 16.67fps + {0xe7 , 0x84}, + {0xe8 , 0x04},//exp level 3 12.5fps + {0xe9 , 0xb0}, + {0xea , 0x09},//exp level 4 6.00fps + {0xeb , 0xc4}, +#elif 0 + //config for 33.33 FPS + {0x01, 0x6a}, //HB 106 + {0x02, 0x52}, //VB 82 + {0x0f, 0x00}, + {0xe2, 0x00}, //anti-flicker step [11:8] + {0xe3, 0x96}, //anti-flicker step [7:0] + {0xe4, 0x01}, //exp level 1 33.33fps or 30ms + {0xe5, 0x2c}, + {0xe6, 0x03}, //exp level 2 16.67fps + {0xe7, 0x84}, + {0xe8, 0x04}, //exp level 3 12.5fps + {0xe9, 0xb0}, + {0xea, 0x09}, //exp level 4 6.00fps + {0xeb, 0xc4}, +#else + //config for 25 FPS + {0x01, 0x6a}, //HB 106 + //{0x02 , 0x70},//VB 112 + {0x02, 0xe8}, //change VB from 112 to 232 + {0x0f, 0x00}, + {0xe2, 0x00}, //anti-flicker step [11:8] + {0xe3, 0x96}, //anti-flicker step [7:0] + {0xe4, 0x02}, //exp level 1 25.00fps or 40ms + {0xe5, 0x58}, + {0xe6, 0x03}, //exp level 2 16.67fps + {0xe7, 0x84}, + {0xe8, 0x04}, //exp level 3 12.5fps + {0xe9, 0xb0}, + {0xea, 0x09}, //exp level 4 6.00fps + {0xeb, 0xc4}, +#endif + {0xec, 0x20}, //select max exposure level 1 - highest fps + {0xed, 0x04}, //set AEC select exp min + {0x05, 0x00}, + {0x06, 0x00}, + {0x07, 0x00}, + {0x08, 0x00}, + {0x09, 0x01}, + {0x0a, 0xe8}, + //{0x0a , 0x70},//change win_height from 488 to 368 + {0x0b, 0x02}, + {0x0c, 0x88}, //win_width 648 + {0x0d, 0x02}, + {0x0e, 0x02}, + {0x10, 0x22}, + {0x11, 0xfd}, + {0x12, 0x2a}, + {0x13, 0x00}, + //{0x14 , 0x10}, + {0x14, 0x13}, //enable mirror & flip + //-------------H_V_Switch(4)---------------// + /* + 1://normal + {0x14 , 0x10}, + 2://IMAGE_H_MIRROR + {0x14 , 0x11}, + 3://IMAGE_V_MIRROR + {0x14 , 0x12}, + 4://IMAGE_HV_MIRROR + {0x14 , 0x13},*/ + {0x15, 0x0a}, + {0x16, 0x05}, + {0x17, 0x01}, + {0x18, 0x44}, + {0x19, 0x44}, + {0x1a, 0x1e}, + {0x1b, 0x00}, + {0x1c, 0xc1}, + {0x1d, 0x08}, + {0x1e, 0x60}, + {0x1f, 0x17}, + {0x20, 0xff}, + {0x21, 0xf8}, + {0x22, 0x57}, +#if FORMAT_SEL == RGB565 + {0x24, 0xa6}, //a6 RGB565 +#elif FORMAT_SEL == UYVY + {0x24, 0xa0}, //a0 Cb Y Cr Y +#endif + {0x25, 0x0f}, + //output sync_mode + //{0x26 , 0x02},//0x03 20101016 zhj + {0x26, 0x03}, //sync mode, high high + {0x2f, 0x01}, + {0x30, 0xf7}, + {0x31, 0x50}, + {0x32, 0x00}, + {0x39, 0x04}, + {0x3a, 0x18}, + {0x3b, 0x20}, + {0x3c, 0x00}, + {0x3d, 0x00}, + {0x3e, 0x00}, + {0x3f, 0x00}, + {0x50, 0x10}, + {0x53, 0x82}, + {0x54, 0x80}, + {0x55, 0x80}, + {0x56, 0x82}, + {0x8b, 0x40}, + {0x8c, 0x40}, + {0x8d, 0x40}, + {0x8e, 0x2e}, + {0x8f, 0x2e}, + {0x90, 0x2e}, + {0x91, 0x3c}, + {0x92, 0x50}, + {0x5d, 0x12}, + {0x5e, 0x1a}, + {0x5f, 0x24}, + {0x60, 0x07}, + {0x61, 0x15}, + {0x62, 0x08}, + {0x64, 0x03}, + {0x66, 0xe8}, + {0x67, 0x86}, + {0x68, 0xa2}, + {0x69, 0x18}, + {0x6a, 0x0f}, + {0x6b, 0x00}, + {0x6c, 0x5f}, + {0x6d, 0x8f}, + {0x6e, 0x55}, + {0x6f, 0x38}, + {0x70, 0x15}, + {0x71, 0x33}, + {0x72, 0xdc}, + {0x73, 0x80}, + {0x74, 0x02}, + {0x75, 0x3f}, + {0x76, 0x02}, + {0x77, 0x36}, + {0x78, 0x88}, + {0x79, 0x81}, + {0x7a, 0x81}, + {0x7b, 0x22}, + {0x7c, 0xff}, + {0x93, 0x48}, + {0x94, 0x00}, + {0x95, 0x05}, + {0x96, 0xe8}, + {0x97, 0x40}, + {0x98, 0xf0}, + {0xb1, 0x38}, + {0xb2, 0x38}, + {0xbd, 0x38}, + {0xbe, 0x36}, +#if 1 + {0xd0, 0xc9}, + {0xd1, 0x10}, + {0xd3, 0x80}, + {0xd5, 0xf2}, + {0xd6, 0x16}, +#else + //default AEC setting + {0xd0, 0xca}, + {0xd1, 0xa1}, + {0xd3, 0xa0}, + {0xd5, 0xf2}, + {0xd6, 0x18}, +#endif + {0xdb, 0x92}, + {0xdc, 0xa5}, + {0xdf, 0x23}, + {0xd9, 0x00}, + {0xda, 0x00}, + {0xe0, 0x09}, + {0xed, 0x04}, +#if 0 + //default max dgain + {0xee , 0xa0}, + {0xef , 0x40}, +#else + //increased max dgain + {0xee, 0xf0}, + {0xef, 0x60}, +#endif + {0x80, 0x03}, + {0x80, 0x03}, + {0x9F, 0x10}, + {0xA0, 0x20}, + {0xA1, 0x38}, + {0xA2, 0x4E}, + {0xA3, 0x63}, + {0xA4, 0x76}, + {0xA5, 0x87}, + {0xA6, 0xA2}, + {0xA7, 0xB8}, + {0xA8, 0xCA}, + {0xA9, 0xD8}, + {0xAA, 0xE3}, + {0xAB, 0xEB}, + {0xAC, 0xF0}, + {0xAD, 0xF8}, + {0xAE, 0xFD}, + {0xAF, 0xFF}, + /* + GC0308_GAMMA_Select, + 1://smallest gamma curve + {0x9F , 0x0B}, + {0xA0 , 0x16}, + {0xA1 , 0x29}, + {0xA2 , 0x3C}, + {0xA3 , 0x4F}, + {0xA4 , 0x5F}, + {0xA5 , 0x6F}, + {0xA6 , 0x8A}, + {0xA7 , 0x9F}, + {0xA8 , 0xB4}, + {0xA9 , 0xC6}, + {0xAA , 0xD3}, + {0xAB , 0xDD}, + {0xAC , 0xE5}, + {0xAD , 0xF1}, + {0xAE , 0xFA}, + {0xAF , 0xFF}, + 2: + {0x9F , 0x0E}, + {0xA0 , 0x1C}, + {0xA1 , 0x34}, + {0xA2 , 0x48}, + {0xA3 , 0x5A}, + {0xA4 , 0x6B}, + {0xA5 , 0x7B}, + {0xA6 , 0x95}, + {0xA7 , 0xAB}, + {0xA8 , 0xBF}, + {0xA9 , 0xCE}, + {0xAA , 0xD9}, + {0xAB , 0xE4}, + {0xAC , 0xEC}, + {0xAD , 0xF7}, + {0xAE , 0xFD}, + {0xAF , 0xFF}, + 3: + {0x9F , 0x10}, + {0xA0 , 0x20}, + {0xA1 , 0x38}, + {0xA2 , 0x4E}, + {0xA3 , 0x63}, + {0xA4 , 0x76}, + {0xA5 , 0x87}, + {0xA6 , 0xA2}, + {0xA7 , 0xB8}, + {0xA8 , 0xCA}, + {0xA9 , 0xD8}, + {0xAA , 0xE3}, + {0xAB , 0xEB}, + {0xAC , 0xF0}, + {0xAD , 0xF8}, + {0xAE , 0xFD}, + {0xAF , 0xFF}, + 4: + {0x9F , 0x14}, + {0xA0 , 0x28}, + {0xA1 , 0x44}, + {0xA2 , 0x5D}, + {0xA3 , 0x72}, + {0xA4 , 0x86}, + {0xA5 , 0x95}, + {0xA6 , 0xB1}, + {0xA7 , 0xC6}, + {0xA8 , 0xD5}, + {0xA9 , 0xE1}, + {0xAA , 0xEA}, + {0xAB , 0xF1}, + {0xAC , 0xF5}, + {0xAD , 0xFB}, + {0xAE , 0xFE}, + {0xAF , 0xFF}, + 5://largest gamma curve + {0x9F , 0x15}, + {0xA0 , 0x2A}, + {0xA1 , 0x4A}, + {0xA2 , 0x67}, + {0xA3 , 0x79}, + {0xA4 , 0x8C}, + {0xA5 , 0x9A}, + {0xA6 , 0xB3}, + {0xA7 , 0xC5}, + {0xA8 , 0xD5}, + {0xA9 , 0xDF}, + {0xAA , 0xE8}, + {0xAB , 0xEE}, + {0xAC , 0xF3}, + {0xAD , 0xFA}, + {0xAE , 0xFD}, + {0xAF , 0xFF}, + */ + //-----------GAMMA Select End--------------// + {0xc0, 0x00}, + {0xc1, 0x10}, + {0xc2, 0x1C}, + {0xc3, 0x30}, + {0xc4, 0x43}, + {0xc5, 0x54}, + {0xc6, 0x65}, + {0xc7, 0x75}, + {0xc8, 0x93}, + {0xc9, 0xB0}, + {0xca, 0xCB}, + {0xcb, 0xE6}, + {0xcc, 0xFF}, + {0xf0, 0x02}, + {0xf1, 0x01}, + {0xf2, 0x01}, + {0xf3, 0x30}, + {0xf9, 0x9f}, + {0xfa, 0x78}, + //{0xfa , 0x58},//Change measure window Y1 from 480 to 352 + //------------------------------------------------- + {0xfe, 0x01}, // set page1 + {0x00, 0xf5}, + {0x02, 0x1a}, + {0x0a, 0xa0}, + {0x0b, 0x60}, + {0x0c, 0x08}, + {0x0e, 0x4c}, + {0x0f, 0x39}, + {0x11, 0x3f}, + {0x12, 0x72}, + {0x13, 0x13}, + {0x14, 0x42}, + {0x15, 0x43}, + {0x16, 0xc2}, + {0x17, 0xa8}, + {0x18, 0x18}, + {0x19, 0x40}, + {0x1a, 0xd0}, + {0x1b, 0xf5}, + {0x70, 0x40}, + {0x71, 0x58}, + {0x72, 0x30}, + {0x73, 0x48}, + {0x74, 0x20}, + {0x75, 0x60}, + {0x77, 0x20}, + {0x78, 0x32}, + {0x30, 0x03}, + {0x31, 0x40}, + {0x32, 0xe0}, + {0x33, 0xe0}, + {0x34, 0xe0}, + {0x35, 0xb0}, + {0x36, 0xc0}, + {0x37, 0xc0}, + {0x38, 0x04}, + {0x39, 0x09}, + {0x3a, 0x12}, + {0x3b, 0x1C}, + {0x3c, 0x28}, + {0x3d, 0x31}, + {0x3e, 0x44}, + {0x3f, 0x57}, + {0x40, 0x6C}, + {0x41, 0x81}, + {0x42, 0x94}, + {0x43, 0xA7}, + {0x44, 0xB8}, + {0x45, 0xD6}, + {0x46, 0xEE}, + {0x47, 0x0d}, + {0xfe, 0x00}, //set page0 + //-----------Update the registers 2010/07/06-------------// + //Registers of Page0 + {0xfe, 0x00}, //set page0 + {0x10, 0x26}, + {0x11, 0x0d}, //fd,modified by mormo 2010/07/06 + {0x1a, 0x2a}, //1e,modified by mormo 2010/07/06 + {0x1c, 0x49}, //c1,modified by mormo 2010/07/06 + {0x1d, 0x9a}, //08,modified by mormo 2010/07/06 + {0x1e, 0x61}, //60,modified by mormo 2010/07/06 + {0x3a, 0x20}, + {0x50, 0x14}, //10,modified by mormo 2010/07/06 + {0x53, 0x80}, + {0x56, 0x80}, + {0x8b, 0x20}, //LSC + {0x8c, 0x20}, + {0x8d, 0x20}, + {0x8e, 0x14}, + {0x8f, 0x10}, + {0x90, 0x14}, + {0x94, 0x02}, + {0x95, 0x07}, + {0x96, 0xe0}, + {0xb1, 0x40}, //YCPT + {0xb2, 0x40}, + {0xb3, 0x40}, + {0xb6, 0xe0}, + //{0xd0 , 0xcb},//AECT c9,modifed by mormo 2010/07/06 + //{0xd3 , 0x48},//80,modified by mormor 2010/07/06 + {0xf2, 0x02}, + //{0xf7 , 0x12}, + //{0xf8 , 0x0a}, + //Registers + {0xfe, 0x01}, // set page1 + {0x02, 0x20}, + {0x04, 0x10}, + {0x05, 0x08}, + {0x06, 0x20}, + {0x08, 0x0a}, + {0x0e, 0x44}, + {0x0f, 0x32}, + {0x10, 0x41}, + {0x11, 0x37}, + {0x12, 0x22}, + {0x13, 0x19}, + {0x14, 0x44}, + {0x15, 0x44}, + {0x19, 0x50}, + {0x1a, 0xd8}, + {0x32, 0x10}, + {0x35, 0x00}, + {0x36, 0x80}, + {0x37, 0x00}, + //-----------Update the registers end---------// + {0xfe, 0x00}, //set page0 + {0xd2, 0x90}, +#endif +}; + +static uint8_t image_sensor_read_id(void); +static uint8_t image_sensor_regs_config(void); + +void cam_clk_out(void) +{ + GLB_Set_I2S_CLK(ENABLE, GLB_I2S_OUT_REF_CLK_NONE); + PDS_Set_Audio_PLL_Freq(AUDIO_PLL_24576000_HZ); + GLB_Set_Chip_Out_1_CLK_Sel(GLB_CHIP_CLK_OUT_I2S_REF_CLK); +} + +uint8_t image_sensor_init(BL_Fun_Type mjpeg_en, cam_device_t *cam_cfg, mjpeg_device_t *mjpeg_cfg) +{ + i2c_register(I2C0_INDEX, "i2c", DEVICE_OFLAG_RDWR); + image_sensor_i2c = device_find("i2c"); + if(image_sensor_i2c){ + device_open(image_sensor_i2c, 0); + } + if(image_sensor_read_id()) + { + MSG("err1\r\n"); + return 1; + } + if(image_sensor_regs_config()) + { + MSG("err2\r\n"); + return 1; + } + + cam_stop(); + mjpeg_stop(); + + if(mjpeg_en) + { + cam_init(cam_cfg); + mjpeg_init(mjpeg_cfg); + } + else + { + cam_init(cam_cfg); + } + + return SUCCESS; +} + +/****************************************************************************//** + * @brief image_sensor_write_byte + * + * @param addr: Register address + * @param data: data + * + * @return None + * +*******************************************************************************/ +uint8_t image_sensor_write_byte(uint8_t cmd, uint8_t data) +{ + i2c_msg_t msg1; + + msg1.slaveaddr = I2C_CAMERA_ADDR, + msg1.len = 1, + msg1.buf = &data; + msg1.flags = SUB_ADDR_1BYTE | I2C_WR; + msg1.subaddr = cmd; + + return i2c_transfer(image_sensor_i2c, &msg1, 1); + +} + +/****************************************************************************//** + * @brief image_sensor_read_byte + * + * @param addr: Register address + * @param rdata: data + * + * @return None + * +*******************************************************************************/ +uint8_t image_sensor_read_byte(uint8_t cmd) +{ + i2c_msg_t msg1; + uint8_t temp; + msg1.len = 1, + msg1.buf = &temp; + msg1.subaddr = cmd; + msg1.slaveaddr = I2C_CAMERA_ADDR, + msg1.flags = SUB_ADDR_1BYTE | I2C_RD; + i2c_transfer(image_sensor_i2c, &msg1, 1); + + return temp; +} + + +/****************************************************************************/ /** + * @brief CAMERA Read ID + * + * @param None + * + * @return SUCCESS or ERROR + * +*******************************************************************************/ +static uint8_t image_sensor_read_id(void) +{ + uint8_t buf[2] = {0}; + + buf[0] = image_sensor_read_byte(GC0308_ID); + // MSG("image_sensor id:0x%2x\r\n",buf[0]); + if (buf[0] == 0x9b) + { + return SUCCESS; + } + else + { + return ERROR; + } +} + +static uint8_t image_sensor_regs_config(void) +{ + int i; + + for (i = 0; i < sizeof(sensorRegList) / sizeof(sensorRegList[0]); i++) + { + if (image_sensor_write_byte(sensorRegList[i][0],sensorRegList[i][1]) != SUCCESS) + { + return ERROR; + } + bflb_platform_delay_ms(1); + } + return SUCCESS; +} + + +/****************************************************************************/ /** + * @brief Dump image sensor register while is set + * + * @param None + * + * @return None + * +*******************************************************************************/ +void image_sensor_dump_regs(void) +{ + uint32_t i; + + for (i = 0; i < sizeof(sensorRegList) / sizeof(sensorRegList[0]); i++) + { + MSG("reg[%02x]: %02x\n", sensorRegList[i][0], image_sensor_read_byte(sensorRegList[i][0])); + } +} + +/* cam cdc case use gpio & timer*/ + +void tr_gpio_init(void) +{ + gpio_set_mode(GPIO_PIN_22, GPIO_OUTPUT_PP_MODE); + gpio_write(GPIO_PIN_22, 0); +} + +struct device* timer_ch0_comp2 = NULL; + +void timer_ch0_irq_callback(struct device *dev, void *args, uint32_t size, uint32_t state) +{ + static uint32_t i = 0; + if( i & 1) + { + gpio_write(GPIO_PIN_22, 1); + } + else + { + gpio_write(GPIO_PIN_22, 0); + } +} + +void tr_timer_init(void) +{ + timer_user_cfg_t timer_user_cfg; + timer_user_cfg.timeout_val = 1000*1000; /* us */ + timer_user_cfg.comp_it = TIMER_COMP0_IT; + + timer_register(TIMER_CH0_INDEX, "timer_ch0_comp2", DEVICE_OFLAG_RDWR); + + timer_ch0_comp2 = device_find("timer_ch0_comp2"); + if(timer_ch0_comp2) + { + device_open(timer_ch0_comp2, 0); + device_set_callback(timer_ch0_comp2, timer_ch0_irq_callback); + device_control(timer_ch0_comp2, DEVICE_CTRL_TIMER_CH_START, (void *)(&timer_user_cfg)); + } +} + +void trigger_init(void) +{ + tr_gpio_init(); + tr_timer_init(); +} diff --git a/bsp/bsp_common/image_sensor/bsp_image_sensor.h b/bsp/bsp_common/image_sensor/bsp_image_sensor.h new file mode 100644 index 00000000..875e829d --- /dev/null +++ b/bsp/bsp_common/image_sensor/bsp_image_sensor.h @@ -0,0 +1,36 @@ +/** + * @file bsp_gc0308.h + * @brief + * + * Copyright (c) 2021 Bouffalolab team + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. The + * ASF licenses this file to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + * + */ +#ifndef _IMAGE_SENSOR_H_ +#define _IMAGE_SENSOR_H_ + +#include "bflb_platform.h" +#include "bl702_cam.h" +#include "bl702_mjpeg.h" +#include "hal_cam.h" +#include "hal_mjpeg.h" + +uint8_t image_sensor_init(BL_Fun_Type mjpeg_en, cam_device_t *cam_cfg, mjpeg_device_t *mjpeg_cfg); +void cam_clk_out(void); +void trigger_init(void); + +#endif \ No newline at end of file diff --git a/bsp/bsp_common/lvgl/lv_port_disp.c b/bsp/bsp_common/lvgl/lv_port_disp.c index 22f6bf49..fdc55e1c 100644 --- a/bsp/bsp_common/lvgl/lv_port_disp.c +++ b/bsp/bsp_common/lvgl/lv_port_disp.c @@ -111,6 +111,10 @@ void lv_port_disp_init(void) /*Set the resolution of the display*/ Disp_Drv.hor_res = 240; Disp_Drv.ver_res = 320; + /* hardware rotation */ + Disp_Drv.sw_rotate = 0; + /* rotation */ + Disp_Drv.rotated = LV_DISP_ROT_NONE; /*Used to copy the buffer's content to the display*/ Disp_Drv.flush_cb = disp_flush; @@ -163,15 +167,21 @@ void disp_init(void) static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p) { /*The most simple case (but also the slowest) to put all pixels to the screen one-by-one*/ - + static uint8_t rotated_dir = 0; uint32_t length = (area->y2 - area->y1 +1) * (area->x2 - area->x1 +1) ; + if(rotated_dir != disp_drv->rotated) + { + rotated_dir = disp_drv->rotated; + LCD_Set_Dir(rotated_dir); + } + LCD_Set_Addr(area->x1,area->y1,area->x2,area->y2); device_control(lcd_spi,DEVICE_CTRL_TX_DMA_RESUME,NULL); + device_control(lcd_dma_tx, DEVICE_CTRL_SET_INT, NULL); CS1_LOW; DC_HIGH; - device_control(lcd_dma_tx, DEVICE_CTRL_SET_INT, NULL); dma_reload(lcd_dma_tx, (uint32_t)color_p, (uint32_t)DMA_ADDR_SPI_TDR, length*2); dma_channel_start(lcd_dma_tx); diff --git a/bsp/bsp_common/lvgl/lv_port_fs.c b/bsp/bsp_common/lvgl/lv_port_fs.c index 92f28af7..2ceb5e93 100644 --- a/bsp/bsp_common/lvgl/lv_port_fs.c +++ b/bsp/bsp_common/lvgl/lv_port_fs.c @@ -10,8 +10,9 @@ * INCLUDES *********************/ #include "lv_port_fs.h" - -typedef uint8_t lv_fs_res_t; +#include "ff.h" +#include "stdio.h" +#include "bflb_platform.h" /********************* * DEFINES @@ -24,19 +25,13 @@ typedef uint8_t lv_fs_res_t; /* Create a type to store the required data about your file. * If you are using a File System library * it already should have a File type. - * For example FatFS has `FIL`. In this case use `typedef FIL file_t`*/ -typedef struct { - /*Add the data you need to store about a file*/ - uint32_t dummy1; - uint32_t dummy2; -}file_t; + * For example FatFS has `file_t `. In this case use `typedef file_t file_t`*/ +typedef FIL file_t; /*Similarly to `file_t` create a type for directory reading too */ -typedef struct { - /*Add the data you need to store about directory reading*/ - uint32_t dummy1; - uint32_t dummy2; -}dir_t; +typedef DIR dir_t; + +FATFS FS_OBJ_SD; /********************** * STATIC PROTOTYPES @@ -58,9 +53,12 @@ static lv_fs_res_t fs_dir_open (lv_fs_drv_t * drv, void * rddir_p, const char *p static lv_fs_res_t fs_dir_read (lv_fs_drv_t * drv, void * rddir_p, char *fn); static lv_fs_res_t fs_dir_close (lv_fs_drv_t * drv, void * rddir_p); +extern void fatfs_sd_driver_register(void); + /********************** * STATIC VARIABLES **********************/ +typedef uint8_t lv_fs_res_t; /********************** * GLOBAL PROTOTYPES @@ -91,7 +89,7 @@ void lv_port_fs_init(void) /*Set up fields...*/ fs_drv.file_size = sizeof(file_t); - fs_drv.letter = 'P'; + fs_drv.letter = 'S'; fs_drv.open_cb = fs_open; fs_drv.close_cb = fs_close; fs_drv.read_cb = fs_read; @@ -115,6 +113,47 @@ void lv_port_fs_init(void) /********************** * STATIC FUNCTIONS **********************/ +lv_fs_res_t res_fatfs_to_lv(FRESULT res) +{ + if(res==FR_OK) + { + return LV_FS_RES_OK; + } + + switch (res) + { + case (FR_DISK_ERR): + res = LV_FS_RES_HW_ERR; + break; + case (FR_NO_FILE): + res = LV_FS_RES_NOT_EX; + break; + case (FR_NO_PATH): + res = LV_FS_RES_NOT_EX; + break; + case (FR_NOT_ENOUGH_CORE): + res = LV_FS_RES_OUT_OF_MEM; + break; + case (FR_LOCKED): + res = LV_FS_RES_LOCKED; + case (FR_TOO_MANY_OPEN_FILES): + res = LV_FS_RES_LOCKED; + break; + case (FR_NO_FILESYSTEM): + res = LV_FS_RES_FS_ERR; + break; + case (FR_WRITE_PROTECTED): + res = LV_FS_RES_DENIED; + break; + case (FR_TIMEOUT): + res = LV_FS_RES_TOUT; + break; + default: + res = LV_FS_RES_UNKNOWN; + } + return res; +} + /* Initialize your Storage device and File system. */ static void fs_init(void) @@ -122,6 +161,9 @@ static void fs_init(void) /*E.g. for FatFS initialize the SD card and FatFS itself*/ /*You code here*/ + fatfs_sd_driver_register(); + f_mount(&FS_OBJ_SD,"sd:",1); + } /** @@ -134,28 +176,43 @@ static void fs_init(void) */ static lv_fs_res_t fs_open (lv_fs_drv_t * drv, void * file_p, const char * path, lv_fs_mode_t mode) { - // lv_fs_res_t res = LV_FS_RES_NOT_IMP; + lv_fs_res_t res = LV_FS_RES_NOT_IMP; + BYTE fatfs_mode; + char *path_buf = NULL; + + switch (drv->letter) + { + case 'S': + path_buf = (char *)lv_mem_alloc(sizeof(char) * (strlen(path) + 4)); + sprintf(path_buf, "SD:/%s", path); + break; + + default: + return LV_FS_RES_NOT_EX; + break; + } - // if(mode == LV_FS_MODE_WR) - // { - // /*Open a file for write*/ + switch (mode) + { + case (LV_FS_MODE_RD): + fatfs_mode = FA_READ; + break; + case (LV_FS_MODE_WR): + fatfs_mode = FA_WRITE; + break; + case (LV_FS_MODE_WR|LV_FS_MODE_RD): + fatfs_mode = FA_WRITE|FA_READ; + break; + default: + fatfs_mode = LV_FS_MODE_RD; + break; + } - // /* Add your code here*/ - // } - // else if(mode == LV_FS_MODE_RD) - // { - // /*Open a file for read*/ + res = f_open((file_t *)file_p, path_buf, fatfs_mode); + res = res_fatfs_to_lv(res); - // /* Add your code here*/ - // } - // else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD)) - // { - // /*Open a file for read and write*/ - - // /* Add your code here*/ - // } - - // return res; + lv_mem_free(path_buf); + return res; } /** @@ -167,11 +224,13 @@ static lv_fs_res_t fs_open (lv_fs_drv_t * drv, void * file_p, const char * path, */ static lv_fs_res_t fs_close (lv_fs_drv_t * drv, void * file_p) { - // lv_fs_res_t res = LV_FS_RES_NOT_IMP; + lv_fs_res_t res = LV_FS_RES_NOT_IMP; - // /* Add your code here*/ + /* Add your code here*/ + res = f_close((file_t *)file_p); + res = res_fatfs_to_lv(res); - // return res; + return res; } /** @@ -186,9 +245,11 @@ static lv_fs_res_t fs_close (lv_fs_drv_t * drv, void * file_p) */ static lv_fs_res_t fs_read (lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br) { - // lv_fs_res_t res = LV_FS_RES_NOT_IMP; + lv_fs_res_t res = LV_FS_RES_NOT_IMP; - // /* Add your code here*/ + /* Add your code here*/ + res = f_read((file_t *)file_p, buf, btr, br); + res = res_fatfs_to_lv(res); return res; } @@ -207,6 +268,8 @@ static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, lv_fs_res_t res = LV_FS_RES_NOT_IMP; /* Add your code here*/ + res = f_write((file_t *)file_p, buf, btw, bw); + res = res_fatfs_to_lv(res); return res; } @@ -224,6 +287,8 @@ static lv_fs_res_t fs_seek (lv_fs_drv_t * drv, void * file_p, uint32_t pos) lv_fs_res_t res = LV_FS_RES_NOT_IMP; /* Add your code here*/ + res = f_lseek((file_t *)file_p, pos); + res = res_fatfs_to_lv(res); return res; } @@ -237,11 +302,11 @@ static lv_fs_res_t fs_seek (lv_fs_drv_t * drv, void * file_p, uint32_t pos) */ static lv_fs_res_t fs_size (lv_fs_drv_t * drv, void * file_p, uint32_t * size_p) { - lv_fs_res_t res = LV_FS_RES_NOT_IMP; + //lv_fs_res_t res = LV_FS_RES_NOT_IMP; /* Add your code here*/ - - return res; + *size_p = f_size((file_t *)file_p); + return LV_FS_RES_OK; } /** * Give the position of the read write pointer @@ -253,11 +318,11 @@ static lv_fs_res_t fs_size (lv_fs_drv_t * drv, void * file_p, uint32_t * size_p) */ static lv_fs_res_t fs_tell (lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p) { - lv_fs_res_t res = LV_FS_RES_NOT_IMP; + //lv_fs_res_t res = LV_FS_RES_NOT_IMP; /* Add your code here*/ - - return res; + *pos_p = f_tell((file_t *)file_p); + return LV_FS_RES_OK; } /** @@ -271,7 +336,23 @@ static lv_fs_res_t fs_remove (lv_fs_drv_t * drv, const char *path) lv_fs_res_t res = LV_FS_RES_NOT_IMP; /* Add your code here*/ + char *path_buf = NULL; + + switch (drv->letter) + { + case 'S': + path_buf = (char *)lv_mem_alloc(sizeof(char) * (strlen(path) + 4)); + sprintf(path_buf, "SD:/%s", path); + break; + default: + return LV_FS_RES_NOT_EX; + break; + } + res = f_unlink(path_buf); + res = res_fatfs_to_lv(res); + + lv_mem_free(path_buf); return res; } @@ -287,7 +368,9 @@ static lv_fs_res_t fs_trunc (lv_fs_drv_t * drv, void * file_p) lv_fs_res_t res = LV_FS_RES_NOT_IMP; /* Add your code here*/ - + res = f_truncate((file_t *)file_p); + res = res_fatfs_to_lv(res); + return res; } @@ -303,7 +386,27 @@ static lv_fs_res_t fs_rename (lv_fs_drv_t * drv, const char * oldname, const cha lv_fs_res_t res = LV_FS_RES_NOT_IMP; /* Add your code here*/ + char *path_old_buf = NULL; + char *path_new_buf = NULL; + + switch (drv->letter) + { + case 'S': + path_old_buf = (char *)lv_mem_alloc(sizeof(char) * (strlen(oldname) + 4)); + path_new_buf = (char *)lv_mem_alloc(sizeof(char) * (strlen(newname) + 4)); + sprintf(path_old_buf, "SD:/%s", oldname); + sprintf(path_new_buf, "SD:/%s", newname); + break; + default: + return LV_FS_RES_NOT_EX; + break; + } + res = f_rename(path_old_buf, path_new_buf); + res = res_fatfs_to_lv(res); + + lv_mem_free(path_old_buf); + lv_mem_free(path_new_buf); return res; } @@ -318,9 +421,26 @@ static lv_fs_res_t fs_rename (lv_fs_drv_t * drv, const char * oldname, const cha static lv_fs_res_t fs_free (lv_fs_drv_t * drv, uint32_t * total_p, uint32_t * free_p) { lv_fs_res_t res = LV_FS_RES_NOT_IMP; + char *path = NULL; + FATFS *fs_obj; /* Add your code here*/ + switch (drv->letter) + { + case 'S': + path = "SD:"; + fs_obj = &FS_OBJ_SD; + break; + default: + return LV_FS_RES_NOT_EX; + break; + } + + res = f_getfree(path , free_p, &fs_obj); + *free_p = (fs_obj->csize) * (*free_p) / 1024; + *total_p = (fs_obj->csize) * (fs_obj->n_fatent - 2) /1024; + res = res_fatfs_to_lv(res); return res; } @@ -336,7 +456,23 @@ static lv_fs_res_t fs_dir_open (lv_fs_drv_t * drv, void * rddir_p, const char *p lv_fs_res_t res = LV_FS_RES_NOT_IMP; /* Add your code here*/ + char *path_buf = NULL; + + switch (drv->letter) + { + case 'S': + path_buf = (char *)lv_mem_alloc(sizeof(char) * (strlen(path) + 4)); + sprintf(path_buf, "SD:/%s", path); + break; + default: + return LV_FS_RES_NOT_EX; + break; + } + res = f_opendir(rddir_p, path_buf); + res = res_fatfs_to_lv(res); + + lv_mem_free(path_buf); return res; } @@ -351,8 +487,16 @@ static lv_fs_res_t fs_dir_open (lv_fs_drv_t * drv, void * rddir_p, const char *p static lv_fs_res_t fs_dir_read (lv_fs_drv_t * drv, void * rddir_p, char *fn) { lv_fs_res_t res = LV_FS_RES_NOT_IMP; + FILINFO entry; /* Add your code here*/ + res = f_readdir(rddir_p, &entry); + res = res_fatfs_to_lv(res); + + if(res == LV_FS_RES_OK) + { + sprintf(fn,"%s%s",(entry.fattrib & AM_DIR)? "/" : "", entry.fname); + } return res; } @@ -368,7 +512,8 @@ static lv_fs_res_t fs_dir_close (lv_fs_drv_t * drv, void * rddir_p) lv_fs_res_t res = LV_FS_RES_NOT_IMP; /* Add your code here*/ - + f_closedir((dir_t*)rddir_p); + res = res_fatfs_to_lv(res); return res; } diff --git a/bsp/bsp_common/lvgl/lv_port_fs.h b/bsp/bsp_common/lvgl/lv_port_fs.h index 238f1cc9..5f65c103 100644 --- a/bsp/bsp_common/lvgl/lv_port_fs.h +++ b/bsp/bsp_common/lvgl/lv_port_fs.h @@ -29,6 +29,7 @@ extern "C" { /********************** * GLOBAL PROTOTYPES **********************/ +void lv_port_fs_init(void); /********************** * MACROS diff --git a/bsp/bsp_common/lvgl/lv_port_indev.c b/bsp/bsp_common/lvgl/lv_port_indev.c index f630c362..55793b41 100644 --- a/bsp/bsp_common/lvgl/lv_port_indev.c +++ b/bsp/bsp_common/lvgl/lv_port_indev.c @@ -10,12 +10,8 @@ * INCLUDES *********************/ #include "lv_port_indev.h" -#include "xpt2046.h" #include "bflb_platform.h" -#include "bl702_glb.h" -#include "bl702_spi.h" - /********************* * DEFINES *********************/ @@ -38,9 +34,9 @@ static lv_coord_t touchpad_get_xy(lv_coord_t * x, lv_coord_t * y); // static bool mouse_is_pressed(void); // static void mouse_get_xy(lv_coord_t * x, lv_coord_t * y); -// static void keypad_init(void); -// static bool keypad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data); -// static uint32_t keypad_get_key(void); +static void keypad_init(void); +static bool keypad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data); +static uint32_t keypad_get_key(void); // static void encoder_init(void); // static bool encoder_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data); @@ -55,10 +51,10 @@ static lv_coord_t touchpad_get_xy(lv_coord_t * x, lv_coord_t * y); * STATIC VARIABLES **********************/ lv_indev_t * indev_touchpad; -lv_indev_t * indev_mouse; +//lv_indev_t * indev_mouse; lv_indev_t * indev_keypad; -lv_indev_t * indev_encoder; -lv_indev_t * indev_button; +//lv_indev_t * indev_encoder; +//lv_indev_t * indev_button; // static int32_t encoder_diff; // static lv_indev_state_t encoder_state; @@ -122,13 +118,13 @@ void lv_port_indev_init(void) * -----------------*/ /*Initialize your keypad or keyboard if you have*/ - // keypad_init(); + keypad_init(); /*Register a keypad input device*/ - // lv_indev_drv_init(&indev_drv); - // indev_drv.type = LV_INDEV_TYPE_KEYPAD; - // indev_drv.read_cb = keypad_read; - // indev_keypad = lv_indev_drv_register(&indev_drv); + lv_indev_drv_init(&indev_drv); + indev_drv.type = LV_INDEV_TYPE_KEYPAD; + indev_drv.read_cb = keypad_read; + indev_keypad = lv_indev_drv_register(&indev_drv); /* Later you should create group(s) with `lv_group_t * group = lv_group_create()`, * add objects to the group with `lv_group_add_obj(group, obj)` @@ -181,6 +177,8 @@ void lv_port_indev_init(void) /*------------------ * Touchpad * -----------------*/ +#include "touch.h" +#include "hal_spi.h" /*Initialize your touchpad*/ static void touchpad_init(void) @@ -225,27 +223,14 @@ static lv_coord_t touchpad_get_xy(lv_coord_t * x, lv_coord_t * y) { /*Your code comes here*/ lv_disp_t *p_disp_drv_cb; - lv_disp_rot_t rotate; uint8_t res; - SPI_ClockCfg_Type clockCfg = - { - 2, /* Length of start condition */ - 2, /* Length of stop condition */ - 2, /* Length of data phase 0,affecting clock */ - 2, /* Length of data phase 1,affecting clock */ - 2 /* Length of interval between frame */ - }; p_disp_drv_cb = lv_disp_get_default(); - rotate = lv_disp_get_rotation(p_disp_drv_cb); + while(p_disp_drv_cb->driver.buffer->flushing); - clockCfg.dataPhase0Len = 5; - clockCfg.dataPhase1Len = 5; - SPI_ClockConfig(SPI_ID_0, &clockCfg); - res = xpt2046_read((uint16_t*)x,(uint16_t*)y,rotate); - clockCfg.dataPhase0Len = 1; - clockCfg.dataPhase1Len = 1; - SPI_ClockConfig(SPI_ID_0, &clockCfg); + device_control(touch_spi, DEVICE_CTRL_SPI_CONFIG_CLOCK, (void*)3600000); + res = touch_read(x,y); + device_control(touch_spi, DEVICE_CTRL_SPI_CONFIG_CLOCK, (void*)36000000); return res; } @@ -296,63 +281,130 @@ static lv_coord_t touchpad_get_xy(lv_coord_t * x, lv_coord_t * y) /*------------------ * Keypad * -----------------*/ +#include "hal_adc.h" +#include "hal_gpio.h" +uint8_t PinList[] = {GPIO_PIN_18}; +adc_channel_t posChList[] = {ADC_CHANNEL8}; +adc_channel_t negChList[] = {ADC_CHANNEL_GND}; + +adc_channel_val_t result_val; +struct device* adc_key; + +uint16_t key_value[] = {283,89,198,0,406}; /* Initialize your keypad */ -// static void keypad_init(void) -// { -// /*Your code comes here*/ -// } +static void keypad_init(void) +{ + /*Your code comes here*/ + adc_channel_cfg_t adc_channel_cfg; -/* Will be called by the library to read the mouse */ -// static bool keypad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data) -// { -// static uint32_t last_key = 0; + adc_channel_cfg.pos_channel = posChList; + adc_channel_cfg.neg_channel = negChList; + adc_channel_cfg.num = 1; -// /*Get the current x and y coordinates*/ -// mouse_get_xy(&data->point.x, &data->point.y); + adc_register(ADC0_INDEX, "adc_key", DEVICE_OFLAG_STREAM_RX); -// /*Get whether the a key is pressed and save the pressed key*/ -// uint32_t act_key = keypad_get_key(); -// if(act_key != 0) { -// data->state = LV_INDEV_STATE_PR; + adc_key = device_find("adc_key"); + if(adc_key) + { + ADC_DEV(adc_key)->continuous_conv_mode = ENABLE; + device_open(adc_key, DEVICE_OFLAG_STREAM_RX); + device_control(adc_key,DEVICE_CTRL_ADC_CHANNEL_CONFIG,&adc_channel_cfg); + adc_channel_start(adc_key); + } +} -// /*Translate the keys to LVGL control characters according to your key definitions*/ -// switch(act_key) { -// case 1: -// act_key = LV_KEY_NEXT; -// break; -// case 2: -// act_key = LV_KEY_PREV; -// break; -// case 3: -// act_key = LV_KEY_LEFT; -// break; -// case 4: -// act_key = LV_KEY_RIGHT; -// break; -// case 5: -// act_key = LV_KEY_ENTER; -// break; -// } +/* Will be called by the library to read the keypad */ +static bool keypad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data) +{ + static uint32_t last_key = 0; -// last_key = act_key; -// } else { -// data->state = LV_INDEV_STATE_REL; -// } + /*Get the current x and y coordinates*/ + //mouse_get_xy(&data->point.x, &data->point.y); -// data->key = last_key; + /*Get whether the a key is pressed and save the pressed key*/ + uint32_t act_key = keypad_get_key(); + if(act_key != 0) { + data->state = LV_INDEV_STATE_PR; + /*Translate the keys to LVGL control characters according to your key definitions*/ + switch(act_key) { + case 1: + act_key = LV_KEY_LEFT; + break; + case 2: + act_key = LV_KEY_RIGHT; + break; + case 3: + act_key = LV_KEY_UP; + break; + case 4: + act_key = LV_KEY_DOWN; + break; + case 5: + act_key = LV_KEY_ENTER; + break; + default: + break; + } + last_key = act_key; + + } else { + data->state = LV_INDEV_STATE_REL; + } -// /*Return `false` because we are not buffering and no more data to read*/ -// return false; -// } + data->key = last_key; + + /*Return `false` because we are not buffering and no more data to read*/ + return false; +} /*Get the currently being pressed key. 0 if no key is pressed*/ -// static uint32_t keypad_get_key(void) -// { -// /*Your code comes here*/ +static uint32_t keypad_get_key(void) +{ + static uint8_t old_key_v = 0; + static uint8_t old_key_num = 0; + static uint8_t last_key; + uint8_t key; + uint16_t key_voltage; + /*Your code comes here*/ + device_read(adc_key, 0, (void *)&result_val,sizeof(result_val)/sizeof(adc_channel_val_t)); + key_voltage = result_val.volt * 1000; -// return 0; -// } + for(key=0;key sizeof(key_value)) + { + key = 0; + } + + if(key == last_key) + { + old_key_v = key; + old_key_num = 0; + } + else if(key==old_key_v) + { + old_key_num++; + if(old_key_num >= KEY_NOISE_NUM_MAX) + { + last_key = key; + old_key_num = 0; + } + } + else + { + old_key_num = 0; + old_key_v = key; + } + + return last_key; +} /*------------------ * Encoder diff --git a/bsp/bsp_common/lvgl/lv_port_indev.h b/bsp/bsp_common/lvgl/lv_port_indev.h index b41ce81d..7edc2a75 100644 --- a/bsp/bsp_common/lvgl/lv_port_indev.h +++ b/bsp/bsp_common/lvgl/lv_port_indev.h @@ -22,6 +22,10 @@ extern "C" { /********************* * DEFINES *********************/ +#define KEY_ADC_DIFF_MAX 15 +#define DIFF(x,y) (((x)>(y))?((x)-(y)):((y)-(x))) + +#define KEY_NOISE_NUM_MAX 2 /********************** * TYPEDEFS @@ -30,6 +34,14 @@ extern "C" { /********************** * GLOBAL PROTOTYPES **********************/ +/********************** + * STATIC VARIABLES + **********************/ +extern lv_indev_t * indev_touchpad; +//extern lv_indev_t * indev_mouse; +extern lv_indev_t * indev_keypad; +//extern lv_indev_t * indev_encoder; +//extern lv_indev_t * indev_button; void lv_port_indev_init(void); diff --git a/bsp/bsp_common/platform/bflb_platform.c b/bsp/bsp_common/platform/bflb_platform.c index 71cb0b71..4dbe9091 100644 --- a/bsp/bsp_common/platform/bflb_platform.c +++ b/bsp/bsp_common/platform/bflb_platform.c @@ -35,7 +35,7 @@ static uint8_t uart_dbg_disable=0; Shell shell; char shellBuffer[512]; -void uart0_irq_callback(struct device *dev, void *args, uint32_t size, uint32_t state) +void uart_iqr_callback(struct device *dev, void *args, uint32_t size, uint32_t state) { uint8_t data; @@ -70,7 +70,7 @@ void shell_init(void) #else -void uart0_irq_callback(struct device *dev, void *args, uint32_t size, uint32_t state) +void uart_iqr_callback(struct device *dev, void *args, uint32_t size, uint32_t state) { if (state == UART_EVENT_RX_FIFO) { @@ -88,22 +88,25 @@ __WEAK__ void bl_show_info(void) } +__WEAK__ enum uart_index_type board_get_debug_uart_index(void) +{ + return 0; +} + void bflb_platform_init(uint32_t baudrate) { disable_irq(); board_init(); - mtimer_init(); - if(!uart_dbg_disable){ - uart_register(UART0_INDEX, "debug_log", DEVICE_OFLAG_RDWR); + uart_register(board_get_debug_uart_index(), "debug_log", DEVICE_OFLAG_RDWR); struct device *uart = device_find("debug_log"); if (uart) { device_open(uart, DEVICE_OFLAG_STREAM_TX | DEVICE_OFLAG_INT_RX); - device_set_callback(uart, uart0_irq_callback); + device_set_callback(uart, uart_iqr_callback); device_control(uart, DEVICE_CTRL_SET_INT, (void *)(UART_RX_FIFO_IT)); } @@ -116,7 +119,7 @@ void bflb_platform_init(uint32_t baudrate) if (!mmheap_init_with_pool(&_HeapBase, (size_t)&_HeapSize)) { - MSG("dynamic memory init success,heap size = 0x%x \r\n", &_HeapSize); + // MSG("dynamic memory init success,heap size = 0x%x \r\n", &_HeapSize); } else { @@ -146,6 +149,11 @@ void bflb_platform_print_set(uint8_t disable) uart_dbg_disable=disable; } +uint8_t bflb_platform_print_get(void) +{ + return uart_dbg_disable; +} + void bflb_platform_deinit(void) { @@ -170,12 +178,12 @@ void bflb_platform_dump(uint8_t *data, uint32_t len) void bflb_platform_init_time() { - mtimer_init(); + } void bflb_platform_deinit_time() { - mtimer_deinit(); + } void bflb_platform_set_alarm_time(uint64_t time,void( *interruptFun )( void )) @@ -185,17 +193,17 @@ void bflb_platform_set_alarm_time(uint64_t time,void( *interruptFun )( void )) void bflb_platform_clear_time() { - mtimer_clear_time(); + } void bflb_platform_start_time() { - mtimer_start(); + } void bflb_platform_stop_time() { - mtimer_stop(); + } uint64_t bflb_platform_get_time_ms() diff --git a/bsp/bsp_common/platform/bflb_platform.h b/bsp/bsp_common/platform/bflb_platform.h index 6bc98e1c..ecfb9c4d 100644 --- a/bsp/bsp_common/platform/bflb_platform.h +++ b/bsp/bsp_common/platform/bflb_platform.h @@ -27,6 +27,7 @@ #include "misc.h" //#include "mcu_sdk_version.h" +#define printf(a,...) bflb_platform_printf(a,##__VA_ARGS__) #define MSG(a,...) bflb_platform_printf(a,##__VA_ARGS__) #define MSG_DBG(a,...) bflb_platform_printf(a,##__VA_ARGS__) #define MSG_ERR(a,...) bflb_platform_printf(a,##__VA_ARGS__) @@ -79,6 +80,8 @@ void check_failed(uint8_t *file, uint32_t line); void bflb_platform_init(uint32_t baudrate); void bflb_platform_printf(char *fmt,...); +void bflb_platform_print_set(uint8_t disable); +uint8_t bflb_platform_print_get(void); void bflb_platform_dump(uint8_t *data, uint32_t len); void bflb_platform_deinit(void); diff --git a/bsp/bsp_common/psram/bsp_sf_psram.c b/bsp/bsp_common/psram/bsp_sf_psram.c new file mode 100644 index 00000000..36e6038e --- /dev/null +++ b/bsp/bsp_common/psram/bsp_sf_psram.c @@ -0,0 +1,142 @@ +/** + * @file bsp_sf_psram.c + * @brief + * + * Copyright (c) 2021 Bouffalolab team + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. The + * ASF licenses this file to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + * + */ + +#include "bsp_sf_psram.h" +#include "bflb_platform.h" +#include "bl702_psram.h" +#include "bl702_l1c.h" +#include "bl702_sec_eng.h" +#include "bl702_glb.h" + +/* bsp sf psram private variables */ + +SPI_Psram_Cfg_Type apMemory1604 = { + .readIdCmd = 0x9F, + .readIdDmyClk = 0, + .burstToggleCmd = 0xC0, + .resetEnableCmd = 0x66, + .resetCmd = 0x99, + .enterQuadModeCmd = 0x35, + .exitQuadModeCmd = 0xF5, + .readRegCmd = 0xB5, + .readRegDmyClk = 1, + .writeRegCmd = 0xB1, + .readCmd = 0x03, + .readDmyClk = 0, + .fReadCmd = 0x0B, + .fReadDmyClk = 1, + .fReadQuadCmd = 0xEB, + .fReadQuadDmyClk = 3, + .writeCmd = 0x02, + .quadWriteCmd = 0x38, + .pageSize = 512, + .ctrlMode = PSRAM_SPI_CTRL_MODE, + .driveStrength = PSRAM_DRIVE_STRENGTH_50_OHMS, + .burstLength = PSRAM_BURST_LENGTH_512_BYTES, +}; + +SF_Ctrl_Cmds_Cfg cmdsCfg = { + .cmdsEn = ENABLE, + .burstToggleEn = ENABLE, + .wrapModeEn = DISABLE, + .wrapLen = SF_CTRL_WRAP_LEN_512, +}; +SF_Ctrl_Psram_Cfg sfCtrlPsramCfg = { + .owner = SF_CTRL_OWNER_SAHB, + .padSel = SF_CTRL_PAD_SEL_DUAL_CS_SF2, + .bankSel = SF_CTRL_SEL_PSRAM, + .psramRxClkInvertSrc = ENABLE, + .psramRxClkInvertSel = DISABLE, + .psramDelaySrc = ENABLE, + .psramClkDelay = 1, +}; + +/* bsp sf psram gpio init */ +/** + * @brief + * + * @return None + * + */ +void ATTR_TCM_SECTION bsp_sf_psram_gpio_init(void) +{ + GLB_GPIO_Cfg_Type cfg; + uint8_t gpiopins[7]; + uint8_t i = 0; + + cfg.gpioMode = GPIO_MODE_AF; + cfg.pullType = GPIO_PULL_UP; + cfg.drive = 3; + cfg.smtCtrl = 1; + cfg.gpioFun = GPIO_FUN_FLASH_PSRAM; + + gpiopins[0] = BFLB_EXTPSRAM_CLK_GPIO; + gpiopins[1] = BFLB_EXTPSRAM_CS_GPIO; + gpiopins[2] = BFLB_EXTPSRAM_DATA0_GPIO; + gpiopins[3] = BFLB_EXTPSRAM_DATA1_GPIO; + gpiopins[4] = BFLB_EXTPSRAM_DATA2_GPIO; + gpiopins[5] = BFLB_EXTPSRAM_DATA3_GPIO; + gpiopins[6] = BFLB_EXTFLASH_CS_GPIO; + + for(i=0; idirection = DMA_MEMORY_TO_PERIPH; @@ -57,11 +71,17 @@ uint8_t SD_SPI_Init(void) ((dma_device_t*)dma_ch3)->src_width = DMA_TRANSFER_WIDTH_8BIT; ((dma_device_t*)dma_ch3)->dst_width = DMA_TRANSFER_WIDTH_8BIT; device_open(dma_ch3, 0); - device_set_callback(dma_ch3, NULL); - device_control(dma_ch3, DEVICE_CTRL_SET_INT, NULL); } - dma_ch4 = device_find("ch4"); + dma_ch4 = device_find("dma0_ch4"); + if(dma_ch4) + { + device_close(dma_ch4); + } + else{ + dma_register(DMA0_CH4_INDEX, "dma0_ch4", DEVICE_OFLAG_RDWR); + dma_ch4 = device_find("dma0_ch4"); + } if (dma_ch4) { ((dma_device_t*)dma_ch4)->direction = DMA_PERIPH_TO_MEMORY; @@ -71,62 +91,34 @@ uint8_t SD_SPI_Init(void) ((dma_device_t*)dma_ch4)->src_width = DMA_TRANSFER_WIDTH_8BIT ; ((dma_device_t*)dma_ch4)->dst_width = DMA_TRANSFER_WIDTH_8BIT ; device_open(dma_ch4, 0); - device_set_callback(dma_ch4, NULL); - device_control(dma_ch4, DEVICE_CTRL_SET_INT, NULL); } - return SUCCESS; } BL_Err_Type SPI_ReadWriteByte(uint8_t *txBuff, uint8_t *rxBuff, uint32_t length) { - static SPI_FifoCfg_Type SPI_fifoconfig={ - .txFifoThreshold = 1, - .rxFifoThreshold = 1, - .txFifoDmaEnable = ENABLE, - .rxFifoDmaEnable = ENABLE, - }; - // DMA自动与手动无法同时使用，DmaEnable开启后，一旦进行手动发送，之后DMA发送就会卡死 - // test code： - // MSG("SPI_DMA_test 1\r\n"); - // dma_reload(dma_ch3, (uint32_t)txBuff, (uint32_t)DMA_ADDR_SPI_TDR, length); - // dma_reload(dma_ch4, (uint32_t)DMA_ADDR_SPI_RDR, (uint32_t)rxBuff, length); - // dma_channel_start(dma_ch3); - // dma_channel_start(dma_ch4); - // while (device_control(dma_ch3, DMA_CHANNEL_GET_STATUS, NULL) || device_control(dma_ch4, DMA_CHANNEL_GET_STATUS, NULL)) - // { - // } - // MSG("SPI_DMA_test 2\r\n"); - // spi_transmit_receive(spi0,txBuff,rxBuff,length,SPI_DATASIZE_8BIT); - // MSG("SPI_DMA_test 3\r\n"); + while(device_control(dma_ch3,DMA_CHANNEL_GET_STATUS,NULL)||device_control(dma_ch4,DMA_CHANNEL_GET_STATUS,NULL)); if(length<500) { - if(SPI_fifoconfig.txFifoDmaEnable == ENABLE || SPI_fifoconfig.rxFifoDmaEnable == ENABLE) - { - SPI_fifoconfig.txFifoDmaEnable = DISABLE; - SPI_fifoconfig.rxFifoDmaEnable = DISABLE; - SPI_FifoConfig(SPI_ID_0,&SPI_fifoconfig); - } spi_transmit_receive(spi0,txBuff,rxBuff,length,SPI_DATASIZE_8BIT); } - else{ - if(SPI_fifoconfig.txFifoDmaEnable == DISABLE || SPI_fifoconfig.rxFifoDmaEnable == DISABLE) - { - SPI_fifoconfig.txFifoDmaEnable = ENABLE; - SPI_fifoconfig.rxFifoDmaEnable = ENABLE; - SPI_FifoConfig(SPI_ID_0,&SPI_fifoconfig); - } + else + { + device_control(spi0, DEVICE_CTRL_TX_DMA_RESUME, NULL); + device_control(spi0, DEVICE_CTRL_RX_DMA_RESUME, NULL); + device_control(dma_ch3, DEVICE_CTRL_CLR_INT, NULL); + device_control(dma_ch4, DEVICE_CTRL_CLR_INT, NULL); + dma_reload(dma_ch3, (uint32_t)txBuff, (uint32_t)DMA_ADDR_SPI_TDR, length); dma_reload(dma_ch4, (uint32_t)DMA_ADDR_SPI_RDR, (uint32_t)rxBuff, length); dma_channel_start(dma_ch3); dma_channel_start(dma_ch4); - while(device_control(dma_ch3,DMA_CHANNEL_GET_STATUS,NULL)||device_control(dma_ch4,DMA_CHANNEL_GET_STATUS,NULL)) - { - } - dma_channel_stop(dma_ch3); - dma_channel_stop(dma_ch4); + + while(device_control(dma_ch3,DMA_CHANNEL_GET_STATUS,NULL)||device_control(dma_ch4,DMA_CHANNEL_GET_STATUS,NULL)); + device_control(spi0, DEVICE_CTRL_TX_DMA_SUSPEND, NULL); + device_control(spi0, DEVICE_CTRL_RX_DMA_SUSPEND, NULL); } return SUCCESS; diff --git a/bsp/bsp_common/spi_sd/bsp_spi_sd.h b/bsp/bsp_common/spi_sd/bsp_spi_sd.h index 07696194..a901ef5e 100644 --- a/bsp/bsp_common/spi_sd/bsp_spi_sd.h +++ b/bsp/bsp_common/spi_sd/bsp_spi_sd.h @@ -24,7 +24,7 @@ #ifndef __SPI_SD_H__ #define __SPI_SD_H__ -#define SPI_PIN_CS GPIO_PIN_10 +#define SPI_PIN_CS GPIO_PIN_16 //SD传输数据结束后是否释放总线宏定义 #define NO_RELEASE 0 diff --git a/bsp/bsp_common/touch/touch.c b/bsp/bsp_common/touch/touch.c new file mode 100644 index 00000000..59cbc941 --- /dev/null +++ b/bsp/bsp_common/touch/touch.c @@ -0,0 +1,41 @@ +/** + * @file touch.c + * @brief + * + * Copyright (c) 2021 Bouffalolab team + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. The + * ASF licenses this file to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + * + */ +#include"touch.h" + +void touch_init(void) +{ +#if defined (TOUCH_CONTROLLER_XPT2046) + xpt2046_init(); +#endif +} + +uint8_t touch_read(int16_t * x, int16_t * y) +{ +#if defined (TOUCH_CONTROLLER_XPT2046) + return xpt2046_read( x, y); +#endif +} + + + + diff --git a/bsp/bsp_common/audio/audio_core.h b/bsp/bsp_common/touch/touch.h similarity index 65% rename from bsp/bsp_common/audio/audio_core.h rename to bsp/bsp_common/touch/touch.h index 997e02a2..004980df 100644 --- a/bsp/bsp_common/audio/audio_core.h +++ b/bsp/bsp_common/touch/touch.h @@ -1,45 +1,38 @@ -/** - * @file audio_core.h - * @brief - * - * Copyright (c) 2021 Bouffalolab team - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. The - * ASF licenses this file to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance with the - * License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - * - */ - -#ifndef __AUDIO_PROTO__ -#define __AUDIO_PROTO__ - -#include "misc.h" - -typedef struct{ - - uint8_t *buff1; - uint8_t *buff2; - uint32_t buff_size; - - struct device * audio_dma; - struct device * audio_device; - - int (*buffer_ready_callback)(char bufIndex); - -}audio_core_t; - -int audio_core_init(audio_core_t * audio_core_cfg); -int audio_core_start(void); -int audio_core_stop(void); +/** + * @file touch.h + * @brief + * + * Copyright (c) 2021 Bouffalolab team + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. The + * ASF licenses this file to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + * + */ + +#ifndef _TOUCH_H_ +#define _TOUCH_H_ + +#define TOUCH_CONTROLLER_XPT2046 + + +#ifdef TOUCH_CONTROLLER_XPT2046 + #include "xpt2046.h" +#endif + + +void touch_init(void); +uint8_t touch_read(int16_t * x, int16_t * y); + #endif \ No newline at end of file diff --git a/bsp/bsp_common/touch/xpt2046.c b/bsp/bsp_common/touch/xpt2046.c index 88045cb1..dda414fa 100644 --- a/bsp/bsp_common/touch/xpt2046.c +++ b/bsp/bsp_common/touch/xpt2046.c @@ -73,14 +73,20 @@ static uint16_t xpt2046_cmd(uint8_t cmd) void xpt2046_init(void) { gpio_set_mode(TOUCH_PIN_CS,GPIO_OUTPUT_MODE); - gpio_write(TOUCH_PIN_CS,1); //CS2 + gpio_write(TOUCH_PIN_CS,1); touch_spi = device_find("spi0"); if(touch_spi) { - return ; + device_close(touch_spi); + } + else{ + spi_register(SPI0_INDEX,"spi0",DEVICE_OFLAG_RDWR); + touch_spi = device_find("spi0"); + } + if(touch_spi) + { + device_open(touch_spi,DEVICE_OFLAG_STREAM_TX|DEVICE_OFLAG_STREAM_RX); } - spi_register(SPI0_INDEX,"spi0",DEVICE_OFLAG_RDWR); - device_open(touch_spi,DEVICE_OFLAG_STREAM_TX|DEVICE_OFLAG_STREAM_RX); } @@ -98,7 +104,6 @@ static uint8_t xpt2048_is_touch_detected() uint16_t z1 = xpt2046_cmd(CMD_Z1_READ) ; uint16_t z2 = xpt2046_cmd(CMD_Z2_READ) ; - // this is not what the confusing datasheet says but it seems to // be enough to detect real touches on the panel uint16_t z = z1 + 4096 - z2; @@ -122,7 +127,7 @@ static uint8_t xpt2048_is_touch_detected() * @return * *******************************************************************************/ -static uint8_t xpt2046_ads_get(uint16_t *x, uint16_t *y) +static uint8_t xpt2046_ads_get(int16_t *x, int16_t *y) { for(uint8_t i=0; i XPT2046_X_MIN) (*x) -= XPT2046_X_MIN; @@ -176,36 +181,12 @@ static uint8_t xpt2046_corr(uint16_t * x, uint16_t * y, int8_t rotated) else (*y) = 0; - if(rotated==TOUCH_ROT_90 || rotated==TOUCH_ROT_270) - { - uint16_t temp = *x; - *x = *y; - *y = temp; - } - - (*x) = (uint32_t)((uint32_t)(*x) * LV_HOR_RES) / + (*x) = (uint32_t)((uint32_t)(*x) * 240) / (XPT2046_X_MAX - XPT2046_X_MIN); - (*y) = (uint32_t)((uint32_t)(*y) * LV_VER_RES) / + (*y) = (uint32_t)((uint32_t)(*y) * 320) / (XPT2046_Y_MAX - XPT2046_Y_MIN); - switch (rotated) - { - case TOUCH_ROT_NONE: - break; - case TOUCH_ROT_90: - *y = -*y; - break; - case TOUCH_ROT_180: - *x = -*x; - *y = -*y; - break; - case TOUCH_ROT_270: - *x = -*x; - default: - break; - } - return 1; } @@ -217,18 +198,18 @@ static uint8_t xpt2046_corr(uint16_t * x, uint16_t * y, int8_t rotated) * @return * *******************************************************************************/ -uint8_t xpt2046_read(uint16_t * x, uint16_t * y, int8_t rotated) +uint8_t xpt2046_read(int16_t * x, int16_t * y) { - static uint16_t xt=0,yt=0; + static int16_t xt=0,yt=0; static uint8_t avg_last = 0; - uint16_t x1,y1; + int16_t x1,y1; if(xpt2046_ads_get(&x1, &y1)==0) { goto end; } - if(xpt2046_corr(&x1,&y1,rotated)==0) + if(xpt2046_adc2xy(&x1,&y1)==0) { goto end; } diff --git a/bsp/bsp_common/touch/xpt2046.h b/bsp/bsp_common/touch/xpt2046.h index 18ec40bf..4b7590b3 100644 --- a/bsp/bsp_common/touch/xpt2046.h +++ b/bsp/bsp_common/touch/xpt2046.h @@ -20,7 +20,10 @@ * under the License. * */ +#ifndef _XPT2046_H_ +#define _XPT2046_H_ +#include "bflb_platform.h" #define TOUCH_PIN_CS GPIO_PIN_11 //#define TOUCH_PIN_PEN GPIO_PIN_11 @@ -39,5 +42,9 @@ #define XPT2046_X_MAX 3850 #define XPT2046_Y_MAX 3700 +extern struct device* touch_spi; + void xpt2046_init(void); -uint8_t xpt2046_read(uint16_t * x, uint16_t * y, int8_t rotated); +uint8_t xpt2046_read(int16_t * x, int16_t * y); + +#endif \ No newline at end of file diff --git a/bsp/bsp_common/usb/uart_interface.c b/bsp/bsp_common/usb/uart_interface.c index 30e52dd6..8259015b 100644 --- a/bsp/bsp_common/usb/uart_interface.c +++ b/bsp/bsp_common/usb/uart_interface.c @@ -78,6 +78,7 @@ void uart1_init(void) if (uart1) { device_open(uart1, DEVICE_OFLAG_DMA_TX | DEVICE_OFLAG_INT_RX); //uart0 tx dma mode + device_control(uart1, DEVICE_CTRL_SUSPEND, NULL); device_set_callback(uart1, uart_irq_callback); device_control(uart1, DEVICE_CTRL_SET_INT, (void *)(UART_RX_FIFO_IT | UART_RTO_IT)); } @@ -121,29 +122,38 @@ void uart1_config(uint32_t baudrate, uart_databits_t databits, uart_parity_t par device_control(uart1, DEVICE_CTRL_CONFIG, &cfg); } +static uint8_t uart1_dtr; +static uint8_t uart1_rts; + +void uart1_set_dtr_rts(uint8_t dtr, uint8_t rts) +{ + uart1_dtr = dtr; + uart1_rts = rts; +} + void uart1_dtr_init(void) { - gpio_set_mode(GPIO_PIN_22, GPIO_OUTPUT_MODE); + gpio_set_mode(uart1_dtr, GPIO_OUTPUT_MODE); } void uart1_rts_init(void) { - gpio_set_mode(GPIO_PIN_21, GPIO_OUTPUT_MODE); + gpio_set_mode(uart1_rts, GPIO_OUTPUT_MODE); } void uart1_dtr_deinit(void) { - gpio_set_mode(GPIO_PIN_22, GPIO_INPUT_MODE); + gpio_set_mode(uart1_dtr, GPIO_INPUT_MODE); } void uart1_rts_deinit(void) { - gpio_set_mode(GPIO_PIN_21, GPIO_INPUT_MODE); + gpio_set_mode(uart1_rts, GPIO_INPUT_MODE); } void dtr_pin_set(uint8_t status) { - gpio_write(GPIO_PIN_22, status); + gpio_write(uart1_dtr, status); } void rts_pin_set(uint8_t status) { - gpio_write(GPIO_PIN_21, status); + gpio_write(uart1_rts, status); } void ringbuffer_lock() { diff --git a/bsp/bsp_common/usb/uart_interface.h b/bsp/bsp_common/usb/uart_interface.h index 56cfba99..3cf23c2d 100644 --- a/bsp/bsp_common/usb/uart_interface.h +++ b/bsp/bsp_common/usb/uart_interface.h @@ -32,6 +32,7 @@ extern Ring_Buffer_Type uart1_rx_rb; void uart1_init(void); void uart1_config(uint32_t baudrate,uart_databits_t databits,uart_parity_t parity,uart_stopbits_t stopbits); +void uart1_set_dtr_rts(uint8_t dtr, uint8_t rts); void uart1_dtr_init(void); void uart1_rts_init(void); void uart1_dtr_deinit(void); diff --git a/bsp/bsp_common/usb/usb_dc.c b/bsp/bsp_common/usb/usb_dc.c index a96d2756..30458047 100644 --- a/bsp/bsp_common/usb/usb_dc.c +++ b/bsp/bsp_common/usb/usb_dc.c @@ -79,6 +79,7 @@ int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg) } int usbd_ep_close(const uint8_t ep) { + device_control(usb,DEVICE_CTRL_USB_DC_SET_NACK,(void*)(uint32_t)ep); return 0; } int usbd_ep_set_stall(const uint8_t ep)