void testTask(void *pvParameters) { for (;;) { Serial_print("Voltage: "); Serial_printInteger(getVoltage(ADC_readValue(0)), 10); Serial_print("V\n"); vTaskDelay(1000); } vTaskDelete(NULL); }
void loop(void) { Serial_println("Sending to nrf24_reliable_datagram_server"); // Send a message to manager_server if (manager.sendtoWait(data, sizeof(data), SERVER_ADDRESS)) { // Now wait for a reply from the server uint8_t len = sizeof(buf); uint8_t from; if (manager.recvfromAckTimeout(buf, &len, 2000, &from)) { uint8_t buf[16]; Serial_print("got reply from : 0x"); buf[0] = '\0'; UTIL1_strcatNum16Hex(buf, sizeof(buf), from); Serial_print((const char*)buf); Serial_print(": "); Serial_println((char*)buf); } else { Serial_println("No reply, is nrf24_reliable_datagram_server running?"); } } else { Serial_println("sendtoWait failed"); } delay(500); }
void loop(void) { static int cntr = 0; uint8_t buffer[32]; if (device.available()) { // Should be a message for us now uint8_t buf[RH_APP_MAX_MESSAGE_LEN]; uint8_t len = sizeof(buf); if (device.recv(buf, &len)) { LED2_Neg(); cntr++; UTIL1_Num32uToStr(buffer, sizeof(buffer), cntr); UTIL1_strcat(buffer, sizeof(buffer), (const unsigned char*)": "); Serial_print((const char*)buffer); Serial_print("got request: "); Serial_println((char*)buf); // Send a reply uint8_t data[] = "And hello back to you"; device.send(data, sizeof(data)); device.waitPacketSent(); Serial_println("Sent a reply"); } else { Serial_println("recv failed"); } } }
void Serial_print(USART_TypeDef *USARTx, int value, int base) { char buffer[8 * sizeof(value) + 1]; // Null byte to the end. char *str = &buffer[sizeof(buffer) - 1]; *str = '\0'; // If negative, print minus and make it positive. if ( value < 0 ) { Serial_print(USARTx, "-"); value = -value; } // Loop the number from least significant to most significant. do { int m = value; value /= base; char c = m - base * value; if ( c < 10 ) { // Numbers are continously in ASCII from 0 to 9 at 48 to 57 *--str = c + '0'; } else { // Capital letters are also continously in ASCII starting with A in 65 *--str = c + 'A' - 10; } } while(value); Serial_print(USARTx, str); }
// simple line entry only handles backspace void Serial_GetLine(char *buffer, size_t length) { size_t cursor = 0; buffer[cursor] = '\0'; for (;;) { char c = Serial_GetChar(); if ('\010' == c || 127 == c) { if (cursor > 0) { buffer[--cursor] = '\0'; Serial_print("\010 \010"); } else { Serial_print("\007"); } } else if (c >= ' ' && c < 127) { if (cursor < length - 1) { // remember space for the '\0' buffer[cursor++] = c; buffer[cursor] = '\0'; Serial_PutChar(c); } else { Serial_print("\007"); } } else if ('\r' == c || '\n' == c) { return; } } }
/* * application.cpp * * Created on: 23.07.2016 * Author: Erich Styger Local */ #include "Platform.h" #include "Kinetis.h" #include "application.h" #if PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_NRF24L01 #include <RH_NRF24.h> #elif PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_RH_RF95 #include <RH_RF95.h> #endif #include "CLS1.h" #include "UTIL1.h" #include "LED1.h" #include "LED2.h" #include <RHReliableDatagram.h> #include <stdlib.h> #define IS_CLIENT 0 /* client or server */ #define IS_RELIABLE 0 /* reliable or not */ #define CLIENT_ADDRESS 1 #define SERVER_ADDRESS 2 // Singleton instance of the radio driver #if PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_NRF24L01 static RH_NRF24 device(KINETIS_CE, KINETIS_SS); #define RH_APP_MAX_MESSAGE_LEN RH_NRF24_MAX_MESSAGE_LEN #elif PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_RH_RF95 static RH_RF95 device(KINETIS_SS, KINETIS_ISR1); #define RH_APP_MAX_MESSAGE_LEN RH_RF95_MAX_MESSAGE_LEN #endif static void Serial_println(const char *msg) { CLS1_ConstStdIOType *io = CLS1_GetStdio(); CLS1_SendStr((const unsigned char*)msg, io->stdOut); CLS1_SendStr((const unsigned char*)"\r\n", io->stdOut); } void Serial_print(const char *msg) { CLS1_SendStr((const unsigned char*)msg, CLS1_GetStdio()->stdOut); } #if IS_CLIENT && !IS_RELIABLE /* not reliable client */ void setup(void) { Serial_print("----------------------------------------------\r\n"); #if PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_NRF24L01 Serial_print("NRF24L01+ Client (not reliable)\r\n"); #elif PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_RH_RF95 Serial_print("RF95x (LoRa) Client (not reliable)\r\n"); #endif Serial_println("----------------------------------------------\r\n"); if (!device.init()) { Serial_println("init failed"); } #if PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_NRF24L01 // Defaults after init are 2.402 GHz (channel 2), 2Mbps, 0dBm if (!device.setChannel(1)) { Serial_println("setChannel failed"); } if (!device.setRF(RH_NRF24::DataRate2Mbps, RH_NRF24::TransmitPower0dBm)) { Serial_println("setRF failed"); } #elif PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_RH_RF95 // Defaults after init are 434.0MHz, 13dBm, Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on // The default transmitter power is 13dBm, using PA_BOOST. // If you are using RFM95/96/97/98 modules which uses the PA_BOOST transmitter pin, then // you can set transmitter powers from 5 to 23 dBm: // driver.setTxPower(23, false); // If you are using Modtronix inAir4 or inAir9,or any other module which uses the // transmitter RFO pins and not the PA_BOOST pins // then you can configure the power transmitter power for -1 to 14 dBm and with useRFO true. // Failure to do that will result in extremely low transmit powers. // driver.setTxPower(14, true); #endif }
void assert_failed(uint8_t* file, uint32_t line) { Serial_print(USART2, (char*)file); Serial_print(USART2, ":"); Serial_print(USART2, (int)line, 10); Serial_println(USART2, " Assert failed"); while (1) { BlinkBlue(1); } }
void print_CameraDataHex() { int line, column; for (line = 0; line < VERTICAL_RESOLUTION; ) { for (column = 0; column < HORIZONTAL_RESOLUTION;) { // Serial_print(USART2, (Targetbuffer[line*HORIZONTAL_RESOLUTION+column] >> 8) & 0xff, 16); Serial_print(USART2, (Targetbuffer[line*HORIZONTAL_RESOLUTION+column]) , 16); column = column + 8; Serial_print(USART2, " "); } Serial_print(USART2, "\r\n"); line = line + 4; } }
void setup(void) { Serial_print("----------------------------------------------\r\n"); #if PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_NRF24L01 Serial_print("NRF24L01+ Server (reliable)\r\n"); #elif PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_RH_RF95 Serial_print("RF95x (LoRa) Server (reliable)\r\n"); #endif Serial_println("----------------------------------------------\r\n"); srand(50); /* initialize random seed */ /* \todo use soemthing 'random' */ if (!manager.init()) Serial_println("init failed"); // Defaults after init are 2.402 GHz (channel 2), 2Mbps, 0dBm }
extern void Serial_Process(void){ Rx = SciaRegs.SCIRXBUF.all; //caracter recibido if(Rx == 0x61) init = true; if(Rx == 0x62){ Serial_print(itoa[doaG]); //envia el ángulo Serial_print("*\0"); } if(Rx == 0x07A) Serial_print("Estoy Funcionando\n\0"); }
uint32_t SDHashClass::fnv(uint8_t *buf, size_t len, uint32_t hval) { Serial_print("fnv:0x"); Serial_print(hval, HEX); Serial_print(" .. "); uint8_t *end = buf+len; if (!hval) hval = 2166136261; for(;buf < end;++buf) { hval ^= (uint32_t)*buf; hval += (hval<<1) + (hval<<4) + (hval<<7) + (hval<<8) + (hval<<24); } Serial_print("0x"); Serial_println(hval, HEX); return hval; }
void loop(void) { Serial_println("Sending to nrf24_server"); // Send a message to nrf24_server uint8_t data[] = "Hello World!"; nrf24.send(data, sizeof(data)); nrf24.waitPacketSent(); // Now wait for a reply uint8_t buf[RH_NRF24_MAX_MESSAGE_LEN]; uint8_t len = sizeof(buf); if (nrf24.waitAvailableTimeout(500)) { // Should be a reply message for us now if (nrf24.recv(buf, &len)) { Serial_print("got reply: "); Serial_println((char*)buf); } else { Serial_println("recv failed"); } } else { Serial_println("No reply, is nrf24_server running?"); } delay(400); }
void callback(char *topic, byte *payload, unsigned int length) { Serial_print("Message arrived ["); Serial_print(topic); Serial_print("] "); for (int i = 0; i < length; i++) { Serial_print((char)payload[i]); } Serial_println(); if(strcmp(control_topic,topic)==0){ if ((char)payload[0] == '1') { ledstate = false; digitalWrite(LED_PIN, LOW); } else { ledstate = true; digitalWrite(LED_PIN, HIGH); } } }
void reconnect() { while (!client.connected()) { Serial_print("Attempting MQTT connection..."); if (client.connect("ESP8266Client")) { Serial_println("connected"); client.publish(status_topic, "system ready"); client.subscribe(control_topic); } else { handle_switching(); Serial_print("failed, rc="); Serial_print(client.state()); Serial_println(" try again in 5 seconds"); for(int msec=0; msec < 5000; msec+= 500){ delay(500); handle_switching(); } } } }
void Serial_HexDump(const void *buffer, size_t size) { uint32_t start = (uint32_t)buffer & 0x0f; uint32_t address = (uint32_t)buffer & ~0x0f; const uint8_t *bytes = (const uint8_t *)address; size_t offset; for (offset = 0; offset < start + size; offset += 16) { Serial_printf("%08lx: ", address + offset); int i; for (i = 0; i < 16; ++i) { if (8 == i) { Serial_PutChar(' '); } if (offset + i < start || offset + i >= start + size) { Serial_print(" --"); } else { Serial_printf(" %02x", bytes[offset + i]); } } Serial_print(" |"); for (i = 0; i < 16; i++) { if (8 == i) { Serial_PutChar(' '); } if (offset + i < start || offset + i >= start + size) { Serial_PutChar(' '); } else if (isprint(bytes[offset + i])) { Serial_PutChar(bytes[offset + i]); } else { Serial_PutChar('.'); } } Serial_print("|\n"); } }
void DMA2_Stream1_IRQHandler(void) { GPIO_SetBits(GPIOD, ORANGE_LED); if ( DMA_GetITStatus(DMA2_Stream1, DMA_IT_DMEIF1) != RESET) { // direct mode error interrupt Serial_print(USART2, "direct mode error interrupt\r\n"); while (1) { GPIO_ToggleBits(GPIOD, ORANGE_LED); ms_delay(200); } // DMA_ClearITPendingBit(DMA2_Stream1, DMA_IT_DMEIF1); } if ( DMA_GetITStatus(DMA2_Stream1, DMA_IT_FEIF1) != RESET) { // FIFO error interrupt Serial_print(USART2, "FIFO error interrupt\r\n"); while (1) { GPIO_ToggleBits(GPIOD, ORANGE_LED); ms_delay(800); } // DMA_ClearITPendingBit(DMA2_Stream1, DMA_IT_FEIF1); } if ( DMA_GetITStatus(DMA2_Stream1, DMA_IT_HTIF1) != RESET) { // half transfer complete interrupt DMA_ClearITPendingBit(DMA2_Stream1, DMA_IT_HTIF1); } if ( DMA_GetITStatus(DMA2_Stream1, DMA_IT_TCIF1) != RESET) { // transfer complete interrupt DMA_ClearITPendingBit(DMA2_Stream1, DMA_IT_TCIF1); } if ( DMA_GetITStatus(DMA2_Stream1, DMA_IT_TEIF1) != RESET) { // transfer error interrupt Serial_print(USART2, "transfer error interrupt\r\n"); while (1) { GPIO_ToggleBits(GPIOD, ORANGE_LED); ms_delay(1500); } // DMA_ClearITPendingBit(DMA2_Stream1, DMA_IT_TEIF1); } }
void handle_switching(void){ if(interrupted){ digitalWrite(LED_PIN, ledstate); if(client.connected()){ snprintf (msg, 75, "%ld", ledstate ? 0 : 1); Serial_print("Publish override message: ledstate "); Serial_println(msg); client.publish(override_topic, msg); interrupted = false; } } }
uint8_t SDHashClass::createFile(SDHFilehandle fh, const char *filename, uint8_t *data, SDHDataSize len) { SDHAddress addr; if (statFile(fh, NULL, &addr) == SDH_ERR_FILE_NOT_FOUND) { Serial_print("addr="); Serial_println(addr); uint8_t namelen = strlen(filename); char name_padding = kSDHashMaxFilenameLength - namelen; if (name_padding <= 0) return SDH_ERR_FILENAME; name_padding+=1; if(!_card.writeStart(addr, 1)) return SDH_ERR_SD; uint8_t ofs = 0; uint8_t type = kSDHashSegment0; if(!_card.writeData(&type, sizeof type, ofs)) return SDH_ERR_SD; ofs+= sizeof type; if(!_card.writeData((uint8_t*)&fh, sizeof fh, ofs)) return SDH_ERR_SD; ofs += sizeof fh; uint16_t seg_count = _BSWAP16(1); if(!_card.writeData((uint8_t*)&seg_count, sizeof seg_count, ofs)) return SDH_ERR_SD; ofs += sizeof seg_count; if(!_card.writeData((uint8_t*)filename, namelen, ofs)) return SDH_ERR_SD; ofs += namelen; for(uint8_t cnt = 0; cnt < name_padding; ++cnt) { if(!_card.writeData((uint8_t*)&name_padding, sizeof name_padding, ofs)) return SDH_ERR_SD; ofs += sizeof name_padding; } if(!_card.writeDataPadding(512 - ofs)) return SDH_ERR_SD; if(!_card.writeStop()) return SDH_ERR_SD; #ifdef LOGGING_ENABLED if (namelen >=kSDHashHiddenFilenamePrefixLen) { if (memcmp(filename, kSDHashHiddenFilenamePrefix, kSDHashHiddenFilenamePrefixLen)) { uint8_t ret = _appendLog(kSDHashLogCreate, addr); if (ret != SDH_OK) return ret; } } #endif if (data && len) return appendFile(fh, data, len); return SDH_OK; } else return SDH_ERR_FILE_EXISTS; }
void loop(void) { if (manager.available()) { // Wait for a message addressed to us from the client uint8_t len = sizeof(buf); uint8_t from; if (manager.recvfromAck(buf, &len, &from)) { uint8_t buf[16]; Serial_print("got request from : 0x"); buf[0] = '\0'; UTIL1_strcatNum16Hex(buf, sizeof(buf), from); Serial_print((const char*)buf); Serial_print(": "); Serial_println((char*)buf); // Send a reply back to the originator client if (!manager.sendtoWait(data, sizeof(data), from)) Serial_println("sendtoWait failed"); } } }
void print_CameraData() { int line, column; for (line = 0; line < VERTICAL_RESOLUTION; ) { for (column = 0; column < HORIZONTAL_RESOLUTION;) { if ( Targetbuffer[line*HORIZONTAL_RESOLUTION+column] > 0x00 && Targetbuffer[line*HORIZONTAL_RESOLUTION+column] < 0x4000 ) { Serial_print(USART2, " "); } if ( Targetbuffer[line*HORIZONTAL_RESOLUTION+column] >= 0x4000 && Targetbuffer[line*HORIZONTAL_RESOLUTION+column] < 0x8000 ) { Serial_print(USART2, "."); } if ( Targetbuffer[line*HORIZONTAL_RESOLUTION+column] >= 0x8000 && Targetbuffer[line*HORIZONTAL_RESOLUTION+column] < 0xb000 ) { Serial_print(USART2, "o"); } if ( Targetbuffer[line*HORIZONTAL_RESOLUTION+column] >= 0xb000 && Targetbuffer[line*HORIZONTAL_RESOLUTION+column] < 0xffff ) { Serial_print(USART2, "#"); } column = column + 2; } Serial_print(USART2, "\r\n"); line = line + 4; } }
static void showStatus(bool aborting) { Serial.print(isPlaying ? "1" : "0"); Serial_print("\t"); Serial.print(aborting ? "1" : "0"); Serial_print("\t"); Serial.print((int) pressure); Serial_print("\t"); Serial.print((int) cellTemperature); Serial_print("\t"); Serial.print((int) mosfetTemperature); Serial_print("\t"); Serial.print((int) ambientTemperature); Serial_print("\t"); Serial.print((int) current); Serial_print("\t"); Serial.print(maxPressure); Serial_print("\t"); Serial.print(maxCurrent); Serial.println(); }
void setup_wifi() { delay(10); Serial_println(); Serial_print("Connecting to "); Serial_println(ssid); WiFi.mode(WIFI_STA); WiFi.begin(ssid, password); delay(10); while (WiFi.waitForConnectResult() != WL_CONNECTED) { Serial_println("Connection failed! rebooting..."); delay(5000); ESP.restart(); } Serial_println("WiFi connected"); Serial_println("IP address: "); Serial_println(WiFi.localIP()); }
void loop() { handle_switching(); if (!client.connected()) { reconnect(); } client.loop(); long now = millis(); if (now - lastMsg > 5000) { lastMsg = now; snprintf (msg, 75, "%ld", ledstate ? 0 : 1); Serial_print("Publish status message: ledstate "); Serial_println(msg); client.publish(status_topic, msg); } delay(90); }
void loop(void) { if (nrf24.available()) { // Should be a message for us now uint8_t buf[RH_NRF24_MAX_MESSAGE_LEN]; uint8_t len = sizeof(buf); if (nrf24.recv(buf, &len)) { // NRF24::printBuffer("request: ", buf, len); Serial_print("got request: "); Serial_println((char*)buf); // Send a reply uint8_t data[] = "And hello back to you"; nrf24.send(data, sizeof(data)); nrf24.waitPacketSent(); Serial_println("Sent a reply"); } else { Serial_println("recv failed"); } } }
uint8_t SDHashClass::begin() { _validCard = false; pinMode(10, OUTPUT); _card.init(); // stop any reads and writes that were in progress // when serial monitor started/stopped, or if we got // reset while the SD card didn't _card.writeStop(); _card.readEnd(); if (_getHashInfo()) { _validCard = true; Serial_print("found SDHash, version="); Serial_print(_hashInfo.version, DEC); Serial_print(" buckets="); Serial_println(_hashInfo.buckets); // make sure our buckets count is smaller than cardsize // otherwise things are going to go haywire if (_hashInfo.buckets > _card.cardSize()) { Serial_println("card isn't big enough"); return SDH_ERR_CARD; } #ifdef LOGGING_ENABLED if (statFile(kSDHashLogFilenameHash, NULL, NULL) == SDH_ERR_FILE_NOT_FOUND) { return SDHash.createFile(kSDHashLogFilenameHash, kSDHashLogFilename); } #endif return SDH_OK; } else { _hashInfo.version = 1; _hashInfo.buckets = _card.cardSize(); if (_hashInfo.buckets) { uint8_t header[kSDHashHeaderSize]; memcpy(header, kSDHashMagic, sizeof kSDHashMagic); header[sizeof kSDHashMagic] = _hashInfo.version; _hashInfo.buckets = _BSWAP32(_hashInfo.buckets); memcpy(header + sizeof kSDHashMagic + 1, &_hashInfo.buckets, sizeof _hashInfo.buckets); if (_card.writeBlock(0, header, sizeof header)) { Serial_println("card marked as SDHash"); _validCard = true; } else { Serial_print("failed to write header=0x"); Serial_println(_card.errorCode(), HEX); return SDH_ERR_SD; } #ifdef LOGGING_ENABLED SDHash.deleteFile(kSDHashLogFilenameHash); return SDHash.createFile(kSDHashLogFilenameHash, kSDHashLogFilename); #else return SDH_OK; #endif } else { Serial_println("card has no buckets?"); return SDH_ERR_CARD; } } }
void loop(void) { #if PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_RH_RF95 Serial_println("Sending to RF95 LoRa server"); #elif PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_NRF24L01 Serial_println("Sending to nRF24L01+ server"); #endif // Send a message to nrf24_server uint8_t data[] = "Hello World!"; device.send(data, sizeof(data)); device.waitPacketSent(); // Now wait for a reply uint8_t buf[RH_APP_MAX_MESSAGE_LEN]; uint8_t len = sizeof(buf); #if PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_RH_RF95 if (device.waitAvailableTimeout(3000)) { #elif PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_NRF24L01 if (device.waitAvailableTimeout(500)) { #endif // Should be a reply message for us now if (device.recv(buf, &len)) { LED1_Neg(); Serial_print("got reply: "); Serial_println((char*)buf); } else { Serial_println("recv failed"); } } else { Serial_println("No reply, is server running?"); } delay(400); } #elif !IS_CLIENT && !IS_RELIABLE /* not reliable server */ void setup(void) { Serial_print("----------------------------------------------\r\n"); #if PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_NRF24L01 Serial_print("NRF24L01+ Server (not reliable)\r\n"); #elif PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_RH_RF95 Serial_print("RF95x (LoRa) Server (not reliable)\r\n"); #endif Serial_println("----------------------------------------------\r\n"); if (!device.init()) { Serial_println("init failed"); } #if PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_NRF24L01 // Defaults after init are 2.402 GHz (channel 2), 2Mbps, 0dBm if (!device.setChannel(1)) { Serial_println("setChannel failed"); } if (!device.setRF(RH_NRF24::DataRate2Mbps, RH_NRF24::TransmitPower0dBm)) { Serial_println("setRF failed"); } #elif PL_RH_TRANSCEIVER_TYPE==PL_RH_TRANSCEIVER_RH_RF95 // The default transmitter power is 13dBm, using PA_BOOST. // If you are using RFM95/96/97/98 modules which uses the PA_BOOST transmitter pin, then // you can set transmitter powers from 5 to 23 dBm: // driver.setTxPower(23, false); // If you are using Modtronix inAir4 or inAir9,or any other module which uses the // transmitter RFO pins and not the PA_BOOST pins // then you can configure the power transmitter power for -1 to 14 dBm and with useRFO true. // Failure to do that will result in extremely low transmit powers. // driver.setTxPower(14, true); #endif }
void Serial_println(USART_TypeDef *USARTx, char *s) { Serial_print(USARTx, s); Serial_print(USARTx, "\r\n"); }
int main() { SysTick_Config(SystemCoreClock / 1000); InitLeds(); GPIO_SetBits(GPIOD, GREEN_LED); Delay(100); GPIO_ResetBits(GPIOD, GREEN_LED); GPIO_SetBits(GPIOD, ORANGE_LED); Delay(100); GPIO_ResetBits(GPIOD, ORANGE_LED); GPIO_SetBits(GPIOD, RED_LED); Delay(100); GPIO_ResetBits(GPIOD, RED_LED); GPIO_SetBits(GPIOD, BLUE_LED); Delay(100); GPIO_ResetBits(GPIOD, BLUE_LED); /** * USART */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC, ENABLE); GPIO_PinAFConfig(USART2_TX_PORT, USART2_TX_PIN_SOURCE, GPIO_AF_USART2); GPIO_PinAFConfig(USART2_RX_PORT, USART2_RX_PIN_SOURCE, GPIO_AF_USART2); /* Configure USART Tx as alternate function */ GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Pin = USART2_TX_PIN; GPIO_Init(USART2_TX_PORT, &GPIO_InitStructure); /* Configure USART Rx as alternate function */ GPIO_InitStructure.GPIO_Pin = USART2_RX_PIN; GPIO_Init(USART2_RX_PORT, &GPIO_InitStructure); USART_InitTypeDef USART_InitStructure; USART_InitStructure.USART_BaudRate = 115200; USART_InitStructure.USART_WordLength = USART_WordLength_8b; USART_InitStructure.USART_StopBits = USART_StopBits_1; USART_InitStructure.USART_Parity = USART_Parity_No; USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; USART_Init(USART2, &USART_InitStructure); /* Enable USART */ USART_Cmd(USART2, ENABLE); Serial_print(USART2, "Hello World! -- Compiled on: "); Serial_print(USART2, __DATE__); Serial_print(USART2, " - "); Serial_println(USART2, __TIME__); /** * Interrupts */ NVIC_InitTypeDef NVIC_InitStructure; NVIC_InitStructure.NVIC_IRQChannel = DCMI_IRQn; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_Init(&NVIC_InitStructure); DCMI_ClearITPendingBit(DCMI_IT_FRAME | DCMI_IT_OVF | DCMI_IT_ERR); DCMI_ITConfig(DCMI_IT_FRAME | DCMI_IT_OVF | DCMI_IT_ERR, ENABLE); NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream1_IRQn; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_Init(&NVIC_InitStructure); DMA_ClearITPendingBit(DMA2_Stream1, DMA_IT_TCIF1 | DMA_IT_TEIF1); DMA_ITConfig(DMA2_Stream1, DMA_IT_TC | DMA_IT_FE | DMA_IT_TE | DMA_IT_DME, ENABLE); Serial_print(USART2, "Interrupts done. \r\n"); /** Camera Reset Pin & Power Down Pin */ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_Speed = GPIO_Low_Speed; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_9; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_SetBits(GPIOA, GPIO_Pin_10); GPIO_ResetBits(GPIOA, GPIO_Pin_9); /** * DCMI */ OV2640_HW_Init(); Serial_print(USART2, "HW_Init done. \r\n"); /* Print camera Id */ OV2640_IDTypeDef camera_id; OV2640_ReadID(&camera_id); Serial_print(USART2, "Camera ID: "); Serial_print(USART2, camera_id.Manufacturer_ID1, 16); Serial_print(USART2, " - "); Serial_print(USART2, camera_id.Manufacturer_ID2, 16); Serial_print(USART2, " - "); Serial_print(USART2, camera_id.PIDH, 16); Serial_print(USART2, " - "); Serial_print(USART2, camera_id.PIDL, 16); Serial_println(USART2, ""); OV2640_QQVGAConfig(); Serial_print(USART2, "QQVGAConfig done. \r\n"); // OV2640_BandWConfig(0x18); // BW OV2640_Init(BMP_QQVGA); Serial_print(USART2, "Init done. \r\n"); // Memset int i; for (i=0; i<160*120; i++) { Targetbuffer[i] = 0xbeef; } DMA_Cmd(DMA2_Stream1, ENABLE); while ( DMA_GetCmdStatus(DMA2_Stream1) != ENABLE ) ; Serial_print(USART2, "DMA Enable done. \r\n"); DCMI_Cmd(ENABLE); Serial_print(USART2, "DCMI Enable done. \r\n"); DCMI_CaptureCmd(ENABLE); Serial_print(USART2, "DCMI Capture start. \r\n"); Serial_print(USART2, "Print: \r\n.\r\n.\r\n"); Serial_print(USART2, "done. \r\n"); Delay(1); // Clear screen Serial_print(USART2, 0x1b); Serial_print(USART2, "[2J"); while (1) { while (DCMI_GetFlagStatus(DCMI_FLAG_FRAMERI) == RESET) ; print_CameraData(); // Move cursor to home position. Serial_print(USART2, 0x1b); Serial_print(USART2, "[H"); } }
void Serial_print_c(USART_TypeDef *USARTx, int value, int base) { Serial_print(USARTx, value, base); }