Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Fork of OmniWheels by
equeue_mbed.cpp
00001 /* 00002 * Implementation for the mbed library 00003 * https://github.com/mbedmicro/mbed 00004 * 00005 * Copyright (c) 2016 Christopher Haster 00006 * 00007 * Licensed under the Apache License, Version 2.0 (the "License"); 00008 * you may not use this file except in compliance with the License. 00009 * You may obtain a copy of the License at 00010 * 00011 * http://www.apache.org/licenses/LICENSE-2.0 00012 * 00013 * Unless required by applicable law or agreed to in writing, software 00014 * distributed under the License is distributed on an "AS IS" BASIS, 00015 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00016 * See the License for the specific language governing permissions and 00017 * limitations under the License. 00018 */ 00019 #include "equeue/equeue_platform.h" 00020 00021 #if defined(EQUEUE_PLATFORM_MBED) 00022 00023 #include <stdbool.h> 00024 #include "mbed.h" 00025 00026 #if MBED_CONF_EVENTS_USE_LOWPOWER_TIMER_TICKER 00027 #define ALIAS_TIMER LowPowerTimer 00028 #define ALIAS_TICKER LowPowerTicker 00029 #define ALIAS_TIMEOUT LowPowerTimeout 00030 #else 00031 #define ALIAS_TIMER Timer 00032 #define ALIAS_TICKER Ticker 00033 #define ALIAS_TIMEOUT Timeout 00034 #endif 00035 00036 // Ticker operations 00037 static bool equeue_tick_inited = false; 00038 static volatile unsigned equeue_minutes = 0; 00039 static unsigned equeue_timer[ 00040 (sizeof(ALIAS_TIMER)+sizeof(unsigned)-1)/sizeof(unsigned)]; 00041 static unsigned equeue_ticker[ 00042 (sizeof(ALIAS_TICKER)+sizeof(unsigned)-1)/sizeof(unsigned)]; 00043 00044 static void equeue_tick_update() { 00045 equeue_minutes += reinterpret_cast<ALIAS_TIMER*>(equeue_timer)->read_ms(); 00046 reinterpret_cast<ALIAS_TIMER*>(equeue_timer)->reset(); 00047 } 00048 00049 static void equeue_tick_init() { 00050 MBED_STATIC_ASSERT(sizeof(equeue_timer) >= sizeof(ALIAS_TIMER), 00051 "The equeue_timer buffer must fit the class Timer"); 00052 MBED_STATIC_ASSERT(sizeof(equeue_ticker) >= sizeof(ALIAS_TICKER), 00053 "The equeue_ticker buffer must fit the class Ticker"); 00054 ALIAS_TIMER *timer = new (equeue_timer) ALIAS_TIMER; 00055 ALIAS_TICKER *ticker = new (equeue_ticker) ALIAS_TICKER; 00056 00057 equeue_minutes = 0; 00058 timer->start(); 00059 ticker->attach_us(equeue_tick_update, 1000 << 16); 00060 00061 equeue_tick_inited = true; 00062 } 00063 00064 unsigned equeue_tick() { 00065 if (!equeue_tick_inited) { 00066 equeue_tick_init(); 00067 } 00068 00069 unsigned minutes; 00070 unsigned ms; 00071 00072 do { 00073 minutes = equeue_minutes; 00074 ms = reinterpret_cast<ALIAS_TIMER*>(equeue_timer)->read_ms(); 00075 } while (minutes != equeue_minutes); 00076 00077 return minutes + ms; 00078 } 00079 00080 00081 // Mutex operations 00082 int equeue_mutex_create(equeue_mutex_t *m) { return 0; } 00083 void equeue_mutex_destroy(equeue_mutex_t *m) { } 00084 00085 void equeue_mutex_lock(equeue_mutex_t *m) { 00086 core_util_critical_section_enter(); 00087 } 00088 00089 void equeue_mutex_unlock(equeue_mutex_t *m) { 00090 core_util_critical_section_exit(); 00091 } 00092 00093 00094 // Semaphore operations 00095 #ifdef MBED_CONF_RTOS_PRESENT 00096 00097 int equeue_sema_create(equeue_sema_t *s) { 00098 osEventFlagsAttr_t attr; 00099 memset(&attr, 0, sizeof(attr)); 00100 attr.cb_mem = &s->mem; 00101 attr.cb_size = sizeof(s->mem); 00102 00103 s->id = osEventFlagsNew(&attr); 00104 return !s->id ? -1 : 0; 00105 } 00106 00107 void equeue_sema_destroy(equeue_sema_t *s) { 00108 osEventFlagsDelete(s->id); 00109 } 00110 00111 void equeue_sema_signal(equeue_sema_t *s) { 00112 osEventFlagsSet(s->id, 1); 00113 } 00114 00115 bool equeue_sema_wait(equeue_sema_t *s, int ms) { 00116 if (ms < 0) { 00117 ms = osWaitForever; 00118 } 00119 00120 return (osEventFlagsWait(s->id, 1, osFlagsWaitAny, ms) == 1); 00121 } 00122 00123 #else 00124 00125 // Semaphore operations 00126 int equeue_sema_create(equeue_sema_t *s) { 00127 *s = false; 00128 return 0; 00129 } 00130 00131 void equeue_sema_destroy(equeue_sema_t *s) { 00132 } 00133 00134 void equeue_sema_signal(equeue_sema_t *s) { 00135 *s = 1; 00136 } 00137 00138 static void equeue_sema_timeout(equeue_sema_t *s) { 00139 *s = -1; 00140 } 00141 00142 bool equeue_sema_wait(equeue_sema_t *s, int ms) { 00143 int signal = 0; 00144 ALIAS_TIMEOUT timeout; 00145 if (ms == 0) { 00146 return false; 00147 } else if (ms > 0) { 00148 timeout.attach_us(callback(equeue_sema_timeout, s), ms*1000); 00149 } 00150 00151 core_util_critical_section_enter(); 00152 while (!*s) { 00153 sleep(); 00154 core_util_critical_section_exit(); 00155 core_util_critical_section_enter(); 00156 } 00157 00158 signal = *s; 00159 *s = false; 00160 core_util_critical_section_exit(); 00161 00162 return (signal > 0); 00163 } 00164 00165 #endif 00166 00167 #endif
Generated on Fri Jul 22 2022 04:53:47 by
