Over the past twenty years, CAD software has evolved mainly in terms of graphics processing quality, task automation, and the ability to perform complex calculations. However, these results still need to be validated through traditional methods such as using formulas and solving equations numerically or analytically.

Despite these advances, the core functions of computer-aided design have not changed—and should not. The construction of basic geometric shapes, such as squares or circles, remains independent of color or line type. Similarly, finishing operations in 3D models, such as fillets or chamfers, are performed much as they were decades ago.

Another major change lies in the licensing model. Today, most CAD programs are no longer sold under perpetual licenses but through annual subscriptions that often exceed USD 2,000 per user. This is a significant cost for companies employing several designers, which must allocate a considerable portion of their budget to software licenses rather than hiring more personnel or investing in other areas.

It is noteworthy that, despite the existence of free, open-source, and high-quality software capable of delivering equivalent results to commercial programs, its adoption remains limited. One possible reason is that open-source projects depend on volunteer contributions, creating uncertainty about long-term continuity. In contrast, proprietary software ensures its sustainability through its own economic incentives.

Another reason is the learning curve: open-source programs often lack formal documentation and support. Nevertheless, wouldn’t it be worthwhile to invest in self-training or low-cost instruction? Technological independence alone should be a sufficient reason to begin the transition toward open-source software.

Finally, many universities teach using academic versions of commercial software that cannot be legally used in professional practice. If educational institutions and professionals were to promote the use of open-source tools, the market could eventually shift: open software would become the standard, and proprietary software the exception.

Cite this as: Tablet School, "The Evolution of CAD Software and the Case for Open-Source Alternatives", Tablet School Journal Nr. 22 Vol 1 Oct 2025, ISSN: 2661-6505.

Lead-acid batteries operate through a reversible chemical reaction between lead dioxide (PbO₂), sponge lead (Pb), and sulfuric acid (H₂SO₄). They are widely used due to their low initial cost and ability to deliver high surge currents. Lead-acid batteries are among the most cost-effective energy storage solutions and can handle high currents, making them suitable for applications requiring short bursts of power. With over 150 years of development, this technology is well-understood and extensively deployed. However, lead-acid batteries have a relatively low specific energy, typically around 30–50 Wh/kg, limiting their suitability for weight- or space-sensitive applications. Their cycle life is also limited, generally ranging from 300 to 500 cycles under deep discharge conditions, and improper disposal can pose environmental hazards due to lead content. Typical use cases include automotive starter batteries, uninterruptible power supplies (UPS), and off-grid renewable energy systems. Charging times are approximately 5–8 hours to reach 70% capacity using constant-current charging, followed by an additional 7–10 hours to reach full charge, while discharge times vary with load but usually fall between 5 and 20 hours at a 0.05C to 0.2C rate.

Lithium-ion batteries, in contrast, utilize intercalation compounds in both electrodes, providing higher specific energy, greater efficiency, and longer lifespan. They are the dominant technology in portable electronics and electric vehicles. Lithium-ion batteries offer specific energy between 150 and 260 Wh/kg, enabling lighter and more compact designs, and they can typically endure 2,000 to 10,000 cycles depending on depth of discharge and operating conditions. Their round-trip efficiency ranges from 92% to 98%, making them ideal for applications requiring frequent cycling. The main disadvantages include higher initial cost relative to lead-acid batteries, the need for a battery management system (BMS) to ensure safe operation, and environmental and ethical concerns related to lithium and other materials extraction. They are commonly used in electric vehicles, portable electronics, and grid energy storage systems. Charging times for lithium-ion batteries generally range from 2 to 4 hours depending on charger and capacity, while typical discharge times are 1 to 2 hours at a 1C rate, although this can vary with application and load.

Nickel-metal hydride (NiMH) batteries use a hydrogen-absorbing alloy as the negative electrode and nickel oxyhydroxide (NiOOH) as the positive electrode, offering a balance between performance, safety, and environmental impact. NiMH batteries are less prone to thermal runaway than lithium-ion batteries and provide moderate specific energy, typically between 60 and 120 Wh/kg, making them suitable for many applications. They are environmentally friendly, containing no toxic heavy metals such as cadmium. However, NiMH batteries are less energy-dense than lithium-ion batteries, resulting in larger and heavier designs, and they have higher self-discharge rates, requiring more frequent charging. Their limited fast-charging capability means that charging too quickly can reduce cycle life. Typical applications include hybrid electric vehicles, power tools, and consumer electronics. Standard charging times are 12–16 hours, although fast charging can reduce this time but may impact battery longevity, while discharge times generally range from 5 to 20 hours at a 0.05C to 0.2C rate, similar to lead-acid batteries.

