feedc0de/arduino-esp32
1
0
Fork 0
forked from espressif/arduino-esp32
Code Pull Requests Activity

Cleanup arduino useless bullshit

Browse Source
This commit is contained in:
0xFEEDC0DE64
2022-05-23 23:28:35 +02:00
parent e1540e64a6
commit c85a4725a9
29 changed files with 187 additions and 341 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -14,7 +14,6 @@ set(CORE_SRCS
cores/esp32/esp32-hal-touch.c cores/esp32/esp32-hal-touch.c
cores/esp32/esp32-hal-rmt.c cores/esp32/esp32-hal-rmt.c
cores/esp32/FunctionalInterrupt.cpp cores/esp32/FunctionalInterrupt.cpp
cores/esp32/IPv6Address.cpp
cores/esp32/stdlib_noniso.c cores/esp32/stdlib_noniso.c
cores/esp32/USB.cpp cores/esp32/USB.cpp
cores/esp32/USBCDC.cpp cores/esp32/USBCDC.cpp

186
cores/esp32/Arduino.h
View File

@ -20,24 +20,24 @@
#ifndef Arduino_h #ifndef Arduino_h
#define Arduino_h #define Arduino_h
#include <stdbool.h> //#include <stdbool.h>
#include <stdint.h> //#include <stdint.h>
#include <stdarg.h> //#include <stdarg.h>
#include <stddef.h> //#include <stddef.h>
#include <stdio.h> //#include <stdio.h>
#include <stdlib.h> //#include <stdlib.h>
#include <string.h> //#include <string.h>
#include <inttypes.h> //#include <inttypes.h>
#include "esp_arduino_version.h" //#include "esp_arduino_version.h"
#include "freertos/FreeRTOS.h" //#include "freertos/FreeRTOS.h"
#include "freertos/task.h" //#include "freertos/task.h"
#include "freertos/semphr.h" //#include "freertos/semphr.h"
#include "esp32-hal.h" //#include "esp32-hal.h"
#include "esp8266-compat.h" //#include "esp8266-compat.h"
#include "soc/gpio_reg.h" //#include "soc/gpio_reg.h"
#include "stdlib_noniso.h" //#include "stdlib_noniso.h"
//#define PI 3.1415926535897932384626433832795 //#define PI 3.1415926535897932384626433832795
//#define HALF_PI 1.5707963267948966192313216916398 //#define HALF_PI 1.5707963267948966192313216916398
@ -49,112 +49,102 @@
//#define SERIAL 0x0 //#define SERIAL 0x0
//#define DISPLAY 0x1 //#define DISPLAY 0x1
#define LSBFIRST 0
#define MSBFIRST 1
//Interrupt Modes //Interrupt Modes
#define RISING 0x01 //#define RISING 0x01
#define FALLING 0x02 //#define FALLING 0x02
#define CHANGE 0x03 //#define CHANGE 0x03
#define ONLOW 0x04 //#define ONLOW 0x04
#define ONHIGH 0x05 //#define ONHIGH 0x05
#define ONLOW_WE 0x0C //#define ONLOW_WE 0x0C
#define ONHIGH_WE 0x0D //#define ONHIGH_WE 0x0D
#define DEFAULT 1 //#define DEFAULT 1
#define EXTERNAL 0 //#define EXTERNAL 0
#ifndef __STRINGIFY //#ifndef __STRINGIFY
#define __STRINGIFY(a) #a //#define __STRINGIFY(a) #a
#endif //#endif
#define constrain(amt,low,high) ((amt)<(low)?(low):((amt)>(high)?(high):(amt))) //#define constrain(amt,low,high) ((amt)<(low)?(low):((amt)>(high)?(high):(amt)))
#define radians(deg) ((deg)*DEG_TO_RAD) //#define radians(deg) ((deg)*DEG_TO_RAD)
#define degrees(rad) ((rad)*RAD_TO_DEG) //#define degrees(rad) ((rad)*RAD_TO_DEG)
#define sq(x) ((x)*(x)) //#define sq(x) ((x)*(x))
#define sei() //#define sei()
#define cli() //#define cli()
#define interrupts() sei() //#define interrupts() sei()
#define noInterrupts() cli() //#define noInterrupts() cli()
#define clockCyclesPerMicrosecond() ( (long int)getCpuFrequencyMhz() ) //#define lowByte(w) ((uint8_t) ((w) & 0xff))
#define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() ) //#define highByte(w) ((uint8_t) ((w) >> 8))
#define microsecondsToClockCycles(a) ( (a) * clockCyclesPerMicrosecond() )
#define lowByte(w) ((uint8_t) ((w) & 0xff)) //#define bitRead(value, bit) (((value) >> (bit)) & 0x01)
#define highByte(w) ((uint8_t) ((w) >> 8)) //#define bitSet(value, bit) ((value) |= (1UL << (bit)))
//#define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
//#define bitWrite(value, bit, bitvalue) ((bitvalue) ? bitSet(value, bit) : bitClear(value, bit))
#define bitRead(value, bit) (((value) >> (bit)) & 0x01) //// avr-libc defines _NOP() since 1.6.2
#define bitSet(value, bit) ((value) |= (1UL << (bit))) //#ifndef _NOP
#define bitClear(value, bit) ((value) &= ~(1UL << (bit))) //#define _NOP() do { __asm__ volatile ("nop"); } while (0)
#define bitWrite(value, bit, bitvalue) ((bitvalue) ? bitSet(value, bit) : bitClear(value, bit)) //#endif
// avr-libc defines _NOP() since 1.6.2 //#define bit(b) (1UL << (b))
#ifndef _NOP //#define _BV(b) (1UL << (b))
#define _NOP() do { __asm__ volatile ("nop"); } while (0)
#endif
#define bit(b) (1UL << (b)) //#define digitalPinToPort(pin) (((pin)>31)?1:0)
#define _BV(b) (1UL << (b)) //#define digitalPinToBitMask(pin) (1UL << (((pin)>31)?((pin)-32):(pin)))
//#define digitalPinToTimer(pin) (0)
//#define analogInPinToBit(P) (P)
//#define portOutputRegister(port) ((volatile uint32_t*)((port)?GPIO_OUT1_REG:GPIO_OUT_REG))
//#define portInputRegister(port) ((volatile uint32_t*)((port)?GPIO_IN1_REG:GPIO_IN_REG))
//#define portModeRegister(port) ((volatile uint32_t*)((port)?GPIO_ENABLE1_REG:GPIO_ENABLE_REG))
#define digitalPinToPort(pin) (((pin)>31)?1:0) //#define NOT_A_PIN -1
#define digitalPinToBitMask(pin) (1UL << (((pin)>31)?((pin)-32):(pin))) //#define NOT_A_PORT -1
#define digitalPinToTimer(pin) (0) //#define NOT_AN_INTERRUPT -1
#define analogInPinToBit(P) (P) //#define NOT_ON_TIMER 0
#define portOutputRegister(port) ((volatile uint32_t*)((port)?GPIO_OUT1_REG:GPIO_OUT_REG))
#define portInputRegister(port) ((volatile uint32_t*)((port)?GPIO_IN1_REG:GPIO_IN_REG))
#define portModeRegister(port) ((volatile uint32_t*)((port)?GPIO_ENABLE1_REG:GPIO_ENABLE_REG))
#define NOT_A_PIN -1 //typedef bool boolean;
#define NOT_A_PORT -1 //typedef uint8_t byte;
#define NOT_AN_INTERRUPT -1 //typedef unsigned int word;
#define NOT_ON_TIMER 0
typedef bool boolean; //long map(long, long, long, long, long);
typedef uint8_t byte;
typedef unsigned int word;
long map(long, long, long, long, long); //#ifdef __cplusplus
//extern "C" {
//#endif
#ifdef __cplusplus //unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout);
extern "C" { //unsigned long pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout);
#endif
unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout); //#ifdef __cplusplus
unsigned long pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout); //}
uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder); //#include <algorithm>
void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val); //#include <cmath>
#ifdef __cplusplus //#include "WCharacter.h"
}
#include <algorithm> //using std::abs;
#include <cmath> //using std::isinf;
//using std::isnan;
//using std::max;
//using std::min;
//using ::round;
#include "WCharacter.h" //uint16_t makeWord(uint16_t w);
//uint16_t makeWord(byte h, byte l);
using std::abs; //#define word(...) makeWord(__VA_ARGS__)
using std::isinf;
using std::isnan;
using std::max;
using std::min;
using ::round;
uint16_t makeWord(uint16_t w); //unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L);
uint16_t makeWord(byte h, byte l); //unsigned long pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L);
#define word(...) makeWord(__VA_ARGS__) //#endif /* __cplusplus */
unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L); //#define _min(a,b) ((a)<(b)?(a):(b))
unsigned long pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L); //#define _max(a,b) ((a)>(b)?(a):(b))
#endif /* __cplusplus */ //#include "pins_arduino.h"
#define _min(a,b) ((a)<(b)?(a):(b))
#define _max(a,b) ((a)>(b)?(a):(b))
#include "pins_arduino.h"
#endif /* _ESP32_CORE_ARDUINO_H_ */ #endif /* _ESP32_CORE_ARDUINO_H_ */

