SDK Development
mbed SDK library sources
Fork of
mbed-src
by 
mbed official
Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.
If you are looking for a stable and tested release, please import one of the official mbed library releases:
Import librarymbed
The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.
Last commit 20 Feb 2019 by mbed official
Revision 51:7838415c99e7, committed 2013-12-02
- Comitter:
- mbed_official
- Date:
- Mon Dec 02 10:00:04 2013 +0000
- Parent:
- 50:b08ceb75017d
- Child:
- 52:a51c77007319
- Commit message:
- Synchronized with git revision 6aaa1345164ad42bf681b857dc768b1b65a07595
Full URL: https://github.com/mbedmicro/mbed/commit/6aaa1345164ad42bf681b857dc768b1b65a07595/
Added (deep)sleep to KL25Z
Changed in this revision
--- a/targets/hal/TARGET_Freescale/TARGET_KL25Z/device.h Tue Nov 26 15:30:05 2013 +0000 +++ b/targets/hal/TARGET_Freescale/TARGET_KL25Z/device.h Mon Dec 02 10:00:04 2013 +0000 @@ -45,7 +45,7 @@ #define DEVICE_LOCALFILESYSTEM 0 #define DEVICE_ID_LENGTH 24 -#define DEVICE_SLEEP 0 +#define DEVICE_SLEEP 1 #define DEVICE_DEBUG_AWARENESS 0
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/targets/hal/TARGET_Freescale/TARGET_KL25Z/sleep.c Mon Dec 02 10:00:04 2013 +0000
@@ -0,0 +1,51 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2006-2013 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "sleep_api.h"
+#include "cmsis.h"
+
+//Normal wait mode
+void sleep(void)
+{
+ SMC->PMPROT = SMC_PMPROT_AVLLS_MASK | SMC_PMPROT_ALLS_MASK | SMC_PMPROT_AVLP_MASK;
+
+ //Normal sleep mode for ARM core:
+ SCB->SCR = 0;
+ __WFI();
+}
+
+//Very low-power stop mode
+void deepsleep(void)
+{
+ //Check if PLL/FLL is enabled:
+ uint32_t PLL_FLL_en = (MCG->C1 & MCG_C1_CLKS_MASK) == MCG_C1_CLKS(0);
+
+ SMC->PMPROT = SMC_PMPROT_AVLLS_MASK | SMC_PMPROT_ALLS_MASK | SMC_PMPROT_AVLP_MASK;
+ SMC->PMCTRL = SMC_PMCTRL_STOPM(2);
+
+ //Deep sleep for ARM core:
+ SCB->SCR = 1<<SCB_SCR_SLEEPDEEP_Pos;
+
+ __WFI();
+
+ //Switch back to PLL as clock source if needed
+ //The interrupt that woke up the device will run at reduced speed
+ if (PLL_FLL_en) {
+ if (MCG->C6 & (1<<MCG_C6_PLLS_SHIFT) != 0) /* If PLL */
+ while((MCG->S & MCG_S_LOCK0_MASK) == 0x00U); /* Wait until locked */
+ MCG->C1 &= ~MCG_C1_CLKS_MASK;
+ }
+
+}
--- a/targets/hal/TARGET_NXP/TARGET_LPC11UXX/serial_api.c Tue Nov 26 15:30:05 2013 +0000
+++ b/targets/hal/TARGET_NXP/TARGET_LPC11UXX/serial_api.c Mon Dec 02 10:00:04 2013 +0000
@@ -124,22 +124,47 @@
uint16_t dlv;
uint8_t mv, dav;
if ((PCLK % (16 * baudrate)) != 0) { // Checking for zero remainder
- float err_best = (float) baudrate;
- uint16_t dlmax = DL;
- for ( dlv = (dlmax/2); (dlv <= dlmax) && !hit; dlv++) {
- for ( mv = 1; mv <= 15; mv++) {
- for ( dav = 1; dav < mv; dav++) {
- float ratio = 1.0f + ((float) dav / (float) mv);
- float calcbaud = (float)PCLK / (16.0f * (float) dlv * ratio);
- float err = fabs(((float) baudrate - calcbaud) / (float) baudrate);
- if (err < err_best) {
- DL = dlv;
- DivAddVal = dav;
- MulVal = mv;
- err_best = err;
- if (err < 0.001f) {
- hit = 1;
- }
+ int err_best = baudrate, b;
+ for (mv = 1; mv < 16 && !hit; mv++)
+ {
+ for (dav = 0; dav < mv; dav++)
+ {
+ // baudrate = PCLK / (16 * dlv * (1 + (DivAdd / Mul))
+ // solving for dlv, we get dlv = mul * PCLK / (16 * baudrate * (divadd + mul))
+ // mul has 4 bits, PCLK has 27 so we have 1 bit headroom which can be used for rounding
+ // for many values of mul and PCLK we have 2 or more bits of headroom which can be used to improve precision
+ // note: X / 32 doesn't round correctly. Instead, we use ((X / 16) + 1) / 2 for correct rounding
+
+ if ((mv * PCLK * 2) & 0x80000000) // 1 bit headroom
+ dlv = ((((2 * mv * PCLK) / (baudrate * (dav + mv))) / 16) + 1) / 2;
+ else // 2 bits headroom, use more precision
+ dlv = ((((4 * mv * PCLK) / (baudrate * (dav + mv))) / 32) + 1) / 2;
+
+ // datasheet says if DLL==DLM==0, then 1 is used instead since divide by zero is ungood
+ if (dlv == 0)
+ dlv = 1;
+
+ // datasheet says if dav > 0 then DL must be >= 2
+ if ((dav > 0) && (dlv < 2))
+ dlv = 2;
+
+ // integer rearrangement of the baudrate equation (with rounding)
+ b = ((PCLK * mv / (dlv * (dav + mv) * 8)) + 1) / 2;
+
+ // check to see how we went
+ b = abs(b - baudrate);
+ if (b < err_best)
+ {
+ err_best = b;
+
+ DL = dlv;
+ MulVal = mv;
+ DivAddVal = dav;
+
+ if (b == baudrate)
+ {
+ hit = 1;
+ break;
}
}
}
--- a/targets/hal/TARGET_NXP/TARGET_LPC11XX_11CXX/serial_api.c Tue Nov 26 15:30:05 2013 +0000
+++ b/targets/hal/TARGET_NXP/TARGET_LPC11XX_11CXX/serial_api.c Mon Dec 02 10:00:04 2013 +0000
@@ -121,22 +121,47 @@
uint16_t dlv;
uint8_t mv, dav;
if ((PCLK % (16 * baudrate)) != 0) { // Checking for zero remainder
- float err_best = (float) baudrate;
- uint16_t dlmax = DL;
- for ( dlv = (dlmax/2); (dlv <= dlmax) && !hit; dlv++) {
- for ( mv = 1; mv <= 15; mv++) {
- for ( dav = 1; dav < mv; dav++) {
- float ratio = 1.0f + ((float) dav / (float) mv);
- float calcbaud = (float)PCLK / (16.0f * (float) dlv * ratio);
- float err = fabs(((float) baudrate - calcbaud) / (float) baudrate);
- if (err < err_best) {
- DL = dlv;
- DivAddVal = dav;
- MulVal = mv;
- err_best = err;
- if (err < 0.001f) {
- hit = 1;
- }
+ int err_best = baudrate, b;
+ for (mv = 1; mv < 16 && !hit; mv++)
+ {
+ for (dav = 0; dav < mv; dav++)
+ {
+ // baudrate = PCLK / (16 * dlv * (1 + (DivAdd / Mul))
+ // solving for dlv, we get dlv = mul * PCLK / (16 * baudrate * (divadd + mul))
+ // mul has 4 bits, PCLK has 27 so we have 1 bit headroom which can be used for rounding
+ // for many values of mul and PCLK we have 2 or more bits of headroom which can be used to improve precision
+ // note: X / 32 doesn't round correctly. Instead, we use ((X / 16) + 1) / 2 for correct rounding
+
+ if ((mv * PCLK * 2) & 0x80000000) // 1 bit headroom
+ dlv = ((((2 * mv * PCLK) / (baudrate * (dav + mv))) / 16) + 1) / 2;
+ else // 2 bits headroom, use more precision
+ dlv = ((((4 * mv * PCLK) / (baudrate * (dav + mv))) / 32) + 1) / 2;
+
+ // datasheet says if DLL==DLM==0, then 1 is used instead since divide by zero is ungood
+ if (dlv == 0)
+ dlv = 1;
+
+ // datasheet says if dav > 0 then DL must be >= 2
+ if ((dav > 0) && (dlv < 2))
+ dlv = 2;
+
+ // integer rearrangement of the baudrate equation (with rounding)
+ b = ((PCLK * mv / (dlv * (dav + mv) * 8)) + 1) / 2;
+
+ // check to see how we went
+ b = abs(b - baudrate);
+ if (b < err_best)
+ {
+ err_best = b;
+
+ DL = dlv;
+ MulVal = mv;
+ DivAddVal = dav;
+
+ if (b == baudrate)
+ {
+ hit = 1;
+ break;
}
}
}
--- a/targets/hal/TARGET_NXP/TARGET_LPC13XX/serial_api.c Tue Nov 26 15:30:05 2013 +0000
+++ b/targets/hal/TARGET_NXP/TARGET_LPC13XX/serial_api.c Mon Dec 02 10:00:04 2013 +0000
@@ -124,22 +124,47 @@
uint16_t dlv;
uint8_t mv, dav;
if ((PCLK % (16 * baudrate)) != 0) { // Checking for zero remainder
- float err_best = (float) baudrate;
- uint16_t dlmax = DL;
- for ( dlv = (dlmax/2); (dlv <= dlmax) && !hit; dlv++) {
- for ( mv = 1; mv <= 15; mv++) {
- for ( dav = 1; dav < mv; dav++) {
- float ratio = 1.0f + ((float) dav / (float) mv);
- float calcbaud = (float)PCLK / (16.0f * (float) dlv * ratio);
- float err = fabs(((float) baudrate - calcbaud) / (float) baudrate);
- if (err < err_best) {
- DL = dlv;
- DivAddVal = dav;
- MulVal = mv;
- err_best = err;
- if (err < 0.001f) {
- hit = 1;
- }
+ int err_best = baudrate, b;
+ for (mv = 1; mv < 16 && !hit; mv++)
+ {
+ for (dav = 0; dav < mv; dav++)
+ {
+ // baudrate = PCLK / (16 * dlv * (1 + (DivAdd / Mul))
+ // solving for dlv, we get dlv = mul * PCLK / (16 * baudrate * (divadd + mul))
+ // mul has 4 bits, PCLK has 27 so we have 1 bit headroom which can be used for rounding
+ // for many values of mul and PCLK we have 2 or more bits of headroom which can be used to improve precision
+ // note: X / 32 doesn't round correctly. Instead, we use ((X / 16) + 1) / 2 for correct rounding
+
+ if ((mv * PCLK * 2) & 0x80000000) // 1 bit headroom
+ dlv = ((((2 * mv * PCLK) / (baudrate * (dav + mv))) / 16) + 1) / 2;
+ else // 2 bits headroom, use more precision
+ dlv = ((((4 * mv * PCLK) / (baudrate * (dav + mv))) / 32) + 1) / 2;
+
+ // datasheet says if DLL==DLM==0, then 1 is used instead since divide by zero is ungood
+ if (dlv == 0)
+ dlv = 1;
+
+ // datasheet says if dav > 0 then DL must be >= 2
+ if ((dav > 0) && (dlv < 2))
+ dlv = 2;
+
+ // integer rearrangement of the baudrate equation (with rounding)
+ b = ((PCLK * mv / (dlv * (dav + mv) * 8)) + 1) / 2;
+
+ // check to see how we went
+ b = abs(b - baudrate);
+ if (b < err_best)
+ {
+ err_best = b;
+
+ DL = dlv;
+ MulVal = mv;
+ DivAddVal = dav;
+
+ if (b == baudrate)
+ {
+ hit = 1;
+ break;
}
}
}
--- a/targets/hal/TARGET_NXP/TARGET_LPC176X/serial_api.c Tue Nov 26 15:30:05 2013 +0000
+++ b/targets/hal/TARGET_NXP/TARGET_LPC176X/serial_api.c Mon Dec 02 10:00:04 2013 +0000
@@ -157,22 +157,47 @@
uint16_t dlv;
uint8_t mv, dav;
if ((PCLK % (16 * baudrate)) != 0) { // Checking for zero remainder
- float err_best = (float) baudrate;
- uint16_t dlmax = DL;
- for ( dlv = (dlmax/2); (dlv <= dlmax) && !hit; dlv++) {
- for ( mv = 1; mv <= 15; mv++) {
- for ( dav = 1; dav < mv; dav++) {
- float ratio = 1.0f + ((float) dav / (float) mv);
- float calcbaud = (float)PCLK / (16.0f * (float) dlv * ratio);
- float err = fabs(((float) baudrate - calcbaud) / (float) baudrate);
- if (err < err_best) {
- DL = dlv;
- DivAddVal = dav;
- MulVal = mv;
- err_best = err;
- if (err < 0.001f) {
- hit = 1;
- }
+ int err_best = baudrate, b;
+ for (mv = 1; mv < 16 && !hit; mv++)
+ {
+ for (dav = 0; dav < mv; dav++)
+ {
+ // baudrate = PCLK / (16 * dlv * (1 + (DivAdd / Mul))
+ // solving for dlv, we get dlv = mul * PCLK / (16 * baudrate * (divadd + mul))
+ // mul has 4 bits, PCLK has 27 so we have 1 bit headroom which can be used for rounding
+ // for many values of mul and PCLK we have 2 or more bits of headroom which can be used to improve precision
+ // note: X / 32 doesn't round correctly. Instead, we use ((X / 16) + 1) / 2 for correct rounding
+
+ if ((mv * PCLK * 2) & 0x80000000) // 1 bit headroom
+ dlv = ((((2 * mv * PCLK) / (baudrate * (dav + mv))) / 16) + 1) / 2;
+ else // 2 bits headroom, use more precision
+ dlv = ((((4 * mv * PCLK) / (baudrate * (dav + mv))) / 32) + 1) / 2;
+
+ // datasheet says if DLL==DLM==0, then 1 is used instead since divide by zero is ungood
+ if (dlv == 0)
+ dlv = 1;
+
+ // datasheet says if dav > 0 then DL must be >= 2
+ if ((dav > 0) && (dlv < 2))
+ dlv = 2;
+
+ // integer rearrangement of the baudrate equation (with rounding)
+ b = ((PCLK * mv / (dlv * (dav + mv) * 8)) + 1) / 2;
+
+ // check to see how we went
+ b = abs(b - baudrate);
+ if (b < err_best)
+ {
+ err_best = b;
+
+ DL = dlv;
+ MulVal = mv;
+ DivAddVal = dav;
+
+ if (b == baudrate)
+ {
+ hit = 1;
+ break;
}
}
}
--- a/targets/hal/TARGET_NXP/TARGET_LPC23XX/serial_api.c Tue Nov 26 15:30:05 2013 +0000
+++ b/targets/hal/TARGET_NXP/TARGET_LPC23XX/serial_api.c Mon Dec 02 10:00:04 2013 +0000
@@ -156,22 +156,47 @@
uint16_t dlv;
uint8_t mv, dav;
if ((PCLK % (16 * baudrate)) != 0) { // Checking for zero remainder
- float err_best = (float) baudrate;
- uint16_t dlmax = DL;
- for ( dlv = (dlmax/2); (dlv <= dlmax) && !hit; dlv++) {
- for ( mv = 1; mv <= 15; mv++) {
- for ( dav = 1; dav < mv; dav++) {
- float ratio = 1.0f + ((float) dav / (float) mv);
- float calcbaud = (float)PCLK / (16.0f * (float) dlv * ratio);
- float err = fabs(((float) baudrate - calcbaud) / (float) baudrate);
- if (err < err_best) {
- DL = dlv;
- DivAddVal = dav;
- MulVal = mv;
- err_best = err;
- if (err < 0.001f) {
- hit = 1;
- }
+ int err_best = baudrate, b;
+ for (mv = 1; mv < 16 && !hit; mv++)
+ {
+ for (dav = 0; dav < mv; dav++)
+ {
+ // baudrate = PCLK / (16 * dlv * (1 + (DivAdd / Mul))
+ // solving for dlv, we get dlv = mul * PCLK / (16 * baudrate * (divadd + mul))
+ // mul has 4 bits, PCLK has 27 so we have 1 bit headroom which can be used for rounding
+ // for many values of mul and PCLK we have 2 or more bits of headroom which can be used to improve precision
+ // note: X / 32 doesn't round correctly. Instead, we use ((X / 16) + 1) / 2 for correct rounding
+
+ if ((mv * PCLK * 2) & 0x80000000) // 1 bit headroom
+ dlv = ((((2 * mv * PCLK) / (baudrate * (dav + mv))) / 16) + 1) / 2;
+ else // 2 bits headroom, use more precision
+ dlv = ((((4 * mv * PCLK) / (baudrate * (dav + mv))) / 32) + 1) / 2;
+
+ // datasheet says if DLL==DLM==0, then 1 is used instead since divide by zero is ungood
+ if (dlv == 0)
+ dlv = 1;
+
+ // datasheet says if dav > 0 then DL must be >= 2
+ if ((dav > 0) && (dlv < 2))
+ dlv = 2;
+
+ // integer rearrangement of the baudrate equation (with rounding)
+ b = ((PCLK * mv / (dlv * (dav + mv) * 8)) + 1) / 2;
+
+ // check to see how we went
+ b = abs(b - baudrate);
+ if (b < err_best)
+ {
+ err_best = b;
+
+ DL = dlv;
+ MulVal = mv;
+ DivAddVal = dav;
+
+ if (b == baudrate)
+ {
+ hit = 1;
+ break;
}
}
}
--- a/targets/hal/TARGET_NXP/TARGET_LPC408X/serial_api.c Tue Nov 26 15:30:05 2013 +0000
+++ b/targets/hal/TARGET_NXP/TARGET_LPC408X/serial_api.c Mon Dec 02 10:00:04 2013 +0000
@@ -147,22 +147,47 @@
uint16_t dlv;
uint8_t mv, dav;
if ((PCLK % (16 * baudrate)) != 0) { // Checking for zero remainder
- float err_best = (float) baudrate;
- uint16_t dlmax = DL;
- for ( dlv = (dlmax/2); (dlv <= dlmax) && !hit; dlv++) {
- for ( mv = 1; mv <= 15; mv++) {
- for ( dav = 1; dav < mv; dav++) {
- float ratio = 1.0f + ((float) dav / (float) mv);
- float calcbaud = (float)PCLK / (16.0f * (float) dlv * ratio);
- float err = fabs(((float) baudrate - calcbaud) / (float) baudrate);
- if (err < err_best) {
- DL = dlv;
- DivAddVal = dav;
- MulVal = mv;
- err_best = err;
- if (err < 0.001f) {
- hit = 1;
- }
+ int err_best = baudrate, b;
+ for (mv = 1; mv < 16 && !hit; mv++)
+ {
+ for (dav = 0; dav < mv; dav++)
+ {
+ // baudrate = PCLK / (16 * dlv * (1 + (DivAdd / Mul))
+ // solving for dlv, we get dlv = mul * PCLK / (16 * baudrate * (divadd + mul))
+ // mul has 4 bits, PCLK has 27 so we have 1 bit headroom which can be used for rounding
+ // for many values of mul and PCLK we have 2 or more bits of headroom which can be used to improve precision
+ // note: X / 32 doesn't round correctly. Instead, we use ((X / 16) + 1) / 2 for correct rounding
+
+ if ((mv * PCLK * 2) & 0x80000000) // 1 bit headroom
+ dlv = ((((2 * mv * PCLK) / (baudrate * (dav + mv))) / 16) + 1) / 2;
+ else // 2 bits headroom, use more precision
+ dlv = ((((4 * mv * PCLK) / (baudrate * (dav + mv))) / 32) + 1) / 2;
+
+ // datasheet says if DLL==DLM==0, then 1 is used instead since divide by zero is ungood
+ if (dlv == 0)
+ dlv = 1;
+
+ // datasheet says if dav > 0 then DL must be >= 2
+ if ((dav > 0) && (dlv < 2))
+ dlv = 2;
+
+ // integer rearrangement of the baudrate equation (with rounding)
+ b = ((PCLK * mv / (dlv * (dav + mv) * 8)) + 1) / 2;
+
+ // check to see how we went
+ b = abs(b - baudrate);
+ if (b < err_best)
+ {
+ err_best = b;
+
+ DL = dlv;
+ MulVal = mv;
+ DivAddVal = dav;
+
+ if (b == baudrate)
+ {
+ hit = 1;
+ break;
}
}
}
--- a/targets/hal/TARGET_NXP/TARGET_LPC43XX/serial_api.c Tue Nov 26 15:30:05 2013 +0000
+++ b/targets/hal/TARGET_NXP/TARGET_LPC43XX/serial_api.c Mon Dec 02 10:00:04 2013 +0000
@@ -130,22 +130,47 @@
uint16_t dlv;
uint8_t mv, dav;
if ((PCLK % (16 * baudrate)) != 0) { // Checking for zero remainder
- float err_best = (float) baudrate;
- uint16_t dlmax = DL;
- for ( dlv = (dlmax/2); (dlv <= dlmax) && !hit; dlv++) {
- for ( mv = 1; mv <= 15; mv++) {
- for ( dav = 1; dav < mv; dav++) {
- float ratio = 1.0f + ((float) dav / (float) mv);
- float calcbaud = (float)PCLK / (16.0f * (float) dlv * ratio);
- float err = fabs(((float) baudrate - calcbaud) / (float) baudrate);
- if (err < err_best) {
- DL = dlv;
- DivAddVal = dav;
- MulVal = mv;
- err_best = err;
- if (err < 0.001f) {
- hit = 1;
- }
+ int err_best = baudrate, b;
+ for (mv = 1; mv < 16 && !hit; mv++)
+ {
+ for (dav = 0; dav < mv; dav++)
+ {
+ // baudrate = PCLK / (16 * dlv * (1 + (DivAdd / Mul))
+ // solving for dlv, we get dlv = mul * PCLK / (16 * baudrate * (divadd + mul))
+ // mul has 4 bits, PCLK has 27 so we have 1 bit headroom which can be used for rounding
+ // for many values of mul and PCLK we have 2 or more bits of headroom which can be used to improve precision
+ // note: X / 32 doesn't round correctly. Instead, we use ((X / 16) + 1) / 2 for correct rounding
+
+ if ((mv * PCLK * 2) & 0x80000000) // 1 bit headroom
+ dlv = ((((2 * mv * PCLK) / (baudrate * (dav + mv))) / 16) + 1) / 2;
+ else // 2 bits headroom, use more precision
+ dlv = ((((4 * mv * PCLK) / (baudrate * (dav + mv))) / 32) + 1) / 2;
+
+ // datasheet says if DLL==DLM==0, then 1 is used instead since divide by zero is ungood
+ if (dlv == 0)
+ dlv = 1;
+
+ // datasheet says if dav > 0 then DL must be >= 2
+ if ((dav > 0) && (dlv < 2))
+ dlv = 2;
+
+ // integer rearrangement of the baudrate equation (with rounding)
+ b = ((PCLK * mv / (dlv * (dav + mv) * 8)) + 1) / 2;
+
+ // check to see how we went
+ b = abs(b - baudrate);
+ if (b < err_best)
+ {
+ err_best = b;
+
+ DL = dlv;
+ MulVal = mv;
+ DivAddVal = dav;
+
+ if (b == baudrate)
+ {
+ hit = 1;
+ break;
}
}
}