Lead-acid, lithium-ion, and NiMH batteries each offer distinct trade-offs in terms of cost, energy density, cycle life, safety, and environmental impact. Lead-acid batteries remain a reliable and affordable choice for applications with moderate energy requirements and high surge demands, lithium-ion batteries excel in high-energy, compact, and frequently cycled systems, and NiMH batteries provide a safe, environmentally friendly solution for moderate-energy applications where robustness is essential.

Sources:
1. Battery University, “BU-403: Charging Lead Acid”, https://batteryuniversity.com/article/bu-403-charging-lead-acid%C2%A0 , accessed Oct. 2025.

2. Battery University, “BU-409: Charging Lithium-ion”, https://batteryuniversity.com/article/bu-409-charging-lithium-ion%C2%A0 , accessed Oct. 2025.

3. Power Stream, “Lead Acid Battery Charging Basics and Chargers”, https://www.powerstream.com/SLA.htm , accessed Oct. 2025.

4. ACETECH, “How Long to Charge a Lithium Battery for the First Time: Expert Guide”, https://www.acebattery.com/blogs/how-long-to-charge-a-lithium-battery-for-the-first-time-expert-guide , accessed Oct. 2025.

5. Energizer, “NiMH Battery Chargers”, https://data.energizer.com/pdfs/charger_appman.pdf , accessed Oct. 2025.

6. Power Stream, “NiMH Battery Charging Basics”, https://www.powerstream.com/NiMH.htm , accessed Oct. 2025.

7. Energizer, “Nickel Metal Hydride (NiMH)“, https://data.energizer.com/pdfs/nickelmetalhydride_appman.pdf , accessed Oct. 2025.

Cite this as: Tablet School, "Comparative Analysis of Lead-Acid, Lithium-Ion, and Nickel-Metal Hydride Batteries", Tablet School Journal Nr. 22 Vol 1 Oct 2025, ISSN: 2661-6505.

In the fascinating world of differential and integral calculus, every mathematical problem presents us with a fundamental crossroads: to choose the elegance of analytical solutions or the flexibility of numerical methods. This decision, which may seem purely theoretical in academic environments, becomes a critical factor when we move to the practical realm of microcontrollers, where every byte of memory and every processing cycle are precious resources that must be managed wisely. Analytical solutions represent the pinnacle of mathematical precision, offering exact answers through formal derivations that follow the rules of calculus. Imagine solving dy/dx = -2x and obtaining the beauty of y = -x² + 1 as an exact solution. This approach provides not only perfect results but also a deep understanding of the system's behavior, unparalleled computational efficiency, and the ability to adjust parameters easily. However, its application encounters limits when we face nonlinear equations or complex boundary conditions that challenge conventional analytical techniques, in addition to requiring advanced mathematical knowledge that can take considerable time to develop. Faced with these limitations, numerical methods emerge as a powerful alternative, capable of addressing virtually any differential equation through algorithms like Euler or Runge-Kutta that build solutions step by step. This approach democratizes access to solving complex problems, offering automation, computational speed, and adaptability. But this power comes at a price: it introduces approximation errors, can suffer from numerical instability, consumes significant computational resources, and presents challenges in precision control that should not be underestimated. The materialization of these solutions leads us to two prominent tools: Python, with its specialized libraries like SciPy and NumPy, has become the standard for scientific computing, offering advanced algorithms and precision control, although it requires programming competence. Excel, on the other hand, provides immediate access through its intuitive visual interface, allowing rapid prototyping without the need for programming, albeit with limitations in precision and scalability. But it is when we enter the realm of microcontrollers that the choice becomes most critical. These devices, with their memory measured in kilobytes, low-power processors, and frequent lack of floating-point units, demand optimized solutions where analytical solutions shine brightly. The implementation of a solution like y = -x² + 1 reduces to a few arithmetic operations, consuming minimal resources and offering predictable execution times, essential for real-time control applications. Numerical methods, with their iterations and error accumulation, represent a computational burden that these systems cannot afford. However, there are scenarios where numerical methods become necessary: when we face equations with no known analytical solution, when the precision of simple methods like improved Euler is sufficient, when we have adequate computational resources, or when response times are not critical. The wisest strategy combines the best of both worlds: using Python for the initial exploration and validation of solutions, and then implementing optimized analytical versions on the microcontroller. This approach guarantees the best compromise between precision, efficiency, and resource consumption, delivering robust and reliable embedded systems. In the end, the choice between analysis and numerical approximation defines not only the system's performance but the very viability of the project in resource-limited environments, reminding us that in the world of microcontrollers, mathematical elegance and computational efficiency are two sides of the same coin.

