Skip to main content

​
Overview

The Temperature Plants endpoint allows you to submit temperature readings from sensors monitoring plant environments. This endpoint tracks ambient temperature in plant growing areas.

​
Endpoint

POST /api/temperatura-plantas/

​
Model Structure

The TemperaturaPlantas model extends the base Sensor model: 
class TemperaturaPlantas(Sensor):
    temperatura = models.FloatField(max_length=200, default='00')
    unidade_medida = models.CharField(max_length=50, default='graus')
Source: models.py:13-17

​
ViewSet Implementation

class TemperaturaPlantasViewset(viewsets.ViewSet):
    permission_classes = (IsAuthenticated,)
    
    def create(self, request):
        serializer = TemperaturaPlantasSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        the_response = TemperaturaPlantasSerializer(serializer.save())
        return Response(the_response.data, status=status.HTTP_201_CREATED)
Source: views.py:124-130

​
Authentication

This endpoint requires authentication. Include your API token in the Authorization header.
Authorization: Token 2d75140c068049278f9cb7d39b1a20f05aecdc56
See Authentication for details.

​
Request Parameters

​
nome
string
required
Sensor name identifierExample: "Temperatura"
​
tipo
string
required
Type of sensor locationExample: "Plantas"
​
grupo
string
required
Sensor group classificationExample: "Grupo P"
​
temperatura
float
required
Temperature reading from the sensorExample: 22.8
​
unidade_medida
string
required
Unit of measurement for temperatureDefault: "graus"Example: "graus"

​
Response Fields

​
id
integer
Auto-generated unique identifier for the record
​
nome
string
Sensor name as provided in request
​
tipo
string
Sensor type as provided in request
​
grupo
string
Sensor group as provided in request
​
temperatura
float
Temperature value submitted
​
unidade_medida
string
Unit of measurement for the temperature
​
data_criacao
datetime
Timestamp when the record was created (auto-generated)

​
Example Request

curl -X POST http://127.0.0.1:8000/api/temperatura-plantas/ \
  -H "Authorization: Token 2d75140c068049278f9cb7d39b1a20f05aecdc56" \
  -H "Content-Type: application/json" \
  -d '{
    "nome": "Temperatura",
    "tipo": "Plantas",
    "grupo": "Grupo P",
    "temperatura": "22.8",
    "unidade_medida": "graus"
  }'

​
Example Response

Status Code: 201 Created 
{
  "id": 15,
  "nome": "Temperatura",
  "tipo": "Plantas",
  "grupo": "Grupo P",
  "temperatura": 22.8,
  "unidade_medida": "graus",
  "data_criacao": "2026-03-11T10:30:45.123456Z"
}

​
Error Responses

​
Missing Authentication Token

Status Code: 401 Unauthorized 
{
  "detail": "Authentication credentials were not provided."
}

​
Invalid Token

Status Code: 401 Unauthorized 
{
  "detail": "Invalid token."
}

​
Missing Required Fields

Status Code: 400 Bad Request 
{
  "temperatura": [
    "This field is required."
  ],
  "nome": [
    "This field is required."
  ]
}

​
Invalid Data Type

Status Code: 400 Bad Request 
{
  "temperatura": [
    "A valid number is required."
  ]
}

​
MQTT Integration Example

Example from the Raspberry Pi MQTT client: 
# From mqtt-django.py:22-34
if message.topic == topic_temp:
    nome = "Temperatura"
    tipo = "Plantas"
    grupo = "Grupo P"
    temperatura = str(message.payload.decode("utf-8"))
    unidade_medida = "graus"
    
    temperatura_plantas = {
        'nome': nome,
        'tipo': tipo,
        'grupo': grupo,
        'temperatura': temperatura,
        'unidade_medida': unidade_medida
    }
    
    headers = {'Authorization': 'Token 2d75140c068049278f9cb7d39b1a20f05aecdc56'}
    url_temperatura_plantas = "http://127.0.0.1:8000/api/temperatura-plantas/"
    send_temperatura_plantas = requests.post(
        url_temperatura_plantas,
        headers=headers,
        json=temperatura_plantas
    )

​
Serializer Details

The endpoint uses TemperaturaPlantasSerializer with depth=1 to include related object details: 
class TemperaturaPlantasSerializer(serializers.ModelSerializer):
    class Meta:
        model = TemperaturaPlantas
        fields = '__all__'
        depth = 1

    def create(self, validated_data):
        temperatura = TemperaturaPlantas.objects.create(**validated_data)
        temperatura.save()
        return temperatura
Source: serializers.py:41-50

​
Use Cases

  • Monitor plant environment temperature in real-time
  • Track temperature fluctuations in growing areas
  • Trigger alerts when temperature is outside optimal range
  • Historical temperature data analysis for plant health
  • IoT device integration via MQTT
  • Greenhouse climate control

​
Best Practices

  1. Regular Readings: Submit temperature readings at consistent intervals (e.g., every 5-10 minutes)
  2. Valid Ranges: Ensure temperature values are within reasonable ranges for plant environments (typically 15-35°C)
  3. Error Handling: Implement retry logic for failed submissions
  4. Data Validation: Validate sensor readings before submission to avoid spurious data

Build docs developers (and LLMs) love

Get started for freeTalk to us