Оптическое распознавание символов на микроконтроллере |
| Имя состояния,номер | Описание состояния | Сигнал к переходу в другое состояние |
| camoff,0 | камера не готова к работе |
vzz (vsync=1,href=0,pclk=0) |
| frapause, 1 | пауза между кадрами. ожидание начала кадра. |
zzz (vsync=0,href=0,pclk=0) |
| framebeg, 2 | чтение кадра. ожидание начала строки в кадре. |
zhz (vsync=0,href=1,pclk=0) |
| framebeg, 2 | чтение кадра. ожидание конца кадра после чтения последнего пикселя |
vzz (vsync=1,href=0,pclk=0) |
| fbyteread, 3 | яркостный байт прочитан. ожидание начала паузы перед цветоразностным байтом. |
zhz (vsync=0,href=1,pclk=0) |
| fpause, 4 | пауза перед цветоразностным байтом. ожидание начала чтения цветоразностного байта. |
zhp (vsync=0,href=1,pclk=1) |
| sbyteread, 5 | цветоразностный байт прочитан. ожидание начала паузы перед яркостным байтом. |
zhz (vsync=0,href=1,pclk=0) |
| spause, 6 | пауза перед яркостным байтом. ожидание окончания строки. |
zzz (vsync=0,href=0,pclk=0) |
| spause, 6 | пауза перед яркостным байтом. ожидание начала чтения яркостного байта. |
zhp (vsync=0,href=1,pclk=1) |
#include "ets_sys.h"
#include "osapi.h"
#include "os_type.h"
#include
#include "driver/uart_register.h"
#include "user_config.h"
#include "user_interface.h"
#include "driver/uart.h"
#include "readCam.h"
#define DELAY 5000 /* milliseconds */
LOCAL os_timer_t cam_timer;
uint16_t frN;
extern uint8_t pixVal;
uint8_t rN[10];
LOCAL void ICACHE_FLASH_ATTR getNFrame(void *arg){
uint16_t sig, sV,sH,sP;
uint16_t pVal;
uint16_t d7,d6,d5,d4,d3,d2;
stateMashine camSM;
ets_uart_printf("getNFrame...\r\n");
initSMcm(&camSM);
while(frN<20){
system_soft_wdt_feed();
pVal= *GPIO_IN;
sV=((pVal&(1UL<>VSYNC);
sH=((pVal&(1UL<>HREF);
sP=((pVal&(1UL<>PCLK);
sig=4*sV+2*sH+sP*sH;
d7=((pVal&(1UL<>D7);
d6=((pVal&(1UL<>D6);
d5=((pVal&(1UL<>D5);
d4=((pVal&(1UL<>D4);
d3=((pVal&(1UL<>D3);
d2=((pVal&(1UL<>D2);
pixVal=128*d7+64*d6+32*d5+16*d4+8*d3+4*d2;
exCAM(&camSM,sig,&frN,rN);
}
}
uint32 ICACHE_FLASH_ATTR user_rf_cal_sector_set(void)
{
enum flash_size_map size_map = system_get_flash_size_map();
uint32 rf_cal_sec = 0;
switch (size_map) {
case FLASH_SIZE_4M_MAP_256_256:
rf_cal_sec = 128 - 8;
break;
case FLASH_SIZE_8M_MAP_512_512:
rf_cal_sec = 256 - 5;
break;
case FLASH_SIZE_16M_MAP_512_512:
case FLASH_SIZE_16M_MAP_1024_1024:
rf_cal_sec = 512 - 5;
break;
case FLASH_SIZE_32M_MAP_512_512:
case FLASH_SIZE_32M_MAP_1024_1024:
rf_cal_sec = 1024 - 5;
break;
default:
rf_cal_sec = 0;
break;
}
return rf_cal_sec;
}
void ICACHE_FLASH_ATTR user_init(void){
void (*cbGetFrame)(void *arg);
cbGetFrame=(void*)getNFrame;
UARTInit(BIT_RATE_921600);
user_gpio_init();
os_timer_disarm(&cam_timer);
os_timer_setfn(&cam_timer, (os_timer_func_t *)cbGetFrame, NULL);
os_timer_arm(&cam_timer, DELAY, 0);
}
#ifndef INCLUDE_READCAM_H_
#define INCLUDE_READCAM_H_
#define GPIO_IN ((volatile uint32_t*) 0x60000318)
#define WP 320
#define HP 240
#define PIXTYP 0
//image __________________________________________
#define IMAGEY0 60
#define IMAGEH HP/3
//____________________pins_____________________
#define VSYNC 15
#define HREF 13
#define PCLK 3
#define D7 4
#define D6 12
#define D5 0
#define D4 14
#define D3 2
#define D2 5
//*************signals OV7670*****************
#define ZZZ 0
#define VZZ 4
#define ZHZ 2
#define ZHP 3
//*************states OV7670*******************
#define CAMOFF 0
#define FRAPAUSE 1
#define FRAMEBEG 2
#define FBYTEREAD 3
#define FPAUSE 4
#define SBYTEREAD 5
#define SPAUSE 6
#define SSCC 40//max state_signal_condition count
#define STATE_L 5
#define STATE_V 0x1F
#define SIG_L 8
#define SIG_V 0xFF
typedef struct {
uint8 pix[WP] ;
}linePixel;
typedef struct gen{
uint8_t state;
uint8_t sig;
uint8_t stateX;
void *fp;
}gen;
typedef struct stateMashine{
uint8_t count;
uint16_t ssc[SSCC];
uint8_t stateX[SSCC];
void *fPoint[SSCC];
void *fpd;
}stateMashine;
#endif /* INCLUDE_READCAM_H_ */
#include "ets_sys.h"
#include "osapi.h"
#include "os_type.h"
#include
#include "driver/uart_register.h"
#include "user_config.h"
#include "user_interface.h"
#include "driver/uart.h"
#include "readCam.h"
void sendLine(uint16_t lN);
void ICACHE_FLASH_ATTR sendFramMark(void);
void ICACHE_FLASH_ATTR sendCtr3Byte(uint8_t typ,uint16_t len);
void user_gpio_init(void);
void sendByte(uint8_t bt);
void ICACHE_FLASH_ATTR initSMcm(stateMashine *psm);
void exCAM( stateMashine *psm,uint8_t sig,uint16_t *frameN,uint8_t *rN);
int indexOf(stateMashine *psm,uint16_t ssc);
linePixel lp;
uint8_t pixVal;
void exCAM( stateMashine *psm,uint8_t sig,uint16_t *frameN,uint8_t *rN){
int16_t ind;
uint16_t lN;
uint16_t pN;
static uint8_t state=CAMOFF,stateX=CAMOFF;
static void (*pfun)()=NULL;
uint16_t stateSigCond=0;
stateSigCond|=((state&STATE_V)<<(16-STATE_L))|((sig&SIG_V)<<(16-STATE_L-SIG_L));
ind=indexOf(psm,stateSigCond);
if(ind>-1) stateX=(*psm).stateX[ind];
if(ind>-1) pfun=(*psm).fPoint[ind];
else pfun=(*psm).fpd;
pfun(frameN,&lN,&pN,rN);
state=stateX;
}
void _cm0(){}
void _cm1(uint16_t *fN,uint16_t *lN,uint16_t *pN){//new frame
sendFramMark();
sendCtr3Byte(PIXTYP,0);
(*lN)=0;
}
void _cm2(uint16_t *fN,uint16_t *lN,uint16_t *pN){//frame end
if(*lN==HP-1)(*fN)++;
}
void _cm3(uint16_t *fN,uint16_t *lN,uint16_t *pN){//new line
uint16_t pixN;
(*pN)=0;
// pixN=(*pN);//right image
pixN=WP-1-(*pN);//revers image
(lp).pix[pixN]=pixVal;
(*pN)++;
}
void _cm4(uint16_t *fN,uint16_t *lN,uint16_t *pN){// first byte
uint16_t pixN;
// pixN=(*pN);//right image
pixN=WP-1-(*pN);//reverse image
(lp).pix[pixN]=pixVal;
// if(pixN/right image
if(pixN)(*pN)++;//reverse image
}
void _cm5(uint16_t *fN,uint16_t *lN,uint16_t *pN,uint8_t *rN){//end line
uint16_t lineN;
lineN=(*lN);
sendLine(lineN);
if((*lN)/0#1
{FRAPAUSE,ZZZ,FRAMEBEG,_cm1},//1#2
{FRAMEBEG,VZZ,FRAPAUSE,_cm2},//2#1
{FRAMEBEG,ZHZ,FBYTEREAD,_cm3},//2#3
{FBYTEREAD,ZHP,FPAUSE,_cm0},//3#4
{FPAUSE,ZHZ,SBYTEREAD,_cm0},//4#5
{SBYTEREAD,ZHP,SPAUSE,_cm0},//5#6
{SPAUSE,ZHZ,FBYTEREAD,_cm4},//6#3
{SPAUSE,ZZZ,FRAMEBEG,_cm5},//6#2
{FPAUSE,ZZZ,FRAMEBEG,_cm5},//5#2
};
(*psm).count=count;
for(i=0;i>UART_TXFIFO_CNT_S)
& UART_TXFIFO_CNT;
}
buf[lenBuff] =bt;
uart0_tx_buffer(buf, lenBuff + 1);
}
void sendLine(uint16_t lN){
uint16_t j;
uint8_t sByt;
for(j=0;j(IMAGEY0+IMAGEH))sByt=0xFF;
sendByte(sByt);
}
}
void ICACHE_FLASH_ATTR user_gpio_init(void) {
ets_uart_printf("GPIO initialisation...\r\n");
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0);
gpio_output_set(0, 0, 0, BIT0); // Set GPIO0 as input
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U, FUNC_GPIO2);
gpio_output_set(0, 0, 0, BIT2); // Set GPIO2 as input
PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0RXD_U, FUNC_GPIO3);
gpio_output_set(0, 0, 0, BIT3); // Set GPIO3 as input
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO4_U, FUNC_GPIO4);
gpio_output_set(0, 0, 0, BIT4); // Set GPIO4 as input
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO5_U, FUNC_GPIO5);
gpio_output_set(0, 0, 0, BIT5); // Set GPIO5 as input
PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO12);
gpio_output_set(0, 0, 0, BIT1); // Set GPIO13 as input
PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTMS_U, FUNC_GPIO14);
gpio_output_set(0, 0, 0, BIT14); // Set GPIO14 as input
PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, FUNC_GPIO13); // Set GPIO13 function
gpio_output_set(0, 0, 0, BIT13); // Set GPIO13 as input
PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDO_U, FUNC_GPIO15);
gpio_output_set(0, 0, 0, BIT15); // Set GPIO15 as input
ets_uart_printf("...init done!\r\n");
}
void ICACHE_FLASH_ATTR sendFramMark(void){
sendByte(42);
sendByte(42);
}
void ICACHE_FLASH_ATTR sendCtr3Byte(uint8_t typ,uint16_t len){
uint8_t lLen,hLen;
sendByte(typ);
lLen=len&0xFF;
hLen=(len&(0xFF<<8))>>8;
sendByte(lLen);
sendByte(hLen);
}
var btn = document.getElementById('com');
var gui = require("nw.gui");
var select_com = document.getElementById('select_com');
var bdr = document.getElementById('bdr');
var canvas = document.getElementById('canvas');
var dev = document.getElementById('dev');
var ctx = canvas.getContext('2d');
var width = 320,
height = 240;
var byteCount = (width * height)/3;
var lastStr=byteCount-width;
var dataArr;
var dataStr;
var indArr = 0;
var dataArrLen = 0;
var byteCounter = 0;
var newStr = 0;
var sendTyp=0;
document.addEventListener('DOMContentLoaded', function() {
btn.addEventListener('click', function() {
connectCom(function(vector) {
drawImg(vector);
});
});
dev.addEventListener('click', function(){
var win = gui.Window.get();
win.showDevTools();
});
});
function drawImg(imgArr) {
var imgData = ctx.createImageData(width, height);
var ind;
for (var i = 0; i < imgArr.length; i++) {
imgData.data[4 * i] = imgArr[i];
imgData.data[4 * i + 1] = imgArr[i];
imgData.data[4 * i + 2] = imgArr[i];
imgData.data[4 * i + 3] = 255;
if(ilastStr){ //red line
imgData.data[4 * i] = 255;
imgData.data[4 * i + 1] = 0;
imgData.data[4 * i + 2] = 0;
imgData.data[4 * i + 3] = 255;
}
if(i<2*byteCount&&i>byteCount+lastStr){ //green line
imgData.data[4 * i] = 0;
imgData.data[4 * i + 1] = 255;
imgData.data[4 * i + 2] = 0;
imgData.data[4 * i + 3] = 255;
}
if(i<3*byteCount&&i>2*byteCount+lastStr){ //blue line
imgData.data[4 * i] = 0;
imgData.data[4 * i + 1] = 0;
imgData.data[4 * i + 2] = 255;
imgData.data[4 * i + 3] = 255;
}
}
ctx.putImageData(imgData, 0, 0);
imgArr.length=0;
}
function connectCom(callback) {
const PIXTYPE=0,BINTYPE=1,FIGTYPE=2;
var imgTyp=PIXTYPE;
var serialport = require('serialport');
var imgArr = [];
var framCount=0,strNum,colNum;
var pix=false;
var comm = 'COM' + select_com.value;
var boudrate = +bdr.value;
var SerialPort = serialport.SerialPort;
var port = new SerialPort(comm, {
baudRate: boudrate,
dataBits: 8,
stopBits: 1,
parity: "none",
bufferSize: 65536,
parser: SerialPort.parsers.byteLength(1)
});
port.on('open', function() {
console.log('Port ' + comm + ' Open');
});
port.on('data', function(data) {
if(imgTyp==PIXTYPE||imgTyp==BINTYPE){
if (data[0] == 42 && newStr == 0) {
newStr = 1;
data[0]=255;
}
if (newStr == 1 && data[0] == 42) {
newStr = 2;
}
if (newStr == 2 && byteCounter <2*byteCount) {
colNum=byteCounter%width;
strNum=(byteCounter-colNum)/width;
if(strNum%2==0){
imgArr[(strNum/2)*width+colNum]=data[0];
}
if(strNum%2==1){
imgArr[((strNum-1)/2)*width+byteCount+colNum]=data[0];
}
byteCounter++;
}
if (newStr == 2 && byteCounter == 2*byteCount) {
newStr = 0;
byteCounter = 0;
framCount++;
console.log('Frame Num ', framCount);
imgTyp=FIGTYPE;
}
}
if(imgTyp==FIGTYPE){
if (data[0] == 42 && newStr == 0) {
newStr = 1;
data[0]=255;
}
if (newStr == 1 && data[0] == 42) {
newStr = 2;
}
if (newStr == 2 && byteCounter < byteCount) {
imgArr[byteCounter+2*byteCount] = data[0];
byteCounter++;
}
if (newStr == 2 && byteCounter == byteCount) {
newStr = 0;
byteCounter = 0;
framCount++;
console.log('Frame Num ', framCount);
imgTyp=PIXTYPE;
callback(imgArr);
}
}
});
port.on('error', function() {
alert('Ошибка подключения к порту СОМ');
});
}
| Комментировать | « Пред. запись — К дневнику — След. запись » | Страницы: [1] [Новые] |
