Problems runnning tflite Hello World example on Arduino

Dear all,

I am trying to compile the Hello World example sketch included in the Tensorflow Lite library which can be installed within the Arduino IDE. I experienced some problems.

  1. On the first try it gave me an error, saying that a cmsis_gcc.h was missing in some directory. I added this file manually from the ARM github.

  2. After this another error occured. This seems to do with a missing bracket “}”. The last “if()” statement seems to be missing the brackets {}. If I improve on this syntax error, the compiler will still give the error about “}” or just crash. It does not matter how many "}"s I add, it will still give this error.

Is this a well known problem? I am not posting the code here since it is simply the built-in HelloWorld example.

For anybody who can comment on this, you have my gratitude!


Hi @Owen_Huisman

Can you share the link of this Hello World example?

Hello George,

This is the link to the github page of this example.

For some reason this page does not contain the actual .ino file required to run the code within the Arduino IDE. I will post this (the original version with faulty syntax) below:
As I mentioned above the example is included in the Tensorflow Lite Arduino library.

/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.

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

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
See the License for the specific language governing permissions and
limitations under the License.

#include <TensorFlowLite.h>

#include “main_functions.h”

#include “tensorflow/lite/micro/all_ops_resolver.h”
#include “constants.h”
#include “model.h”
#include “output_handler.h”
#include “tensorflow/lite/micro/micro_error_reporter.h”
#include “tensorflow/lite/micro/micro_interpreter.h”
#include “tensorflow/lite/schema/schema_generated.h”
#include “tensorflow/lite/version.h”

// Globals, used for compatibility with Arduino-style sketches.
namespace {
tflite::ErrorReporter* error_reporter = nullptr;
const tflite::Model* model = nullptr;
tflite::MicroInterpreter* interpreter = nullptr;
TfLiteTensor* input = nullptr;
TfLiteTensor* output = nullptr;
int inference_count = 0;

constexpr int kTensorArenaSize = 2000;
uint8_t tensor_arena[kTensorArenaSize];
} // namespace

// The name of this function is important for Arduino compatibility.
void setup() {
// Set up logging. Google style is to avoid globals or statics because of
// lifetime uncertainty, but since this has a trivial destructor it’s okay.
// NOLINTNEXTLINE(runtime-global-variables)
static tflite::MicroErrorReporter micro_error_reporter;
error_reporter = &micro_error_reporter;

// Map the model into a usable data structure. This doesn’t involve any
// copying or parsing, it’s a very lightweight operation.
model = tflite::GetModel(g_model);
if (model->version() != TFLITE_SCHEMA_VERSION) {
"Model provided is schema version %d not equal "
“to supported version %d.”,
model->version(), TFLITE_SCHEMA_VERSION);

// This pulls in all the operation implementations we need.
// NOLINTNEXTLINE(runtime-global-variables)
static tflite::AllOpsResolver resolver;

// Build an interpreter to run the model with.
static tflite::MicroInterpreter static_interpreter(
model, resolver, tensor_arena, kTensorArenaSize, error_reporter);
interpreter = &static_interpreter;

// Allocate memory from the tensor_arena for the model’s tensors.
TfLiteStatus allocate_status = interpreter->AllocateTensors();
if (allocate_status != kTfLiteOk) {
TF_LITE_REPORT_ERROR(error_reporter, “AllocateTensors() failed”);

// Obtain pointers to the model’s input and output tensors.
input = interpreter->input(0);
output = interpreter->output(0);

// Keep track of how many inferences we have performed.
inference_count = 0;

// The name of this function is important for Arduino compatibility.
void loop() {
// Calculate an x value to feed into the model. We compare the current
// inference_count to the number of inferences per cycle to determine
// our position within the range of possible x values the model was
// trained on, and use this to calculate a value.
float position = static_cast(inference_count) /
float x = position * kXrange;

// Quantize the input from floating-point to integer
int8_t x_quantized = x / input->params.scale + input->params.zero_point;
// Place the quantized input in the model’s input tensor
input->data.int8[0] = x_quantized;

// Run inference, and report any error
TfLiteStatus invoke_status = interpreter->Invoke();
if (invoke_status != kTfLiteOk) {
TF_LITE_REPORT_ERROR(error_reporter, “Invoke failed on x: %f\n”,

// Obtain the quantized output from model’s output tensor
int8_t y_quantized = output->data.int8[0];
// Dequantize the output from integer to floating-point
float y = (y_quantized - output->params.zero_point) * output->params.scale;

// Output the results. A custom HandleOutput function can be implemented
// for each supported hardware target.
HandleOutput(error_reporter, x, y);

// Increment the inference_counter, and reset it if we have reached
// the total number per cycle
inference_count += 1;
if (inference_count >= kInferencesPerCycle) inference_count = 0;

Best regards,

if statement do not need {} if you have only one instruction

for exemple
b++; //only do if a>0
d++;//do always

chek your #include if a #include have a { not close the compilator detect error in the “main” file.