Skip to content
Permalink
master
Switch branches/tags
Go to file
 
 
Cannot retrieve contributors at this time
/*
* This file is designed to support FREERTOS functions in Espruino,
* a JavaScript interpreter for Microcontrollers designed by Gordon Williams
*
* Copyright (C) 2016 by Juergen Marsch
*
* This Source Code Form is subject to the terms of the Mozilla Publici
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* ----------------------------------------------------------------------------
* This file is designed to be parsed during the build process
*
* Task, queue and timer specific exposed components.
* ----------------------------------------------------------------------------
*/
#include "jsinteractive.h"
#include "jstimer.h"
#include "rom/uart.h"
#include "rtosutil.h"
#include "soc/timer_group_struct.h"
#include "driver/timer.h"
#include <stdio.h>
#include <string.h>
// implementation of simple queue oriented commands. see header file for more info.
void queues_init(){
int i;
for(i = 0; i < queueMax; i++){ RTOSqueues[i].name = NULL; RTOSqueues[i].handle = NULL;}
}
int queue_indexByName(char *queueName){
int i;
for(i = 0; i < queueMax; i++){
if(RTOSqueues[i].handle != 0){
if(strcmp(queueName,RTOSqueues[i].name) == 0){
return i;
}
}
}
return -1;
}
QueueHandle_t queue_handleByName(char *queueName){
int idx;
idx = queue_indexByName(queueName);
return RTOSqueues[idx].handle;
}
int queue_init(char *queueName,int length,int sizeOfEntry){
int i;
for(i = 0; i < queueMax; i++){
if(NULL == RTOSqueues[i].handle){
RTOSqueues[i].name = queueName;
RTOSqueues[i].handle = xQueueCreate(length,sizeOfEntry);
return i;
}
}
return -1;
}
void queue_list(){
int i;
for(i = 0; i < queueMax; i++){
if(RTOSqueues[i].name == NULL) return;
printf("queue %s : %d\n",RTOSqueues[i].name,RTOSqueues[i].handle);
}
}
char *queue_read(int idx){
char data;
if(xQueueReceive(RTOSqueues[idx].handle,&data,0)){
return data;
}
return NULL;
}
void queue_writeChar(int idx,char c){
if(!xQueueSend(RTOSqueues[idx].handle,&c,1)){
printf("SerialTaskOverflow\n");
}
}
// implementation of simple task oriented commands. see header file for more info.
void tasks_init(){
int i;
for(i = 0; i < taskMax; i++){ RTOStasks[i].name = NULL; RTOStasks[i].handle = NULL;}
}
int task_indexByName(char *taskName){
int i;
for(i = 0; i < taskMax; i++){
if(RTOStasks[i].handle != 0){
if(strcmp(taskName,RTOStasks[i].name) == 0){
return i;
}
}
}
return -1;
}
TaskHandle_t task_handleByName(char *taskName){
int idx;
idx = task_indexByName(taskName);
return RTOStasks[idx].handle;
}
int *task_getCurrentIndex(){
int i;TaskHandle_t handle;
handle = xTaskGetCurrentTaskHandle();
for(i = 0; i < taskMax; i++){
if(RTOStasks[i].handle == handle){
return i;
}
}
return NULL;
}
char *task_getCurrentName(){
int i;TaskHandle_t handle;
handle = xTaskGetCurrentTaskHandle();
for(i = 0; i < taskMax; i++){
if(RTOStasks[i].handle == handle){
return RTOStasks[i].name;
}
}
return NULL;
}
int task_init(TaskFunction_t taskCode, char *taskName,unsigned short stackDepth,UBaseType_t priority,BaseType_t coreId){
int i;
for(i = 0; i < taskMax; i++){
if(NULL == RTOStasks[i].handle){
RTOStasks[i].name = taskName;
xTaskCreatePinnedToCore(taskCode,taskName,stackDepth,NULL,priority,&RTOStasks[i].handle,coreId);
return i;
}
}
return -1;
}
void task_list(){
int i;
for(i = 0; i < taskMax;i++){
if(RTOStasks[i].name == NULL) return;
printf("task %s : %d\n",RTOStasks[i].name,RTOStasks[i].handle);
}
}
void task_Suspend(int idx){
vTaskSuspend(RTOStasks[idx].handle);
}
void task_Resume(int idx){
vTaskResume(RTOStasks[idx].handle);
}
void task_notify(int idx){
xTaskNotifyGive(RTOStasks[idx].handle);
}
void taskWaitNotify(){
ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
}
#define TIMER_INTR_SEL TIMER_INTR_LEVEL /*!< Timer level interrupt */
#define TIMER_GROUP TIMER_GROUP_0 /*!< Test on timer group 0 */
#define TIMER_DIVIDER 80 /*!< Hardware timer clock divider */
#define TIMER_SCALE (TIMER_BASE_CLK / TIMER_DIVIDER) /*!< used to calculate counter value */
#define TIMER_FINE_ADJ (1.4*(TIMER_BASE_CLK / TIMER_DIVIDER)/1000000) /*!< used to compensate alarm value */
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
void IRAM_ATTR espruino_isr(void *para){
int idx = (int) para;
if(idx == 0){
TIMERG0.hw_timer[TIMER_0].update = 1;
TIMERG0.int_clr_timers.t0 = 1;
}
else{
TIMERG0.hw_timer[TIMER_1].update = 1;
TIMERG0.int_clr_timers.t1 = 1;
}
jstUtilTimerInterruptHandler();
}
void IRAM_ATTR test_isr(void *para){
int idx = (int) para;
printf("x\n");
if(idx == 0){
TIMERG0.hw_timer[TIMER_0].update = 1;
TIMERG0.int_clr_timers.t0 = 1;
}
else{
TIMERG0.hw_timer[TIMER_1].update = 1;
TIMERG0.int_clr_timers.t1 = 1;
}
}
void timers_Init(){
int i;
for(i = 0; i < timerMax; i++){
ESP32Timers[i].name = NULL;
}
}
int timer_indexByName(char *timerName){
int i;
for(i = 0; i < timerMax; i++){
if(ESP32Timers[i].name == NULL) return -1;
if(strcmp(timerName,ESP32Timers[i].name) == 0){
return i;
}
}
return -1;
}
int timer_Init(char *timerName,int group,int index,int isr_idx){
int i;
for(i = 0; i < timerMax; i++){
if(ESP32Timers[i].name == NULL){
ESP32Timers[i].name = timerName;
ESP32Timers[i].group = group;
ESP32Timers[i].index = index;
timer_config_t config;
config.alarm_en = 1;
config.auto_reload = 1;
config.counter_dir = TIMER_COUNT_UP;
config.divider = TIMER_DIVIDER;
config.intr_type = TIMER_INTR_SEL;
config.counter_en = TIMER_PAUSE;
timer_init(group, index, &config);/*Configure timer*/
timer_pause(group, index);/*Stop timer counter*/
timer_set_counter_value(group, index, 0x00000000ULL);/*Load counter value */
timer_enable_intr(group, index);
if(isr_idx == 0){
ESP32Timers[i].taskToNotifyIdx = task_indexByName("TimerTask");
timer_isr_register(group, index, espruino_isr, (void*) i, ESP_INTR_FLAG_IRAM, NULL);
}
else{
timer_isr_register(group, index, test_isr, (void*) i, ESP_INTR_FLAG_IRAM, NULL);
}
return i;
}
}
return -1;
}
void timer_Start(int idx,uint64_t duration){
timer_enable_intr(ESP32Timers[idx].group, ESP32Timers[idx].index);
timer_set_alarm_value(ESP32Timers[idx].group, ESP32Timers[idx].index, duration - TIMER_FINE_ADJ);
TIMERG0.hw_timer[idx].config.alarm_en = 1;
timer_start(ESP32Timers[idx].group, ESP32Timers[idx].index);
}
void timer_Reschedule(int idx,uint64_t duration){
timer_set_alarm_value(ESP32Timers[idx].group, ESP32Timers[idx].index, duration - TIMER_FINE_ADJ);
TIMERG0.hw_timer[idx].config.alarm_en = 1;
}
void timer_List(){
int i;
for(i = 0; i < timerMax; i++){
if(ESP32Timers[i].name == NULL){printf("timer %d free\n",i);}
else {printf("timer %s : %d.%d\n",ESP32Timers[i].name,ESP32Timers[i].group,ESP32Timers[i].index);}
}
return;
}