Eluan Dan (26 results)

PAP. Condition: New. New Book. Shipped from UK. Established seller since 2000.

PAP. Condition: New. New Book. Shipped from UK. Established seller since 2000.

PAP. Condition: New. New Book. Shipped from UK. Established seller since 2000.

Taschenbuch. Condition: Neu. Neuware.

Taschenbuch. Condition: Neu. Neuware.

Taschenbuch. Condition: Neu. Neuware.

Taschenbuch. Condition: Neu. Neuware.

Taschenbuch. Condition: Neu. Neuware.

Taschenbuch. Condition: Neu. Neuware.

Condition: New. Print on Demand.

Condition: New. Print on Demand.

Condition: New. Print on Demand.

Condition: New. Print on Demand.

Condition: New. Print on Demand.

Condition: New. Print on Demand.

Condition: New. Print on Demand.

Condition: New. Print on Demand.

Paperback. Condition: new. Paperback. What separates an embedded engineer who ships reliable firmware from one who spends nights chasing intermittent crashes?It is not how fast they can write code. It is whether they think in patterns. Most engineers who adopt an RTOS get the primitives - tasks, queues, semaphores, timers - but never receive the architectural blueprint for assembling them into software that is correct, maintainable, and timing-safe under real operating conditions.Your system still has priority inversions that only surface under load, stack overflows that appear in the field but never in the lab, timer callbacks that silently stall the entire scheduler, and a watchdog that proves nothing because it is kicked from a SysTick ISR. These are not beginner mistakes. They are the exact bugs that experienced engineers introduce when they apply RTOS primitives without a structural framework.Real Time Operating Systems Code Patterns gives you that framework. Sixteen chapters of battle-tested, production-grade patterns - from task architecture and scheduling strategy through multi-core synchronization, power management, and field-proof fault recovery - each explained with the mechanics of why the pattern works, not just how to paste it in. Every pattern comes with annotated C code targeting the FreeRTOS API and three graduated exercises to cement what you have learned.Inside this book you will find: Master task design: periodic, event-driven, gatekeeper, and state machine patterns that eliminate shared-state bugs plaguing monolithic superloop migrationsUnderstand scheduling rigorously: Rate Monotonic Analysis, Earliest Deadline First trade-offs, and aperiodic server patterns grounded in real WCET measurementsSynchronize without fear: mutexes with Priority Inheritance, Priority Ceiling Protocol emulation, spinlocks on dual-core targets, and event group barriers - with every pitfall named and solvedBuild resilient systems: multi-task liveness watchdogs, five-level fault escalation ladders, task restart supervisors, and HardFault capture that survives a field resetOptimize with data: windowed CPU profiling, context switch overhead measurement, cache-friendly struct layouts for Cortex-M7, and response-time analysis that turns schedulability into a verified claimScale and port cleanly: OSAL and BSP abstraction layers, FreeRTOS-to-Zephyr migration patterns, dual-bank OTA bootloaders, and multi-core SMP versus AMP architectural decisions for ESP32 and RP2040Written for engineers who already build embedded systems and want to build them better, this book bridges the gap between RTOS documentation and production firmware. Every pattern is derived from real failure modes in shipping products. The RTOS platform comparison appendix covering FreeRTOS, Zephyr, ThreadX, and RT-Thread, the 94-term glossary, and the three-page pattern quick-reference card ensure this is a resource you will return to throughout your engineering career - not just for your first RTOS project.Your firmware deserves an architecture it can grow into - grab your copy today and start building embedded systems that ship, hold up in the field, and scale with your product. This item is printed on demand. Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.

