/******************************************************************************
* FunctionName : pwm_init
* Description : pwm gpio, params and timer initialization
* Parameters : uint16 freq : pwm freq param
* uint16 *duty : each channel's duty
* Returns : NONE
*******************************************************************************/
void ICACHE_FLASH_ATTR
pwm_init(uint16 freq, uint16 *duty)
{
uint8 i;
RTC_REG_WRITE(FRC1_CTRL_ADDRESS, //FRC2_AUTO_RELOAD|
DIVDED_BY_16
| FRC1_ENABLE_TIMER
| TM_EDGE_INT);
RTC_REG_WRITE(FRC1_LOAD_ADDRESS, 0);
// PIN_FUNC_SELECT(PWM_0_OUT_IO_MUX, PWM_0_OUT_IO_FUNC);
// PIN_FUNC_SELECT(PWM_1_OUT_IO_MUX, PWM_1_OUT_IO_FUNC);
// PIN_FUNC_SELECT(PWM_2_OUT_IO_MUX, PWM_2_OUT_IO_FUNC);
// GPIO_OUTPUT_SET(GPIO_ID_PIN(PWM_0_OUT_IO_NUM), 0);
// GPIO_OUTPUT_SET(GPIO_ID_PIN(PWM_1_OUT_IO_NUM), 0);
// GPIO_OUTPUT_SET(GPIO_ID_PIN(PWM_2_OUT_IO_NUM), 0);
for (i = 0; i < PWM_CHANNEL; i++) {
// pwm_gpio |= (1 << pwm_out_io_num[i]);
pwm_gpio = 0;
pwm.duty[i] = 0;
}
pwm_set_freq(500, 0);
// pwm_set_freq_duty(freq, duty);
pwm_start();
ETS_FRC_TIMER1_INTR_ATTACH(pwm_tim1_intr_handler, NULL);
TM1_EDGE_INT_ENABLE();
ETS_FRC1_INTR_ENABLE();
}
void ICACHE_FLASH_ATTR ir_remote_init(uint16 gpio_pin_num, bool invert_logic_level)
{
_gpio_pin_num = gpio_pin_num;
_logic_low = invert_logic_level;
_logic_high = !_logic_low;
_pwm_lvl = _logic_low;
GPIO_ConfigTypeDef gpioCfg;
gpioCfg.GPIO_Pin = BIT(_gpio_pin_num);
gpioCfg.GPIO_Mode = GPIO_Mode_Output;
gpioCfg.GPIO_Pullup = GPIO_PullUp_DIS;
gpio_config(&gpioCfg);
GPIO_OUTPUT_SET(_gpio_pin_num, _logic_low);
portENTER_CRITICAL();
_xt_isr_attach(ETS_FRC_TIMER1_INUM, pwm_tim1_intr_handler);
TM1_EDGE_INT_ENABLE();
_xt_isr_unmask((1 << ETS_FRC_TIMER1_INUM));
CLEAR_PERI_REG_MASK(FRC1_INT_ADDRESS, FRC1_INT_CLR_MASK);
WRITE_PERI_REG(FRC1_CTRL_ADDRESS, CLOCK_DIV_256 | FRC1_ENABLE_TIMER | TM_EDGE_INT);
WRITE_PERI_REG(FRC1_LOAD_ADDRESS, 0);
portEXIT_CRITICAL();
}
void ICACHE_FLASH_ATTR ContinueHPATimer()
{
TM1_EDGE_INT_ENABLE();
ETS_FRC1_INTR_ENABLE();
system_timer_reinit();
hs_adc_start();
}
void hw_timer_init(uint8 req)
{
if (req == 1) {
RTC_REG_WRITE(FRC1_CTRL_ADDRESS,
FRC1_AUTO_LOAD | DIVDED_BY_16 | FRC1_ENABLE_TIMER | TM_EDGE_INT);
} else {
RTC_REG_WRITE(FRC1_CTRL_ADDRESS,
DIVDED_BY_16 | FRC1_ENABLE_TIMER | TM_EDGE_INT);
}
_xt_isr_attach(ETS_FRC_TIMER1_INUM, hw_timer_isr_cb, NULL);
TM1_EDGE_INT_ENABLE();
_xt_isr_unmask(1 << ETS_FRC_TIMER1_INUM);
}
/******************************************************************************
* FunctionName : hw_timer_init
* Description : initilize the hardware isr timer
* Parameters :
FRC1_TIMER_SOURCE_TYPE source_type:
FRC1_SOURCE, timer use frc1 isr as isr source.
NMI_SOURCE, timer use nmi isr as isr source.
u8 req:
0, not autoload,
1, autoload mode,
* Returns : NONE
*******************************************************************************/
void ICACHE_FLASH_ATTR hw_timer_init(FRC1_TIMER_SOURCE_TYPE source_type, u8 req)
{
if (req == 1) {
RTC_REG_WRITE(FRC1_CTRL_ADDRESS,
FRC1_AUTO_LOAD | DIVDED_BY_16 | FRC1_ENABLE_TIMER | TM_EDGE_INT);
} else {
RTC_REG_WRITE(FRC1_CTRL_ADDRESS,
DIVDED_BY_16 | FRC1_ENABLE_TIMER | TM_EDGE_INT);
}
if (source_type == NMI_SOURCE) {
ETS_FRC_TIMER1_NMI_INTR_ATTACH(hw_timer_isr_cb);
} else {
ETS_FRC_TIMER1_INTR_ATTACH(hw_timer_isr_cb, NULL);
}
TM1_EDGE_INT_ENABLE();
ETS_FRC1_INTR_ENABLE();
}
void ICACHE_FLASH_ATTR StartHPATimer()
{
RTC_REG_WRITE(FRC1_CTRL_ADDRESS, FRC1_AUTO_RELOAD|
DIVDED_BY_16 | //5MHz main clock.
FRC1_ENABLE_TIMER |
TM_EDGE_INT );
RTC_REG_WRITE(FRC1_LOAD_ADDRESS, 5000000/DFREQ);
RTC_REG_WRITE(FRC1_COUNT_ADDRESS, 5000000/DFREQ);
//pwm_set_freq_duty(freq, duty);
//pwm_start();
// RTC_REG_WRITE(FRC1_LOAD_ADDRESS, local_single[0].h_time);
ETS_FRC_TIMER1_INTR_ATTACH(timerhandle, NULL);
TM1_EDGE_INT_ENABLE();
ETS_FRC1_INTR_ENABLE();
system_timer_reinit();
hs_adc_start();
}
bool Hardware_Timer::start(bool repeating/* = true*/)
{
this->repeating = repeating;
stop();
if(interval == 0 || !callback)
return started;
if (this->repeating == 1) {
RTC_REG_WRITE(FRC1_CTRL_ADDRESS,
FRC1_AUTO_LOAD | DIVDED_BY_16 | FRC1_ENABLE_TIMER | TM_EDGE_INT);
} else {
RTC_REG_WRITE(FRC1_CTRL_ADDRESS,
DIVDED_BY_16 | FRC1_ENABLE_TIMER | TM_EDGE_INT);
}
TM1_EDGE_INT_ENABLE();
ETS_FRC1_INTR_ENABLE();
started = true;
RTC_REG_WRITE(FRC1_LOAD_ADDRESS, US_TO_RTC_TIMER_TICKS(interval));
return started;
}
// initialize the custom stuff that goes beyond esp-link
void user_init()
{
// Initialize the GPIO subsystem.
gpio_init();
/* ====================================== */
/* UART */
/* ====================================== */
// Initialize UART0 and UART1
/* NOTE: UART1 and I2S share same GPIO. Cannot use simultaneously. */
uart_init( BIT_RATE_115200, BIT_RATE_115200 );
// uart0_sendStr( "\nUART0 - USED TO PROGRAM THE MODULE\n" );
os_printf("\n===================\nUART1 - DEBUG OUPUT\n===================\n");
/* NOTE: PWM CANNOT BE USED SIMULTANEOUSLY WITH HW TIMER */
#if 0
/* ====================================== */
/* PWM */
/* ====================================== */
uint32 pwm_period = 1000;
uint32 pwm_duty[PWM_CHANNEL] = {0};
uint32 io_info[][3] = { {PWM_0_OUT_IO_MUX,PWM_0_OUT_IO_FUNC,PWM_0_OUT_IO_NUM},
{PWM_1_OUT_IO_MUX,PWM_1_OUT_IO_FUNC,PWM_1_OUT_IO_NUM},
};
/* PIN FUNCTION INIT FOR PWM OUTPUT */
pwm_init(pwm_period, pwm_duty, PWM_CHANNEL, io_info);
/* set pwm_duty cycle */
pwm_set_duty (14185, 0);
pwm_set_duty (22222, 1); // todo: explain why 22222 is the highest possible value
/* start PWM */
pwm_start(); // NOTE: PWM causes spikes in other GPIOs
#endif
/* ====================================== */
/* GPIO INTERRPUT */
/* ====================================== */
/* Set GPIO12 in GPIO mode */
PIN_FUNC_SELECT( PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO12 );
/* Set GPIO12 as input */
GPIO_DIS_OUTPUT( GPIO_ID_PIN(12) );
/* Disable all GPIO interrupts */
ETS_GPIO_INTR_DISABLE();
/* Set a GPIO callback function */
ETS_GPIO_INTR_ATTACH( gpioCallback, NULL );
/* Configure the type of edge */
gpio_pin_intr_state_set( GPIO_ID_PIN(12), GPIO_PIN_INTR_ANYEDGE );
ETS_GPIO_INTR_ENABLE();
/* ====================================== */
/* SOFTWARE TIMER */
/* ====================================== */
// Set GPIO0 to output mode
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0);
//Set GPIO0 low
gpio_output_set(0, RELAY_PIN, RELAY_PIN, 0);
/* disarm timer */
os_timer_disarm((ETSTimer*)&some_timer);
/* set callback */
os_timer_setfn((ETSTimer*)&some_timer, (os_timer_func_t *) softwareTimerCallback, NULL);
/* arm the timer -> os_timer_arm(<pointer>, <period in ms>, <fire periodically>) */
os_timer_arm((ETSTimer*)&some_timer, 10, 1);
/* ====================================== */
/* OS TASK */
/* ====================================== */
/* setup OS task */
// system_os_task(user_procTask, user_procTaskPrio, user_procTaskQueue, user_procTaskQueueLen);
/* send a message to OS task (fire task) */
// system_os_post(user_procTaskPrio, 0, 0 );
/* ====================================== */
/* HARDWARE TIMER */
/* ====================================== */
/* The hardware timer is used to indicate when a complete IR message frame should have
* arrived in order to process the received data and calculate the IR command.
*
* It is configured in "one-shot" mode. It is started when the beginning of an
* IR message frame is detected and stopped after the complete message frame has been read.
* This means that the duration of the HW timer should be longer than the duration of
* the longest message frame. In the NEC IR tranmission protocol all message frames have
* a duration of approximately 67.5ms.
*/
/* load the HW TIMER */
uint32 ticks = usToTicks(70000); // 70ms
RTC_REG_WRITE(FRC1_LOAD_ADDRESS, ticks);
/* register callback function */
ETS_FRC_TIMER1_INTR_ATTACH( hwTimerCallback, NULL );
/* enable interrupts */
TM1_EDGE_INT_ENABLE();
ETS_FRC1_INTR_ENABLE();
/* don't start timer yet */
/* the timer is started inside the GPIO INT callback */
/* ====================================== */
/* UDP SERVER */
/* ====================================== */
/* usage: echo <data> | nc -wl -u <ip address> <port>
* example: echo "foo" | nc -w1 -u 192.168.1.187 7777 */
/* allocate space for server */
pUdpServer = (struct espconn *) os_zalloc(sizeof(struct espconn));
/* clear allocated memory */
ets_memset(pUdpServer, 0, sizeof(struct espconn));
/* create the server */
espconn_create(pUdpServer);
/* set the type of server */
pUdpServer->type = ESPCONN_UDP;
/* allocate memory for UDP settings */
pUdpServer->proto.udp = (esp_udp *) os_zalloc(sizeof(esp_udp));
/* set the port that the server will be listening to */
pUdpServer->proto.udp->local_port = 7777;
/* register the callback */
espconn_regist_recvcb(pUdpServer, udpServerRxCb);
/* start listening */
if (espconn_create(pUdpServer))
{
while (1) { os_printf("Error creating a UDP server\n"); }
}
/* ====================================== */
/* WIFI */
/* ====================================== */
wifi_set_opmode(STATION_MODE);
wifi_station_get_config_default(&stconf);
// os_strncpy((char*) stconf.ssid, "TP-LINK_2.4GHz_FC2E51", 32);
// os_strncpy((char*) stconf.password, "tonytony", 64);
os_strncpy((char*) stconf.ssid, "WLAN-PUB", 32);
os_strncpy((char*) stconf.password, "", 64);
// os_strncpy((char*) stconf.ssid, "MAD air", 32);
// os_strncpy((char*) stconf.password, "glioninlog", 64);
stconf.bssid_set = 0;
wifi_station_set_config(&stconf);
// /* ====================================== */
// /* WS2812 LED STRIP */
// /* ====================================== */
//
// /* NOTE: UART1 and I2S share same GPIO. Cannot use simultaneously. */
// ws2812_init();
//
// /* G R B */
// uint8_t ledout[] = {
// 0xff, 0x00, 0x00, //4th
//// 0xff, 0x00, 0x00, //3rd
//// 0x00, 0xff, 0x00, //2nd
//// 0x00, 0x00, 0xff, //1st
// };
//
//#if 0
// os_printf("\r\nB R G: %x %x %x\r\n", ledout[0], ledout[1],ledout[2]);
//#endif
//
// ws2812_push( ledout, sizeof( ledout ) );
/* ====================================== */
/* TCP CONNECTION */
/* ====================================== */
/* allocate space for server */
pTcpConn = (struct espconn *) os_zalloc(sizeof(struct espconn));
/* clear allocated memory */
ets_memset(pTcpConn, 0, sizeof(struct espconn));
/* set the type of connection */
pTcpConn->type = ESPCONN_TCP;
/* set state to NONE */
pTcpConn->state = ESPCONN_NONE;
/* allocate memory for TCP settings */
pTcpConn->proto.tcp = (esp_tcp *) os_zalloc(sizeof(esp_tcp));
/* set the port that the connection will be listening to */
pTcpConn->proto.tcp->local_port = espconn_port();
/* set the remote port and IP address */
pTcpConn->proto.tcp->remote_port = 80;
os_memcpy(pTcpConn->proto.tcp->remote_ip, server_ip_address, sizeof(server_ip_address));
/* register callbacks */
espconn_regist_connectcb(pTcpConn, tcpConnCb);
espconn_regist_reconcb(pTcpConn, tcpReconnCb);
/* disarm timer */
os_timer_disarm((ETSTimer*)&wifi_setup_timer);
/* set callback */
os_timer_setfn((ETSTimer*)&wifi_setup_timer, (os_timer_func_t *) wifiConnectTimerCb, NULL);
/* arm the timer -> os_timer_arm(<pointer>, <period in ms>, <fire periodically>) */
os_timer_arm((ETSTimer*)&wifi_setup_timer, 5000, 1);
return;
}