class EepromClass(ArduinoClass):
class_name = "EEPROM"
get = Function("get", [Variable("adress", uint16_t), Variable("target", uint32_t)])
write = Function(
"write", [Variable("adress", uint16_t), Variable("value", uint8_t)]
)
put = Function("put", [Variable("adress", uint16_t), Variable("source", uint32_t)])
read = Function("read", [Variable("adress", uint16_t)], return_type=uint8_t)
update = Function(
"update", [Variable("adress", uint16_t), Variable("value", uint8_t)]
)
include = "<EEPROM.h>"
def __init__(self):
self.classes = []
self.definitions = []
self.imports = []
self.global_variables = []
self.functions = []
self.includes = []
self.enums = []
self.setup = Function(return_type=dt.void,
name="setup",
obscurable=False)
self.loop = Function(return_type=dt.void,
name="loop",
obscurable=False)
def __call__(self,
count_vaiable,
continue_condition,
raising_value=1,
code=None):
count_vaiable_code = partial(
lambda_remove_tabs_newline,
func=count_vaiable.initialize_code,
remove_endtabs=False,
)
continue_condition = continue_condition.inline
try:
raising_value = 1 + raising_value - 1
if raising_value < 0:
raising_value = count_vaiable.set(count_vaiable -
abs(raising_value))
else:
raising_value = count_vaiable.set(count_vaiable +
raising_value)
except:
pass
raising_value_code = partial(lambda_remove_tabs_newline,
func=raising_value)
inner_code = Function(code=code).inner_code
# (lambda obscure, indentation: "") if code is None else code
return super().__call__(count_vaiable_code, continue_condition,
raising_value_code, inner_code)
def generate_arduino_getter(self, arduino_getter):
from arduino_controller.basicboard.board import (
WRITE_DATA_FUNCTION,
COMMAND_FUNCTION_COMMUNICATION_ARGUMENTS,
)
f = Function(
arguments=COMMAND_FUNCTION_COMMUNICATION_ARGUMENTS,
name="get_{}".format(self),
code=() if arduino_getter is None else arduino_getter,
)
if arduino_getter is None:
if self.add_to_code:
f.add_call(
WRITE_DATA_FUNCTION(self, self.board.byte_ids.get(f)))
return f
farray = acc.add(
FunctionArray(
"functionarray",
arguments=[
Array("data", dt.uint8_t, 0),
Variable(type=dt.uint8_t, name="s"),
],
return_type=dt.void,
size=2,
))
acc.add(Eeprom)
func1 = acc.add(
Function(
name="testfunction",
arguments=[array1, Variable("a2", dt.uint8_t)],
return_type=uint16_t,
code=var1.set(var1 + D1),
variables=[(dt.uint8_t, "B", 1)],
))
# print(func1.arg1,func1.arg2)
func1.add_call(
var1.set(func1.arg2 * func1.var1),
func1.arg1[var1].set(10),
func1.arg1[2].set(var1 % 3),
((var1 | (D1 & var1)) ^ D1 + ~var1) >> 3,
)
acc.setup.add_call(
func1(var1, D1),
var1.set((var1 + D1) * 10),
var1.set(var1 + (D1 * 10)),
class SerialClass(ArduinoClass):
_tempvar_T = Variable("var", T)
class_name = "Serial"
begin = Function("begin", Variable("var", uint32_t))
end = Function("end")
read = Function("read", return_type=int16_t)
peek = Function("peek", return_type=int16_t)
flush = Function("flush")
print = Function("print", _tempvar_T)
print_format = Function("print", [_tempvar_T, Variable("format", uint8_t)])
println = Function("println", _tempvar_T)
println_format = Function("println", [_tempvar_T, Variable("format", uint8_t)])
write = Function("write", Variable("var", uint16_t))
write_buf = Function(
"write", [Array("buffer", uint8_t), Variable("length", uint16_t)]
)
available = Function("available", return_type=int16_t)
readString = Function("readString", return_type=String)
class ArduinoBaseClass(ArduinoClass):
# Digital I/O
INPUT = Variable("INPUT", obscurable=False)
OUTPUT = Variable("OUTPUT", obscurable=False)
INPUT_PULLUP = Variable("INPUT_PULLUP", obscurable=False)
EXTERNAL = Variable("EXTERNAL", obscurable=False)
LOW = Variable("LOW", obscurable=False)
HIGH = Variable("HIGH", obscurable=False)
true = Variable("true", obscurable=False)
false = Variable("false", obscurable=False)
digitalRead = Function("digitalRead", [(uint8_t, "pin")], uint8_t)
digitalWrite = Function("digitalWrite", [(uint8_t, "pin"), (uint8_t, "value")])
pinMode = Function("pinMode", [(uint8_t, "pin"), (uint8_t, "mode")])
analogRead = Function("analogRead", [(uint8_t, "pin")], uint16_t)
analogWrite = Function("analogWrite", [(uint8_t, "pin"), (uint8_t, "value")])
analogReference = Function("analogReference", [(uint8_t, "pin")])
random = Function("random", arguments=[], return_type=uint16_t)
randomSeed = Function(name="randomSeed", arguments=[(uint32_t, "seed")])
memcpy = Function(
name="memcpy",
arguments=[
(uint8_t_pointer, "dest"),
(uint8_t_pointer, "src"),
(uint8_t, "size"),
],
)
millis = Function(return_type=uint32_t, name="millis")
micros = Function(return_type=uint32_t, name="micros")
max = Function(
return_type=uint32_t,
name="max",
arguments=[(uint32_t, "val1"), (uint32_t, "val2")],
)
min = Function(
return_type=uint32_t,
name="min",
arguments=[(uint32_t, "val1"), (uint32_t, "val2")],
)
delay = Function(name="delay", arguments=[(uint32_t, "millis")])
delayMicroseconds = Function(
name="delayMicroseconds", arguments=[(uint32_t, "micros")]
)
sizeof = Function(name="sizeof", arguments=[(uint32_t, "var")])
map = Function(
return_type=uint32_t,
name="map",
arguments=[
(uint32_t, "value"),
(uint32_t, "fromLow"),
(uint32_t, "fromHigh"),
(uint32_t, "toLow"),
(uint32_t, "toHigh"),
],
)
def __call__(self, *code):
inner_code = Function(code=code).inner_code
return super().__call__(inner_code)
def __call__(self, condition, code=None):
inner_code = Function(code=code).inner_code
condition = condition.inline
return super().__call__(condition, inner_code)
def __init__(
self,
# for ArduinoVariable
board,
name,
arduino_data_type=None,
default=None,
# for module_variable
html_input=None,
save=None,
getter=None,
setter=None,
minimum=None,
maximum=None,
is_data_point=None,
allowed_values=None,
arduino_getter=None,
arduino_setter=None,
eeprom=None,
changeable=None,
add_to_code=None,
html_attributes=None,
):
# defaults
if arduino_data_type is None:
arduino_data_type = arduino_data_types.uint8_t
if save is None:
save = True
if is_data_point is None:
is_data_point = False
if eeprom is None:
eeprom = False
if add_to_code is None:
add_to_code = True
ACCArdVar.__init__(self,
type=arduino_data_type,
value=default,
name=name)
# self.add_to_code = add_to_code
if is_data_point and setter is False:
setter = None
changeable = False
if eeprom:
save = False
self.add_to_code = add_to_code
if isinstance(allowed_values, ArduinoEnum):
allowed_values = {
key: val[1]
for key, val in allowed_values.possibilities.items()
}
ModuleVariable.__init__(
self,
name=self.name,
python_type=self.type.python_type,
board=board,
html_input=html_input,
save=save,
getter=getter,
setter=setter,
default=default,
minimum=minimum,
maximum=maximum,
is_data_point=is_data_point,
allowed_values=allowed_values,
nullable=False,
changeable=changeable
if changeable is not None else arduino_setter != False,
html_attributes=html_attributes,
)
self.eeprom = eeprom
from arduino_controller.basicboard.board import (
COMMAND_FUNCTION_COMMUNICATION_ARGUMENTS, )
self.arduino_setter = (None if arduino_setter is False else Function(
arguments=COMMAND_FUNCTION_COMMUNICATION_ARGUMENTS,
name="set_{}".format(self),
code=self.generate_arduino_setter()
if arduino_setter is None else arduino_setter,
))
self.arduino_getter = (None if arduino_getter is False else
self.generate_arduino_getter(arduino_getter))