Paperback. Condition: new. Paperback. What if you could master real-time 3D graphics from the ground up - writing the same kinds of rendering systems that power professional game engines - using nothing but C++, SDL2, and OpenGL?Most programmers who want to build their own games hit the same wall. They follow beginner tutorials that produce working results but never explain why the code works. They reach for high-level game engines and find that the most important details are hidden behind layers of abstraction they are never meant to touch. When they finally want to understand what a vertex buffer object is, how a shader pipeline actually executes on the GPU, or why a game loop must be structured in a specific way, they end up buried in fragmented documentation and outdated examples with no clear path forward. The gap between knowing some C++ and truly building a real-time renderer feels impossible to close.SDL2 and OpenGL Game Development was written to close that gap completely. This book takes you step by step through everything you need - from understanding the graphics hardware to writing your own GLSL shaders, managing real-time game state, handling audio and input, and shipping a fully playable game - all without relying on a high-level engine. You will learn how SDL2 ties together windowing, input, and audio with the power of the OpenGL rendering pipeline, and you will build every system from scratch so you genuinely understand the code you write. By the final chapter, you will have more than a finished game. You will have the deep, transferable knowledge of how real-time rendering actually works.Here is what you will find inside this book: Set up your full development environment with SDL2, OpenGL, GLEW, and CMake across Windows, Linux, and macOS with clear, step-by-step instructionsMaster the modern OpenGL graphics pipeline - understand VAOs, VBOs, index buffers, and write GLSL vertex and fragment shaders from first principlesBuild both 2D and 3D rendering systems from scratch, including sprite batching, perspective cameras, and the Model-View-Projection matrixImplement lighting, shadow mapping, and post-processing effects using custom shaders that run directly on the GPUDesign a complete, playable game with collision detection, entity-component architecture, audio mixing, and smooth frame-rate independent performanceThis book does not protect you from complexity - it walks you through it. Every chapter delivers real code and real explanations designed for programmers who want to understand the full stack, from the raw SDL2 context to the rendered frame on screen. Whether you are building games for fun, preparing for a career in graphics programming, or simply determined to stop using tools you do not fully understand, this is the guide you have been looking for.Stop borrowing someone else's engine - grab your copy today and build every system yourself, from the first vertex to the final frame. This item is printed on demand. Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.

Paperback. Condition: new. Paperback. Do you actually know what happens inside your microcontroller - or are you just trusting a library to figure it out?Most embedded developers rely on abstraction layers, pre-written drivers, and Arduino-style wrappers to get things done. Those tools have their place, but they also hide what is really happening beneath the surface. When something breaks at 3 a.m. in a shipped product, when your PWM signal glitches under load, when your UART drops bytes at high baud rates - you need more than a library call to fix it. You need to understand the hardware.AVR Register Level Programming is the book that takes you beneath the abstraction. Written for engineers, students, and serious makers who are ready to stop being passengers on their own hardware, this guide walks you through every key peripheral of the AVR architecture using direct register access, real C code, and zero hand-waving.This is not theory. This is the real way embedded systems work.Inside, you will discover: How to configure GPIO, timers, UART, SPI, I2C, and ADC directly through hardware registers - no external libraries requiredThe complete timer system - Normal mode, CTC, Fast PWM, and Phase-Correct PWM - with full prescaler calculations and working waveform codePWM generation from scratch, including audio synthesis, DC motor speed control, and dead-band insertion for H-bridge protectionInterrupt-driven UART buffering using circular ring buffers and three interrupt vectors - transmit, receive, and data register emptyA complete bare-metal toolchain from scratch: avr-gcc, avrdude, and Makefiles - no IDE required, no hidden build stepsAppendices, quick-reference register tables, and a full embedded systems glossary built into the book for immediate on-the-job useEvery chapter is built around a single concept, explained from the datasheet up. You will learn how to read a register description, translate it into clean C code, and verify the result - building the kind of deep hardware intuition that separates confident firmware engineers from everyone else.Whether you are debugging a timing-sensitive driver, optimizing an IoT sensor node for ultra-low power, or simply tired of not understanding what your code is actually doing - this book gives you the foundation to work at the level where real control lives.No prior assembly experience required. Basic C knowledge and curiosity about how hardware actually works are all you need to get started.Stop depending on black-box libraries - own your hardware completely, and grab your copy today. This item is printed on demand. Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.

