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);
}
