/*
* 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 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)
{
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 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 setup(void) {
if (!nrf24.init())
Serial_println("init failed");
// Defaults after init are 2.402 GHz (channel 2), 2Mbps, 0dBm
if (!nrf24.setChannel(1))
Serial_println("setChannel failed");
if (!nrf24.setRF(RH_NRF24::DataRate2Mbps, RH_NRF24::TransmitPower0dBm))
Serial_println("setRF failed");
}
void setup(void) {
//Serial.begin(9600);
//while (!Serial)
// ; // wait for serial port to connect. Needed for Leonardo only
if (!nrf24.init())
Serial_println("init failed");
// Defaults after init are 2.402 GHz (channel 2), 2Mbps, 0dBm
if (!nrf24.setChannel(1))
Serial_println("setChannel failed");
if (!nrf24.setRF(RH_NRF24::DataRate2Mbps, RH_NRF24::TransmitPower0dBm))
Serial_println("setRF failed");
}
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
}
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 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 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 initialize() {
diLedPin.initialize(ledPin, 0);
led.initialize(&diLedPin, states, size(states), true);
diShiftRegisterInputPinPE.initialize(shiftRegisterInputPinCP, false);
diShiftRegisterInputPinCP.initialize(shiftRegisterInputPinCP, false);
diShiftRegisterInputPinQ7.initialize(shiftRegisterInputPinQ7, false);
shiftRegisterInput.initialize(DigitalInputShiftRegisterPinsCount,
&diShiftRegisterInputPinPE,
&diShiftRegisterInputPinCP,
&diShiftRegisterInputPinQ7);
Serial.begin(115200);
Serial_println("Initialized");
}
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");
}
}
}
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() {
int reading = 0;
int output=0;
int opposite_output=0;
digitalWrite(pwm_1,HIGH);
digitalWrite(pwm_2,HIGH);
for (int i=0;i<5;i++)
reading+= analogRead(pot);
output=reading/5;
opposite_output=1023-output;
analogWrite(dir_2,output);
analogWrite(dir_1,opposite_output);
delay(30);
Serial_printString("DIR");
Serial_println();
Serial_printNumber(output,DEC);
}
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 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 RepRapMain::setup() {
reader.initialize(115200, size(readerBuffer), readerBuffer);
extruderTemperatureSensor = new TemperatureSensor_TC1047(extruderTemperatureSensorPin);
extruderTemperatureControl.initialize(extruderTemperatureSensor, extenderOutput.createPinHandler(extruderHeaterPin));
bedTemperatureSensor = new TemperatureSensor_TC1047(bedTemperatureSensorPin);
bedTemperatureControl.initialize(bedTemperatureSensor, extenderOutput.createPinHandler(bedHeaterPin));
reprap.initialize(&reader, &extruderTemperatureControl, &bedTemperatureControl);
diButtonPin.initialize(buttonPin, true);
btn.initialize(&diButtonPin, false);
diRotorPinA.initialize(rotorPinA, true);
diRotorPinB.initialize(rotorPinB, true);
rotor.initialize(&diRotorPinA, &diRotorPinB);
attachInterrupt(0, UpdateRotor, CHANGE);
diLedPin.initialize(ledPin);
led.initialize(&diLedPin, states, size(states), true);
led.setState(btn.isAutoRepeatEnabled());
Serial_println("ok");
}
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(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
}
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;
}
}
}
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_println_c(USART_TypeDef *USARTx, char *s) {
Serial_println(USARTx, s);
}
void setup(void) {
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
}