Cite this as: Tablet School, "Analytical vs Numerical Solutions: Optimizing Calculus for Microcontroller Implementation", Tablet School Journal Nr. 22 Vol 1 Oct 2025, ISSN: 2661-6505.

import numpy as np

import matplotlib.pyplot as plt

# Simulation parameters

distance_km = np.linspace(0, 100, 100)  # distance from 0 to 100 km

electric_efficiency = 15  # kWh per 100 km

gasoline_efficiency = 7  # liters per 100 km

energy_density_gasoline = 8.9  # kWh per liter

co2_per_liter_gasoline = 2.31  # kg CO₂ per liter

co2_per_kWh_electric = 0.25  # kg CO₂ per kWh (depends on electricity source)

# Simulate variations in driving conditions

np.random.seed(42)

electric_variation = np.random.normal(1.0, 0.05, len(distance_km))

gasoline_variation = np.random.normal(1.0, 0.07, len(distance_km))

# Compute cumulative energy consumption

electric_consumption = (electric_efficiency / 100) * distance_km * electric_variation

gasoline_consumption_liters = (gasoline_efficiency / 100) * distance_km * gasoline_variation

gasoline_consumption_kWh = gasoline_consumption_liters * energy_density_gasoline

# Compute emissions

co2_electric = electric_consumption * co2_per_kWh_electric

co2_gasoline = gasoline_consumption_liters * co2_per_liter_gasoline

# Plot energy consumption comparison

plt.figure(figsize=(10, 6))

plt.plot(distance_km, electric_consumption, label='Electric Car (kWh)', linewidth=2)

plt.plot(distance_km, gasoline_consumption_kWh, label='Gasoline Car (kWh equivalent)', linewidth=2)

plt.xlabel('Distance (km)')

plt.ylabel('Energy Consumption (kWh)')

plt.title('Energy Consumption Comparison: Electric vs Gasoline Car')

plt.legend()

plt.grid(True)

plt.show()

# Plot CO2 emissions

plt.figure(figsize=(10, 6))

plt.plot(distance_km, co2_electric, label='Electric Car (kg CO₂)', linewidth=2)

plt.plot(distance_km, co2_gasoline, label='Gasoline Car (kg CO₂)', linewidth=2)

plt.xlabel('Distance (km)')

plt.ylabel('Cumulative CO₂ Emissions (kg)')

plt.title('CO₂ Emissions Comparison: Electric vs Gasoline Car')

plt.legend()

plt.grid(True)

plt.show()

# Print summary

print(f"Total Electric Energy Consumption: {electric_consumption[-1]:.2f} kWh")

print(f"Total Gasoline Energy Consumption: {gasoline_consumption_kWh[-1]:.2f} kWh (equivalent)")

print(f"Total CO₂ (Electric): {co2_electric[-1]:.2f} kg")

print(f"Total CO₂ (Gasoline): {co2_gasoline[-1]:.2f} kg")

Cite this as: Tablet School, "Test the code in Python CO₂ Emissions Comparison: Electric vs Gasoline Car", Tablet School Journal Nr. 22 Vol 1 Oct 2025, ISSN: 2661-6505.

import numpy as np

import matplotlib.pyplot as plt

# === Electric Car Parameters ===

battery_capacity_kWh = 60.0        # Battery size in kWh

consumption_kWh_per_100km = 15.0   # Average consumption in kWh/100 km

reserve_percentage = 10            # % of battery reserved (not usable)

# === Derived Values ===

usable_battery = battery_capacity_kWh * (1 - reserve_percentage / 100)

consumption_kWh_per_km = consumption_kWh_per_100km / 100

# === Range Calculation ===

base_range_km = usable_battery / consumption_kWh_per_km

print(f"Usable Battery Energy: {usable_battery:.2f} kWh")

print(f"Average Consumption: {consumption_kWh_per_100km:.2f} kWh/100km")

print(f"Estimated Range: {base_range_km:.1f} km")

# === Simulate Range Variation (due to driving conditions) ===

np.random.seed(0)

speed_factor = np.linspace(60, 130, 50)  # km/h

efficiency_factor = 1 + 0.0025 * (speed_factor - 90) ** 2 / 100  # worse efficiency at higher/lower speeds

range_km = base_range_km / efficiency_factor

# === Plot ===

plt.figure(figsize=(10, 6))

plt.plot(speed_factor, range_km, linewidth=2)

plt.title("Estimated Electric Vehicle Range vs Speed")

plt.xlabel("Average Speed (km/h)")

plt.ylabel("Range (km)")

plt.grid(True)

plt.show()

Cite this as: Tablet School, "Estimated Electric Vehicle Range vs Speed", Tablet School Journal Nr. 22 Vol 1 Oct 2025, ISSN: 2661-6505.