Paperback. Condition: new. Paperback. What separates a data scientist who truly understands their models from one who just runs them? The answer is probability.Most Python practitioners know how to call a function. Far fewer understand the mathematical reasoning behind it - why cross-entropy loss works, what a p-value actually measures, how Bayesian inference updates beliefs, or when the Central Limit Theorem applies and when it breaks down. Without that foundation, models become black boxes and results become unreliable guesses.Probability Theory with Python bridges that gap. This comprehensive guide teaches you to think probabilistically - to reason about uncertainty with precision, build models that honestly quantify what they do and do not know, and apply that reasoning to real data science problems from first principles.Inside this book, you will find: Master the foundations - from Kolmogorov's axioms and Bayes' theorem through conditional probability and combinatorics, building the mathematical vocabulary that every statistical method depends onUnderstand every major distribution - discrete and continuous, with rigorous derivations, Python implementations using NumPy and SciPy, and practical guidance on when each distribution fits and when it doesn'tGo beyond point estimates - learn how to work with full probability distributions, propagate uncertainty correctly, compute posterior predictive intervals, and interpret results in a way that is honest and actionableSimulate the world with Monte Carlo methods - including variance reduction techniques and a production-quality simulation engine validated against analytical resultsApply probability to real systems - four complete capstone projects model spam detection with Naive Bayes, stock price risk with Geometric Brownian Motion, epidemic spread with the stochastic SIR model, and A/B testing with Bayesian inferenceDemystify machine learning theory - understand why cross-entropy loss and softmax work, what mutual information reveals about features, how Markov chains power PageRank, and why the normal distribution appears everywhereSpanning eighteen chapters, the book covers the Law of Large Numbers, the Central Limit Theorem, Markov chains, information theory, stochastic processes including Brownian motion and Ornstein-Uhlenbeck, Bayesian inference with PyMC, hypothesis testing, power analysis, and permutation-based simulation methods. Each chapter includes worked Python code, original diagrams, and three progressive exercises.Written for Python developers, data scientists, machine learning engineers, quantitative analysts, and researchers who want more than surface-level intuition - this book demands no prior probability background beyond high-school mathematics, but does not shy away from the formulas and rigorous derivations that make concepts genuinely understood rather than merely memorised.Every formula is implemented. Every theorem is simulated. Every concept is connected to the code you already write.Stop treating probability as an afterthought. Open this book, run the code, and start reasoning about uncertainty the way every serious practitioner should. Your models - and your results - will never look the same. This item is printed on demand. Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.

Paperback. Condition: new. Paperback. Are you building distributed storage systems that quietly fall apart under load - hot spots silently choking throughput, nodes drowning in uneven data, and rebalancing jobs that cost more than they save?Most engineers learn chunk management the hard way: by debugging a production cluster at 2 AM, watching data nodes tip into overload while others sit idle. The theory is buried in academic papers. The real implementation details are scattered across changelog entries and closed-source systems. What's missing is a single, coherent resource that takes you from first principles to production-ready implementation - covering not just what chunks are, but how to place, replicate, monitor, tune, and rebalance them at scale.Chunk Management and Balancing is the definitive technical guide for storage engineers, distributed systems developers, and infrastructure architects who need to design and operate chunk-based storage systems that perform reliably under pressure. Whether you're working with HDFS, GFS-inspired architectures, Ceph, or building your own chunk server from scratch, this book gives you the mental models, algorithms, and practical techniques to get it right.Inside, you will find: Deep architecture breakdowns of GFS, HDFS, and Ceph - covering chunk placement, master tracking, heartbeat protocols, and replica coordinationLoad rebalancing algorithms explained from theory to code - centralized, distributed, incremental, and bulk strategies with real migration cost analysisChunk size optimization frameworks that help you find the right balance between compression efficiency and access granularity for your specific workloadFault tolerance patterns for node failure detection, re-replication pipelines, split-brain prevention, and disaster recoveryCapacity management strategies to prevent storage deadlock, enforce tenant quotas, and implement hot/warm/cold tieringA hands-on final chapter walking you through building a minimal chunk server in Go - complete with a rebalancing daemon and failure simulation harnessThis book draws on real system design principles from production-grade distributed storage - the same concepts underlying the infrastructure that powers cloud platforms serving billions of users daily. Every chapter pairs conceptual depth with operational guidance so you can apply what you learn immediately.Stop guessing your way through chunk management - grab your copy and build storage systems that scale without breaking. This item is printed on demand. Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.