2
cores/esp32/FunctionalInterrupt.cpp
View File

@ -6,7 +6,7 @@
*/ */
#include "FunctionalInterrupt.h" #include "FunctionalInterrupt.h"
#include "Arduino.h" #include "esp32-hal.h"
typedef void (*voidFuncPtr)(void); typedef void (*voidFuncPtr)(void);
typedef void (*voidFuncPtrArg)(void*); typedef void (*voidFuncPtrArg)(void*);

89
cores/esp32/IPv6Address.cpp
View File

@ -1,89 +0,0 @@
/*
IPv6Address.cpp - Base class that provides IPv6Address
Copyright (c) 2011 Adrian McEwen. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <Arduino.h>
#include <IPv6Address.h>
IPv6Address::IPv6Address()
{
memset(_address.bytes, 0, sizeof(_address.bytes));
}
IPv6Address::IPv6Address(const uint8_t *address)
{
memcpy(_address.bytes, address, sizeof(_address.bytes));
}
IPv6Address::IPv6Address(const uint32_t *address)
{
memcpy(_address.bytes, (const uint8_t *)address, sizeof(_address.bytes));
}
IPv6Address& IPv6Address::operator=(const uint8_t *address)
{
memcpy(_address.bytes, address, sizeof(_address.bytes));
return *this;
}
bool IPv6Address::operator==(const uint8_t* addr) const
{
return memcmp(addr, _address.bytes, sizeof(_address.bytes)) == 0;
}
//size_t IPv6Address::printTo(Print& p) const
//{
// size_t n = 0;
// for(int i = 0; i < 16; i+=2) {
// if(i){
// n += p.print(':');
// }
// n += p.printf("%02x", _address.bytes[i]);
// n += p.printf("%02x", _address.bytes[i+1]);
// }
// return n;
//}
std::string IPv6Address::toString() const
{
char szRet[40];
sprintf(szRet,"%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x",
_address.bytes[0], _address.bytes[1], _address.bytes[2], _address.bytes[3],
_address.bytes[4], _address.bytes[5], _address.bytes[6], _address.bytes[7],
_address.bytes[8], _address.bytes[9], _address.bytes[10], _address.bytes[11],
_address.bytes[12], _address.bytes[13], _address.bytes[14], _address.bytes[15]);
return std::string(szRet);
}
bool IPv6Address::fromString(const char *address)
{
//format 0011:2233:4455:6677:8899:aabb:ccdd:eeff
if(strlen(address) != 39){
return false;
}
char * pos = (char *)address;
size_t i = 0;
for(i = 0; i < 16; i+=2) {
if(!sscanf(pos, "%2hhx", &_address.bytes[i]) || !sscanf(pos+2, "%2hhx", &_address.bytes[i+1])){
return false;
}
pos += 5;
}
return true;
}

92
cores/esp32/IPv6Address.h
View File

@ -1,92 +0,0 @@
/*
IPv6Address.h - Base class that provides IPv6Address
Copyright (c) 2011 Adrian McEwen. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef IPv6Address_h
#define IPv6Address_h
#include <stdint.h>
#include <string>
// A class to make it easier to handle and pass around IP addresses
class IPv6Address
{
private:
union {
uint8_t bytes[16]; // IPv4 address
uint32_t dword[4];
} _address;
// Access the raw byte array containing the address. Because this returns a pointer
// to the internal structure rather than a copy of the address this function should only
// be used when you know that the usage of the returned uint8_t* will be transient and not
// stored.
uint8_t* raw_address()
{
return _address.bytes;
}
public:
// Constructors
IPv6Address();
IPv6Address(const uint8_t *address);
IPv6Address(const uint32_t *address);
bool fromString(const char *address);
bool fromString(const std::string &address) { return fromString(address.c_str()); }
operator const uint8_t*() const
{
return _address.bytes;
}
operator const uint32_t*() const
{
return _address.dword;
}
bool operator==(const IPv6Address& addr) const
{
return (_address.dword[0] == addr._address.dword[0])
&& (_address.dword[1] == addr._address.dword[1])
&& (_address.dword[2] == addr._address.dword[2])
&& (_address.dword[3] == addr._address.dword[3]);
}
bool operator==(const uint8_t* addr) const;
// Overloaded index operator to allow getting and setting individual octets of the address
uint8_t operator[](int index) const
{
return _address.bytes[index];
}
uint8_t& operator[](int index)
{
return _address.bytes[index];
}
// Overloaded copy operators to allow initialisation of IPv6Address objects from other types
IPv6Address& operator=(const uint8_t *address);
// virtual size_t printTo(Print& p) const;
std::string toString() const;
friend class UDP;
friend class Client;
friend class Server;
};
#endif

52
cores/esp32/WCharacter.h
View File

@ -25,83 +25,83 @@
#define toascii(__c) ((__c)&0177) #define toascii(__c) ((__c)&0177)
// WCharacter.h prototypes // WCharacter.h prototypes
inline boolean isAlphaNumeric(int c) __attribute__((always_inline)); inline bool isAlphaNumeric(int c) __attribute__((always_inline));
inline boolean isAlpha(int c) __attribute__((always_inline)); inline bool isAlpha(int c) __attribute__((always_inline));
inline boolean isAscii(int c) __attribute__((always_inline)); inline bool isAscii(int c) __attribute__((always_inline));
inline boolean isWhitespace(int c) __attribute__((always_inline)); inline bool isWhitespace(int c) __attribute__((always_inline));
inline boolean isControl(int c) __attribute__((always_inline)); inline bool isControl(int c) __attribute__((always_inline));
inline boolean isDigit(int c) __attribute__((always_inline)); inline bool isDigit(int c) __attribute__((always_inline));
inline boolean isGraph(int c) __attribute__((always_inline)); inline bool isGraph(int c) __attribute__((always_inline));
inline boolean isLowerCase(int c) __attribute__((always_inline)); inline bool isLowerCase(int c) __attribute__((always_inline));
inline boolean isPrintable(int c) __attribute__((always_inline)); inline bool isPrintable(int c) __attribute__((always_inline));
inline boolean isPunct(int c) __attribute__((always_inline)); inline bool isPunct(int c) __attribute__((always_inline));
inline boolean isSpace(int c) __attribute__((always_inline)); inline bool isSpace(int c) __attribute__((always_inline));
inline boolean isUpperCase(int c) __attribute__((always_inline)); inline bool isUpperCase(int c) __attribute__((always_inline));
inline boolean isHexadecimalDigit(int c) __attribute__((always_inline)); inline bool isHexadecimalDigit(int c) __attribute__((always_inline));
inline int toAscii(int c) __attribute__((always_inline)); inline int toAscii(int c) __attribute__((always_inline));
inline int toLowerCase(int c) __attribute__((always_inline)); inline int toLowerCase(int c) __attribute__((always_inline));
inline int toUpperCase(int c) __attribute__((always_inline)); inline int toUpperCase(int c) __attribute__((always_inline));
// Checks for an alphanumeric character. // Checks for an alphanumeric character.
// It is equivalent to (isalpha(c) || isdigit(c)). // It is equivalent to (isalpha(c) || isdigit(c)).
inline boolean isAlphaNumeric(int c) inline bool isAlphaNumeric(int c)
{ {
return (isalnum(c) == 0 ? false : true); return (isalnum(c) == 0 ? false : true);
} }
// Checks for an alphabetic character. // Checks for an alphabetic character.
// It is equivalent to (isupper(c) || islower(c)). // It is equivalent to (isupper(c) || islower(c)).
inline boolean isAlpha(int c) inline bool isAlpha(int c)
{ {
return (isalpha(c) == 0 ? false : true); return (isalpha(c) == 0 ? false : true);
} }
// Checks whether c is a 7-bit unsigned char value // Checks whether c is a 7-bit unsigned char value
// that fits into the ASCII character set. // that fits into the ASCII character set.
inline boolean isAscii(int c) inline bool isAscii(int c)
{ {
return ( isascii (c) == 0 ? false : true); return ( isascii (c) == 0 ? false : true);
} }
// Checks for a blank character, that is, a space or a tab. // Checks for a blank character, that is, a space or a tab.
inline boolean isWhitespace(int c) inline bool isWhitespace(int c)
{ {
return (isblank(c) == 0 ? false : true); return (isblank(c) == 0 ? false : true);
} }
// Checks for a control character. // Checks for a control character.
inline boolean isControl(int c) inline bool isControl(int c)
{ {
return (iscntrl(c) == 0 ? false : true); return (iscntrl(c) == 0 ? false : true);
} }
// Checks for a digit (0 through 9). // Checks for a digit (0 through 9).
inline boolean isDigit(int c) inline bool isDigit(int c)
{ {
return (isdigit(c) == 0 ? false : true); return (isdigit(c) == 0 ? false : true);
} }
// Checks for any printable character except space. // Checks for any printable character except space.
inline boolean isGraph(int c) inline bool isGraph(int c)
{ {
return (isgraph(c) == 0 ? false : true); return (isgraph(c) == 0 ? false : true);
} }
// Checks for a lower-case character. // Checks for a lower-case character.
inline boolean isLowerCase(int c) inline bool isLowerCase(int c)
{ {
return (islower(c) == 0 ? false : true); return (islower(c) == 0 ? false : true);
} }
// Checks for any printable character including space. // Checks for any printable character including space.
inline boolean isPrintable(int c) inline bool isPrintable(int c)
{ {
return (isprint(c) == 0 ? false : true); return (isprint(c) == 0 ? false : true);
} }
// Checks for any printable character which is not a space // Checks for any printable character which is not a space
// or an alphanumeric character. // or an alphanumeric character.
inline boolean isPunct(int c) inline bool isPunct(int c)
{ {
return (ispunct(c) == 0 ? false : true); return (ispunct(c) == 0 ? false : true);
} }
@ -109,20 +109,20 @@ inline boolean isPunct(int c)
// Checks for white-space characters. For the avr-libc library, // Checks for white-space characters. For the avr-libc library,
// these are: space, formfeed ('\f'), newline ('\n'), carriage // these are: space, formfeed ('\f'), newline ('\n'), carriage
// return ('\r'), horizontal tab ('\t'), and vertical tab ('\v'). // return ('\r'), horizontal tab ('\t'), and vertical tab ('\v').
inline boolean isSpace(int c) inline bool isSpace(int c)
{ {
return (isspace(c) == 0 ? false : true); return (isspace(c) == 0 ? false : true);
} }
// Checks for an uppercase letter. // Checks for an uppercase letter.
inline boolean isUpperCase(int c) inline bool isUpperCase(int c)
{ {
return (isupper(c) == 0 ? false : true); return (isupper(c) == 0 ? false : true);
} }
// Checks for a hexadecimal digits, i.e. one of 0 1 2 3 4 5 6 7 // Checks for a hexadecimal digits, i.e. one of 0 1 2 3 4 5 6 7
// 8 9 a b c d e f A B C D E F. // 8 9 a b c d e f A B C D E F.
inline boolean isHexadecimalDigit(int c) inline bool isHexadecimalDigit(int c)
{ {
return (isxdigit(c) == 0 ? false : true); return (isxdigit(c) == 0 ? false : true);
} }

28
cores/esp32/WMath.cpp
View File

@ -27,20 +27,20 @@ extern "C" {
#include "esp_system.h" #include "esp_system.h"
} }
long map(long x, long in_min, long in_max, long out_min, long out_max) { //long map(long x, long in_min, long in_max, long out_min, long out_max) {
const long dividend = out_max - out_min; // const long dividend = out_max - out_min;
const long divisor = in_max - in_min; // const long divisor = in_max - in_min;
const long delta = x - in_min; // const long delta = x - in_min;
return (delta * dividend + (divisor / 2)) / divisor + out_min; // return (delta * dividend + (divisor / 2)) / divisor + out_min;
} //}
unsigned int makeWord(unsigned int w) //unsigned int makeWord(unsigned int w)
{ //{
return w; // return w;
} //}
unsigned int makeWord(unsigned char h, unsigned char l) //unsigned int makeWord(unsigned char h, unsigned char l)
{ //{
return (h << 8) | l; // return (h << 8) | l;
} //}

1
cores/esp32/esp32-hal-adc.c
View File

@ -42,6 +42,7 @@ static uint8_t __analogVRefPin = 0;
#include "rom/ets_sys.h" #include "rom/ets_sys.h"
#include "esp_intr.h" #include "esp_intr.h"
#endif #endif
#include "esp32-hal-gpio.h"
static uint8_t __analogAttenuation = 3;//11db static uint8_t __analogAttenuation = 3;//11db
static uint8_t __analogWidth = 3;//12 bits static uint8_t __analogWidth = 3;//12 bits

4
cores/esp32/esp32-hal-cpu.h
View File

@ -45,4 +45,8 @@ uint32_t getApbFrequency(); // In Hz
} }
#endif #endif
#define clockCyclesPerMicrosecond() ( (long int)getCpuFrequencyMhz() )
#define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() )
#define microsecondsToClockCycles(a) ( (a) * clockCyclesPerMicrosecond() )
#endif /* _ESP32_HAL_CPU_H_ */ #endif /* _ESP32_HAL_CPU_H_ */

