main-header.h

#ifndef MAIN_HEADER_H
#define MAIN_HEADER_H 1
 
#define REMAP_SPI1 1
 
#define SPI_DEVICE_CC1101 1
 
#define DELAY_DEFAULT 0
#define DELAY_SERIAL 1
#define DELAY_ESP2SERIAL 2
#define DELAY_WRITESPI 3
#define DELAY_TI1101 4
 
#define MAIN_MCULIBHANDLE 1
 
#define USART_CONSOLE 1
#define USART_ESP8266 2
 
#include <stdint.h>
#include <stdarg.h>
 
 
#include "platform-header.h"
#include "ascii_parser.h"
#include "ringbuffer.h"
#include "packetbuffer.h"
#include "fatal-error.h"
#include "command-parser.h"
#include "config.h"
#include "espressif/esp8266.h"
#include "espressif/esp8266_cloud.h"
#include "strings-common.h"
#include "addressing.h"
#include "command-handler.h"
#include "routing.h"
#include "routing_functions.h"
#include "crypt.h"
#include "decode_esp_packet.h"
#include "build_version.h"
#include "onewire.h"
#include "checksums.h"
#include "multiram.h"
#include "logging.h"
#include "mculibrary.h"
#include "loader-api.h"
#include "reboot.h"
#include "queue.h"
 
 
long get_systickctr();
long systick_diff(long timestamp);
void Delay(uint32_t nTime);
void TimingDelay_Decrement(void);
 
int app_main(void);
void process_command(struct command *com);
int open_serial(int num, int baudrate);
void set_baudrate(int num, int baudrate);
int write_serial_char(int handle, char c);
int write_serial_string(int handle, const char *txt);
int write_serial_line(int handle, const char *txt);
void serial_fail_port(int port);
void serial_ok_port(int port);
 
void restart_app(void)   __attribute__((no_instrument_function));
 
void usart_init();
void reset_delay_counter(int n);
int get_delay_counter(int n);
void noop();
 
int startsWith(const char *c1, const char *c2);
 
void gpio_init(byte remap);
void gpio_configure_pins(byte remap);
void gpioa_on(int pin);
void gpioa_off(int pin);
void gpiob_on(int pin);
void gpiob_off(int pin);
void gpioc_on(int pin);
void gpioc_off(int pin);
//void gpio_enable_irq_on_pa0();
//void gpio_disable_irq_on_pa0();
void gpio_enable_irq_on_pb15();
void gpio_disable_irq_on_pb15();
 
byte is_gpiob_irq_triggered(int num);
void clear_gpiob_irq(int num);
 
byte get_status_of_gpio_b(int num);
void system_reset();
 
 
 
 
// flash abstraction layer
/*
 * int flash_write(const void *buf, const int size);
 * int flash_read(void *buf, const int size);
 * int flash_calc_crc(const void *buf, const int size);
 */
// return number of seconds since last boot
long get_seconds_since_boot() __attribute__((no_instrument_function));
 
void set_relay(int relay, int state, int timeout);
void relay_counter();
 
void mainentry(void);
 
 
 
void UserSysTick_Handler(void);
 
int app_main(void);
// set to 1 to avoid printing to console
void setquietflag(byte x);
// set to 1 to printf to usb, otherwise will print to serialport
void print_to_usb(int x);
// print to somewhere sensible (serial/console/usb or so)
void print(const char *txt);
 
 
// return address where we store flash config
void *get_flash_config_addr();
void *get_flash_user_config_addr();
 
// this will send a command via a given device. The way to address the device is platform independent, thus implementations for different platforms implement this in different ways.
// returns 0 on success
int send_buf_via_device(int dev, const byte *buf, int size);
// get and consume next byte from console. if >255: no byte available
uint16_t console_get_byte();
int console_get_line(char *outbuf, int bufsize);
// stick a byte into the console buffer as if it were received from console/usb
void console_add_byte(uint8_t b);
 
// clear the console buffer;
void console_reset();
 
void *sc_realloc(void *ptr, size_t size);
void sc_free(void *ptr);
 
void process_terminal_input();
void print_program_status();
void print_boot_info();
#endif