Paperback. Condition: new. Paperback. What separates a blinking LED from a deployed IoT device that runs reliably for years? The answer is almost always the same: a real-time operating system, used correctly.Most embedded developers hit a wall. They can write code that works on a bench - reading a sensor, toggling a pin, connecting to Wi-Fi. But when they try to combine three things at once, everything breaks. The Wi-Fi stack starves the sensor task. The button handler blocks everything else. The device crashes after six hours for no obvious reason. They patch it, and something else breaks. The problem isn't their code. It's the architecture. They're building concurrent systems with single-threaded thinking.Getting Started with ESP32 FreeRTOS is the book that closes that gap. Written specifically for the ESP32 and ESP-IDF v5.x, it teaches you to think in tasks, design with queues and semaphores, and build firmware that handles real-world complexity without falling apart. From your first xTaskCreate() call to a fully deployed multi-sensor IoT dashboard with Wi-Fi telemetry, BLE connectivity, and over-the-air updates - this book takes you the entire distance.Inside, you will learn how to: - Design multi-task firmware from scratch - understand task states, priorities, the dual-core scheduler, and how to pin tasks to the right core for maximum performance- Master every synchronisation primitive - queues, binary and counting semaphores, mutexes with priority inheritance, event groups, and task notifications, with clear guidance on when to use each one- Integrate hardware peripherals the right way - UART, SPI, and I2C communication with thread-safe driver patterns, GPIO interrupts with proper ISR-to-task deferred processing, and high-resolution timers- Build rock-solid wireless connectivity - connect to Wi-Fi with exponential backoff reconnection, expose sensor data over BLE using a GATT server, and POST telemetry to cloud dashboards over HTTPS- Debug and profile running firmware - decode panic backtraces with the IDF monitor, use GDB over JTAG to inspect every task simultaneously, measure CPU load with runtime statistics, and track stack usage before it causes crashes- Ship production-quality devices - implement OTA firmware updates with automatic rollback, harden your device with flash encryption and secure boot, and apply the field testing protocol that separates a reliable product from an expensive paperweightThe book culminates in a complete capstone project: a multi-sensor IoT dashboard that combines everything - BME280 and UV sensors over I2C, ADC-sampled light readings, a BLE GATT server, Wi-Fi HTTP telemetry, GPIO button handling, and a system health monitor - built using the same task architecture and design patterns used in professional IoT firmware today.Every chapter builds on the last. Every concept is grounded in working, production-quality code. No hand-waving, no oversimplified toy examples - just the real patterns that real embedded engineers use.Whether you are a hobbyist who has outgrown Arduino, a software developer making your first move into embedded systems, or a hardware engineer who wants to write firmware that scales, this book gives you the mental models, the tools, and the confidence to build things that actually work in the field.Stop hacking around concurrency bugs and start engineering firmware that runs forever - pick up your copy today and write your first production-ready IoT application. This item is printed on demand. Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.

Paperback. Condition: new. Paperback. Most statistics books make you feel like you need a PhD just to read the introduction. This one does the opposite.If you have ever stared at a p-value and wondered what it actually means, watched colleagues build probabilistic models and felt left out, or suspected that traditional statistics was leaving something important on the table - this book was written for you.Bayesian inference powers spam filters, clinical trials, A/B testing systems, and fraud detection models running at scale every single day. With Python libraries like PyMC 5 and ArviZ 1.0, it has never been more accessible to practitioners who can code but were never formally trained in statistics.This book teaches you Bayesian inference the way it should be taught - through clear explanations, runnable Python code, and real-world problems you can relate to immediately.No PhD required. No advanced calculus. No impenetrable equation blocks.Here is what you will master inside: How Bayesian thinking differs from traditional statistics and why it produces more honest, actionable resultsBayes' theorem explained in plain English, visualized in Python, and applied to real problems including medical testing and spam classificationA complete Bayesian Python environment setup using PyMC 5, ArviZ 1.0, and JupyterLab - with a full troubleshooting guideThe probability distributions that appear in almost every real Bayesian model, with code and clear guidance on when to use each oneHow to build models in PyMC from scratch, defining priors, likelihoods, and posteriors in readable Python you will understand line by lineMCMC sampling demystified through a from-scratch implementation you build yourselfModel diagnostics using trace plots, R-hat, effective sample size, and divergence checks - and how to fix what is brokenBayesian linear regression, A/B testing, hierarchical models, and classification - all with full code and real-world scenariosThree complete capstone projects covering customer churn prediction, time series forecasting, and clinical trial analysisEvery chapter closes with a hands-on mini-project that gives you something concrete to build, run, and keep.Whether you are a Python developer curious about probabilistic programming, a data analyst tired of significance thresholds, a bootcamp graduate who never got a proper statistics education, or a professional in healthcare, finance, or marketing who works with uncertain data every day - this book gives you the foundation to reason clearly and model honestly.If you are ready to build models that tell the truth about what they know and what they do not, and make decisions from data with genuine statistical integrity - your next step starts here.Grab your copy and start thinking like a Bayesian today. This item is printed on demand. Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.