1
cores/esp32/esp32-hal-dac.c
View File

@ -20,6 +20,7 @@
#include "soc/sens_reg.h" #include "soc/sens_reg.h"
#include "soc/sens_struct.h" #include "soc/sens_struct.h"
#include "driver/dac.h" #include "driver/dac.h"
#include "esp32-hal-gpio.h"
#if CONFIG_IDF_TARGET_ESP32 #if CONFIG_IDF_TARGET_ESP32
#define DAC1 25 #define DAC1 25

3
cores/esp32/esp32-hal-i2c.c
View File

@ -25,6 +25,8 @@
#include "esp_attr.h" #include "esp_attr.h"
#include "esp32-hal-cpu.h" // cpu clock change support 31DEC2018 #include "esp32-hal-cpu.h" // cpu clock change support 31DEC2018
#include "esp32-hal-log.h" #include "esp32-hal-log.h"
#include "esp32-hal-gpio.h"
#include "esp32-hal-matrix.h"
#include "esp_system.h" #include "esp_system.h"
#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+ #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
@ -38,6 +40,7 @@
#else // ESP32 Before IDF 4.0 #else // ESP32 Before IDF 4.0
#include "rom/ets_sys.h" #include "rom/ets_sys.h"
#endif #endif
#include "driver/gpio.h"
#if CONFIG_IDF_TARGET_ESP32 #if CONFIG_IDF_TARGET_ESP32

3
cores/esp32/esp32-hal-ledc.c
View File

@ -21,6 +21,9 @@
#include "soc/dport_reg.h" #include "soc/dport_reg.h"
#include "soc/ledc_reg.h" #include "soc/ledc_reg.h"
#include "soc/ledc_struct.h" #include "soc/ledc_struct.h"
#include "esp32-hal-cpu.h"
#include "esp32-hal-gpio.h"
#include "esp32-hal-ledc.h"
#include "esp_system.h" #include "esp_system.h"
#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+ #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+

3
cores/esp32/esp32-hal-rmt.c
View File

@ -25,6 +25,9 @@
#include "esp_intr_alloc.h" #include "esp_intr_alloc.h"
#include "hal/rmt_ll.h" #include "hal/rmt_ll.h"
#include "driver/rmt.h" #include "driver/rmt.h"
#include "esp32-hal-rmt.h"
#include "esp32-hal-gpio.h"
#include "esp32-hal-matrix.h"
// RMTMEM address is declared in <target>.peripherals.ld // RMTMEM address is declared in <target>.peripherals.ld
extern rmt_mem_t RMTMEM; extern rmt_mem_t RMTMEM;

2
cores/esp32/esp32-hal-sigmadelta.c
View File

@ -20,6 +20,8 @@
#include "soc/gpio_sd_reg.h" #include "soc/gpio_sd_reg.h"
#include "soc/gpio_sd_struct.h" #include "soc/gpio_sd_struct.h"
#include "freertos/semphr.h" #include "freertos/semphr.h"
#include "esp32-hal-cpu.h"
#include "esp32-hal-gpio.h"
#include "esp_system.h" #include "esp_system.h"
#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+ #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+

3
cores/esp32/esp32-hal-spi.c
View File

@ -43,6 +43,9 @@
#include "rom/gpio.h" #include "rom/gpio.h"
#include "esp_intr.h" #include "esp_intr.h"
#endif #endif
#include "esp32-hal-gpio.h"
#include "esp32-hal-matrix.h"
#include "esp32-hal-cpu.h"
struct spi_struct_t { struct spi_struct_t {
spi_dev_t * dev; spi_dev_t * dev;

3
cores/esp32/esp32-hal-touch.c
View File

@ -31,13 +31,14 @@
#include "esp32s2/rom/ets_sys.h" #include "esp32s2/rom/ets_sys.h"
#include "esp_intr_alloc.h" #include "esp_intr_alloc.h"
#include "soc/periph_defs.h" #include "soc/periph_defs.h"
#else #else
#error Target CONFIG_IDF_TARGET is not supported #error Target CONFIG_IDF_TARGET is not supported
#endif #endif
#else // ESP32 Before IDF 4.0 #else // ESP32 Before IDF 4.0
#include "rom/ets_sys.h" #include "rom/ets_sys.h"
#include "esp_intr.h" #include "esp_intr.h"
#endif #endif
#include "esp32-hal-gpio.h"
static uint16_t __touchSleepCycles = 0x1000; static uint16_t __touchSleepCycles = 0x1000;
static uint16_t __touchMeasureCycles = 0x1000; static uint16_t __touchMeasureCycles = 0x1000;

24
cores/esp32/esp32-hal.h
View File

@ -61,18 +61,18 @@ void yield(void);
#define NOP() asm volatile ("nop") #define NOP() asm volatile ("nop")
//#include "esp32-hal-log.h" //#include "esp32-hal-log.h"
#include "esp32-hal-matrix.h" //#include "esp32-hal-matrix.h"
#include "esp32-hal-gpio.h" //#include "esp32-hal-gpio.h"
#include "esp32-hal-touch.h" //#include "esp32-hal-touch.h"
#include "esp32-hal-dac.h" //#include "esp32-hal-dac.h"
#include "esp32-hal-adc.h" //#include "esp32-hal-adc.h"
#include "esp32-hal-spi.h" //#include "esp32-hal-spi.h"
#include "esp32-hal-i2c.h" //#include "esp32-hal-i2c.h"
#include "esp32-hal-ledc.h" //#include "esp32-hal-ledc.h"
#include "esp32-hal-rmt.h" //#include "esp32-hal-rmt.h"
#include "esp32-hal-sigmadelta.h" //#include "esp32-hal-sigmadelta.h"
#include "esp32-hal-psram.h" //#include "esp32-hal-psram.h"
#include "esp32-hal-cpu.h" //#include "esp32-hal-cpu.h"
//returns chip temperature in Celsius //returns chip temperature in Celsius
float temperatureRead(); float temperatureRead();

2
cores/esp32/wiring_shift.c
View File

@ -17,8 +17,10 @@
$Id: wiring.c 248 2007-02-03 15:36:30Z mellis $ $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $
*/ */
#include "wiring_shift.h"
#include "esp32-hal.h" #include "esp32-hal.h"
#include "wiring_private.h" #include "wiring_private.h"
#include "esp32-hal-gpio.h"
uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder) { uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder) {
uint8_t value = 0; uint8_t value = 0;

9
cores/esp32/wiring_shift.h Normal file
View File

@ -0,0 +1,9 @@
#pragma once
#define LSBFIRST 0
#define MSBFIRST 1
#include <stdint.h>
uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder);
void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val);

2
libraries/FS/src/FS.cpp
View File

@ -153,7 +153,7 @@ const char* File::name() const
} }
//to implement //to implement
boolean File::isDirectory(void) bool File::isDirectory(void)
{ {
if (!_p) { if (!_p) {
return false; return false;

2
libraries/FS/src/FS.h
View File

@ -75,7 +75,7 @@ public:
time_t getLastWrite(); time_t getLastWrite();
const char* name() const; const char* name() const;
boolean isDirectory(void); bool isDirectory(void);
File openNextFile(const char* mode = FILE_READ); File openNextFile(const char* mode = FILE_READ);
void rewindDirectory(void); void rewindDirectory(void);

2
libraries/FS/src/FSImpl.h
View File

@ -39,7 +39,7 @@ public:
virtual void close() = 0; virtual void close() = 0;
virtual time_t getLastWrite() = 0; virtual time_t getLastWrite() = 0;
virtual const char* name() const = 0; virtual const char* name() const = 0;
virtual boolean isDirectory(void) = 0; virtual bool isDirectory(void) = 0;
virtual FileImplPtr openNextFile(const char* mode) = 0; virtual FileImplPtr openNextFile(const char* mode) = 0;
virtual void rewindDirectory(void) = 0; virtual void rewindDirectory(void) = 0;
virtual operator bool() = 0; virtual operator bool() = 0;

4
libraries/FS/src/vfs_api.cpp
View File

@ -16,6 +16,8 @@
#include "esp32-hal-log.h" #include "esp32-hal-log.h"
#include <string.h>
using namespace fs; using namespace fs;
FileImplPtr VFSImpl::open(const char* path, const char* mode) FileImplPtr VFSImpl::open(const char* path, const char* mode)
@ -385,7 +387,7 @@ const char* VFSFileImpl::name() const
} }
//to implement //to implement
boolean VFSFileImpl::isDirectory(void) bool VFSFileImpl::isDirectory(void)
{ {
return _isDirectory; return _isDirectory;
} }

2
libraries/FS/src/vfs_api.h
View File

@ -68,7 +68,7 @@ public:
void close() override; void close() override;
const char* name() const override; const char* name() const override;
time_t getLastWrite() override; time_t getLastWrite() override;
boolean isDirectory(void) override; bool isDirectory(void) override;
FileImplPtr openNextFile(const char* mode) override; FileImplPtr openNextFile(const char* mode) override;
void rewindDirectory(void) override; void rewindDirectory(void) override;
operator bool(); operator bool();

2
libraries/SPI/src/SPI.cpp
View File

@ -21,6 +21,8 @@
#include "SPI.h" #include "SPI.h"
#include "pins_arduino.h"
SPIClass::SPIClass(uint8_t spi_bus) SPIClass::SPIClass(uint8_t spi_bus)
:_spi_num(spi_bus) :_spi_num(spi_bus)
,_spi(NULL) ,_spi(NULL)

1
libraries/SPI/src/SPI.h
View File

@ -22,7 +22,6 @@
#define _SPI_H_INCLUDED #define _SPI_H_INCLUDED
#include <stdlib.h> #include <stdlib.h>
#include "pins_arduino.h"
#include "esp32-hal-spi.h" #include "esp32-hal-spi.h"
#define SPI_HAS_TRANSACTION #define SPI_HAS_TRANSACTION

2
libraries/SPIFFS/src/SPIFFS.cpp
View File

@ -25,6 +25,8 @@ extern "C" {
#include "esp32-hal-log.h" #include "esp32-hal-log.h"
#include <string.h>
using namespace fs; using namespace fs;
class SPIFFSImpl : public VFSImpl class SPIFFSImpl : public VFSImpl

2
libraries/Wire/src/Wire.cpp
View File

@ -35,7 +35,7 @@ extern "C" {
#include "esp32-hal-i2c.h" #include "esp32-hal-i2c.h"
#include "esp32-hal-log.h" #include "esp32-hal-log.h"
#include "Wire.h" #include "Wire.h"
#include "Arduino.h" #include "pins_arduino.h"
std::string toString(i2c_err_t val) std::string toString(i2c_err_t val)
{ {

1
libraries/Wire/src/Wire.h
View File

@ -29,6 +29,7 @@
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "freertos/queue.h" #include "freertos/queue.h"
#include <string> #include <string>
#include "esp32-hal-i2c.h"
#define STICKBREAKER 'V1.1.0' #define STICKBREAKER 'V1.1.0'
#define I2C_BUFFER_LENGTH 128 #define I2C_BUFFER_LENGTH 128