Paperback. Condition: new. Paperback. What if every embedded bug you ever debugged in frustration was actually a gap in your hardware knowledge - and that gap could be closed in a single book?Most embedded developers hit the same invisible ceiling. They write code that mostly works, call HAL functions they didn't write, step through abstraction layers they don't own, and spend hours debugging problems they can't fully see. The UART drops bytes under load. The ADC spikes unpredictably. The interrupt fires at the wrong time. The tooling works until it doesn't - and when it doesn't, there's nowhere to go.The real problem isn't the bug. It's not having a direct line to the hardware. Register-level programming fixes that permanently.Arm Cortex-M Register Level C is the book that takes you from HAL-dependent developer to someone who can configure any peripheral from its datasheet, diagnose any fault from its exception frame, and ship firmware that does exactly what it says - nothing more, nothing less.Here's what's waiting inside: Master every core peripheral from scratch - GPIO, UART, SPI, I2C, ADC, DMA, and timers - writing directly to hardware registers without a single HAL wrapper in sightBuild a real working sensor data logger in Chapter 17 that ties together ADC scan mode, circular DMA, USART output, timer-triggered sampling, and a fault handler - all register-level, all yoursDebug faults with confidence using the CFSR, HFSR, and exception stack frame - the chapter on fault handling alone is worth the price of the book for any engineer who has stared helplessly at a HardFaultUnderstand the foundation that makes everything else easier - clock trees, memory maps, linker scripts, startup code, and the NVIC priority system explained the way no HAL tutorial ever willLearn to port your knowledge forward - whether you move to STM32G4, NXP LPC, Nordic nRF, or the latest ARMv8.1-M silicon, the mental model transfers completelyThis book was written for C developers ready to stop guessing and start knowing. Whether you're coming from web or systems programming, stepping up from Arduino, or an experienced embedded engineer who's never worked below the HAL, the early chapters build your foundation and the later chapters make you dangerous.No CubeMX. No auto-generated code. No hidden abstractions. Every line you write is a line you understand.Stop debugging other people's code. Start owning your hardware - grab your copy and write firmware that does exactly what you tell it to. This item is printed on demand. Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.

Paperback. Condition: new. Paperback. Are you tired of embedded systems tutorials that drown you in theory but never show you how to build anything that actually works?Most beginners hit a frustrating wall. They understand C, they can blink an LED - but the moment a real project demands UART, SPI, I2C, interrupts, and a real-time scheduler all running at the same time, the complexity explodes. Online tutorials cover each piece in isolation. Nobody shows you how to wire it all together into firmware you can trust.This book is the bridge you've been looking for.Embedded RTOS Drivers and ISR for Absolute Beginners takes you from writing your first interrupt service routine all the way to building a complete multi-sensor data logger with six concurrent tasks, DMA-driven peripherals, watchdog recovery, and production-grade fault handling - step by step, with real working code on a real board.Here's what you'll build and master: - Write interrupt-driven peripheral drivers from scratch - UART with ring buffers, SPI for flash memory, and I2C for temperature sensors, each with proper error handling and bus recovery- Architect concurrent RTOS applications - design tasks, assign priorities correctly, and connect them with queues, semaphores, mutexes, and event groups without deadlocks or priority inversion- Harness DMA for zero-CPU data transfer - configure circular DMA for ADC, UART, and SPI with half-transfer and full-transfer callbacks wired safely into FreeRTOS tasks- Implement low-power design that actually works - tickless idle, Stop mode entry, RTC wakeup timers, peripheral clock gating, and a power budget calculation that extends battery life to years- Build a reliability stack that survives the field - Independent Watchdog with per-task health monitoring, HardFault handlers that decode the exception frame and pinpoint the faulting instruction, and configASSERT catching bugs before they become crashesEvery concept is grounded in the STM32 Nucleo F446RE and FreeRTOS, using STM32CubeIDE and the HAL library - the same platform used by professional embedded engineers worldwide. You'll work through 18 chapters of concrete, buildable examples, finishing with a capstone project that integrates every peripheral and RTOS pattern from the book into a single, coherent system.By the last page, you won't just know what a scheduler does - you'll know why the event task runs at priority 4 and the storage task at priority 2, and you'll be able to defend that decision. You'll know what the CFSR register is telling you when your system crashes, how to size a queue so it never overflows during a flash erase, and why the watchdog must be fed by tasks - never by SysTick.This is the practical, no-shortcuts guide that embedded developers wish had existed when they were starting out.If you're ready to stop writing toy firmware and start shipping reliable embedded systems, grab your copy now and write your first real driver today. This item is printed on demand. Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability.