import { AbstractSimulationComponentLogic, DigitalVoltageLevelEnum, EdgeEnum, IPin, ITimer, PinModeEnum, } from '@cirkit/simulation/logic'; enum DataStateEnum { Idle, WaitingForResetPulse, PresencePulse, WaitingForCommand, ProcessingCommand, SendingData, ConvertingTemperature, SearchROM, MatchROM, ReadingPowerSupply, } export class SimulationComponentLogic extends AbstractSimulationComponentLogic { dataState: DataStateEnum = DataStateEnum.Idle; lastEdgeTime: bigint | null = null; commandBuffer: number[] = []; bitIndex: number = 0; currentCommand: number = 0; dataToSend: number[] = []; timer: ITimer | null = null; conversionTimer: ITimer | null = null; temperatureConversionComplete: boolean = false; powerSupplyMode: PowerSupplyModeEnum = PowerSupplyModeEnum.Normal; isTransmitting: boolean = false; isDebugLoggingEnabled = false; debugLogColor = colors[Math.floor(Math.random() * colors.length)]; // Variables for Search ROM private deviceROMCode: number[] = []; private searchROMBitIndex: number = 0; private searchROMReadBits: number[] = []; private searchROMReadBitIndex: number = 0; private searchROMSubState: 'sendingBits' | 'receivingSelectionBit' = 'sendingBits'; pinDq: IPin; public init(): void { this.print(`[Init] Initializing DS18B20 simulation component.`); this.deviceROMCode = this.generateROMCode(); this.print(`[ROM Code Generated] ${this.deviceROMCode}`); // Initialize the DQ pin this.pinDq = this.simulationAPI.pin.createInputPin('DQ'); // Add pin watch to detect edges this.simulationAPI.pin.addDigitalPinWatch( this.pinDq, EdgeEnum.Both, (pin: IPin, voltage: number) => { this.dqPinChange(pin, voltage); }, ); } dqPinChange(pin: IPin, voltage: number) { const currentTime = this.simulationAPI.timer.getCurrentTimeNanos(); this.print(`[DQ Pin Change] Voltage: ${voltage} Time: ${currentTime}`); // If the device is transmitting, ignore line transitions if (this.isTransmitting) { this.print( `[DQ Pin Change] Ignoring line transition during transmission.`, ); return; } // Adjust voltage thresholds based on system voltage levels const isLow = voltage < 1.0; // Logic low threshold const isHigh = voltage > 2.3; // Logic high threshold if (isLow) { // Clear the falling edge, since it was triggered by this component. if (pin.mode === PinModeEnum.Output) { this.lastEdgeTime = null; } else { this.lastEdgeTime = currentTime; } } else if (isHigh) { // Skip processing if the component is driving the pin if (this.lastEdgeTime === null) { this.print(`[DQ Pin Change] Last edge triggered by self, skipping.`); return; } // Rising edge detected (line released) const durationNanos = currentTime - this.lastEdgeTime; const durationMicros = Number(durationNanos / BigInt(1000)); // DS18B20 timing constants const RESET_PULSE_MIN = 480; // ?s const TOLERANCE = 15; // ?s if (durationMicros >= RESET_PULSE_MIN - TOLERANCE) { // Reset pulse detected this.print( `[Reset Pulse] Reset pulse detected with duration ${durationMicros} ?s.`, ); this.commandBuffer = []; this.bitIndex = 0; this.currentCommand = 0; this.temperatureConversionComplete = false; this.dataToSend = []; this.dataState = DataStateEnum.PresencePulse; this.print(`[State Change] Data state changed to PresencePulse.`); this.sendPresencePulse(); } else { if (this.dataState === DataStateEnum.Idle) { // Reset lastEdgeTime to prevent stale timestamps this.lastEdgeTime = null; return; } if ( durationMicros >= 60 - TOLERANCE && durationMicros <= 60 + TOLERANCE ) { // Could be a write '0' time slot if (this.isWritingExpected()) { this.handleWriteTimeSlot(0); } else { this.print(`[dqPinChange] Unexpected write '0' time slot.`); } } else if (durationMicros >= 1 && durationMicros <= 15 + TOLERANCE) { // Could be a write '1' time slot or a read time slot if (this.isReadingExpected()) { // Read time slot detected this.handleReadTimeSlot(); } else if (this.isWritingExpected()) { // Write '1' time slot detected this.handleWriteTimeSlot(1); } else { this.print(`[dqPinChange] Unexpected short pulse.`); } } else { this.print( `[dqPinChange] Invalid pulse duration: ${durationMicros} ?s`, ); } } this.lastEdgeTime = null; // Reset the edge time } } isReadingExpected(): boolean { // We expect a read time slot when we're in the process of sending data, // or during Search ROM when the master reads our bits. if (this.dataState === DataStateEnum.SearchROM) { return this.searchROMSubState === 'sendingBits'; } return ( this.dataState === DataStateEnum.SendingData || this.dataState === DataStateEnum.ConvertingTemperature || this.dataState === DataStateEnum.ReadingPowerSupply ); } isWritingExpected(): boolean { if (this.dataState === DataStateEnum.SearchROM) { return this.searchROMSubState === 'receivingSelectionBit'; } else if (this.dataState === DataStateEnum.MatchROM) { return true; // Expecting to receive bits in MatchROM state } return this.dataState === DataStateEnum.WaitingForCommand; } handleWriteTimeSlot(bitValue: number) { if (this.dataState === DataStateEnum.MatchROM) { // Accumulate bits for ROM code this.commandBuffer.push(bitValue); this.print( `[Match ROM] Received bit ${this.commandBuffer.length}: ${bitValue}`, ); if (this.commandBuffer.length >= 64) { // We have received all 64 bits let receivedROMCode = []; for (let i = 0; i < 8; i++) { let byte = 0; for (let j = 0; j < 8; j++) { byte |= this.commandBuffer[i * 8 + j] << j; // LSB first } receivedROMCode.push(byte); } // Compare with deviceROMCode let match = true; for (let i = 0; i < 8; i++) { if (receivedROMCode[i] !== this.deviceROMCode[i]) { match = false; break; } } if (match) { this.print( `[Match ROM] ROM code matches. Device will respond to subsequent commands.`, ); this.dataState = DataStateEnum.WaitingForCommand; this.print(`[State Change] Data state changed to WaitingForCommand.`); } else { this.print( `[Match ROM] ROM code does not match. Device will not respond.`, ); // The device should not respond to any further communication until the bus reset this.dataState = DataStateEnum.Idle; // Or any appropriate non-participating state this.print(`[State Change] Data state changed to Idle.`); } // Clear command buffer this.commandBuffer = []; } } else if (this.dataState === DataStateEnum.SearchROM) { if (this.searchROMSubState === 'receivingSelectionBit') { // The master is sending the selection bit this.handleSearchROMSelectionBit(bitValue); // Prepare for next bit position this.searchROMBitIndex++; this.prepareSearchROMReadBits(); this.searchROMSubState = 'sendingBits'; } else { this.print( `[Search ROM] Unexpected write time slot; not expecting selection bit now.`, ); } } else if (this.dataState === DataStateEnum.WaitingForCommand) { // Only accumulate bits when waiting for a command this.commandBuffer.push(bitValue); this.print( `[Write Time Slot] Received bit ${this.commandBuffer.length}: ${bitValue}`, ); if (this.commandBuffer.length >= 8) { // We have received a byte (command) let commandByte = 0; for (let i = 0; i < 8; i++) { commandByte |= this.commandBuffer[i] << i; // LSB first } this.commandBuffer = []; this.currentCommand = commandByte; this.print( `[Command Received] Received command byte: 0x${commandByte.toString(16).padStart(2, '0')}`, ); this.processCommand(commandByte); } } else { // Ignore bits in other states this.print( `[Write Time Slot] Ignoring bit in state ${DataStateEnum[this.dataState]}`, ); } } handleReadTimeSlot() { this.simulateSendingDataBit(); } sendPresencePulse() { // Wait 15 ?s (t_RECOVERY) this.print(`[Presence Pulse] Preparing to send presence pulse.`); if (this.timer !== null) { this.simulationAPI.timer.stopTimer(this.timer); } this.timer = this.simulationAPI.timer.createTimer(() => { // Pull the line low for 60-240 ?s (t_PRESENCE) this.simulationAPI.pin.updatePinToDigitalOutput( this.pinDq, /* highVoltage= */ 5, DigitalVoltageLevelEnum.LOW, ); this.print(`[Presence Pulse] Line pulled low.`); // Presence pulse duration within specification const t_PRESENCE = 120; // ?s (typical value) // Schedule to release the line after t_PRESENCE this.timer = this.simulationAPI.timer.createTimer(() => { // Release the line //this.simulator.pinWrite(this.componentInstanceID, 'DQ', 5); // Pull-up resistor brings it high this.simulationAPI.pin.updatePinToInput(this.pinDq); this.print(`[Presence Pulse] Line released.`); // Now we can wait for commands this.dataState = DataStateEnum.WaitingForCommand; this.print(`[State Change] Data state changed to WaitingForCommand.`); }); this.simulationAPI.timer.startTimer( this.timer, t_PRESENCE /* ?s */, false, ); }); this.simulationAPI.timer.startTimer(this.timer, 15 /* ?s */, false); } processCommand(commandByte: number) { this.print( `[Process Command] Processing command 0x${commandByte .toString(16) .padStart(2, '0')}`, ); switch (commandByte) { case 0xcc: // Skip ROM this.print(`[Process Command] Skip ROM command received.`); // In this simplified simulation, we handle only one device, so Skip ROM is acceptable. this.dataState = DataStateEnum.WaitingForCommand; this.print(`[State Change] Data state remains in WaitingForCommand.`); break; case 0x44: // Convert T this.print(`[Process Command] Convert T command received.`); this.startTemperatureConversion(); break; case 0xbe: // Read Scratchpad this.print(`[Process Command] Read Scratchpad command received.`); if (this.temperatureConversionComplete) { this.print(`[Process Command] Temperature conversion complete.`); } else { this.print( `[Process Command] Temperature conversion not complete yet. Sending current data.`, ); } this.prepareScratchpadData(); this.dataState = DataStateEnum.SendingData; this.bitIndex = 0; this.print(`[State Change] Data state changed to SendingData.`); break; case 0xf0: // Search ROM this.print(`[Process Command] Search ROM command received.`); this.performSearchROM(); break; case 0x55: // Match ROM this.print(`[Process Command] Match ROM command received.`); // Prepare to receive the 64-bit ROM code from the master this.commandBuffer = []; this.bitIndex = 0; this.dataState = DataStateEnum.MatchROM; this.print(`[State Change] Data state changed to MatchROM.`); break; case 0xb4: // Read Power Supply this.print(`[Process Command] Read Power Supply command received.`); this.dataState = DataStateEnum.ReadingPowerSupply; break; default: this.print( `[Process Command] Unknown command received: 0x${commandByte.toString( 16, )}`, ); this.dataState = DataStateEnum.WaitingForCommand; this.print(`[State Change] Data state reset to WaitingForCommand.`); break; } // Reset command buffer to ensure it's clear for the next command this.commandBuffer = []; } performSearchROM() { this.print(`[Perform Search ROM] Simulating Search ROM procedure.`); // Clear command buffer this.commandBuffer = []; this.searchROMBitIndex = 0; this.searchROMSubState = 'sendingBits'; this.dataState = DataStateEnum.SearchROM; this.print(`[State Change] Data state changed to SearchROM.`); this.prepareSearchROMReadBits(); } prepareSearchROMReadBits() { const bitPosition = this.searchROMBitIndex; if (bitPosition >= 64) { // All bits sent this.dataState = DataStateEnum.WaitingForCommand; this.print( `[Search ROM] All bits sent. Data state changed to WaitingForCommand.`, ); return; } const byteIndex = Math.floor(bitPosition / 8); const bitMask = 1 << bitPosition % 8; const deviceBit = this.deviceROMCode[byteIndex] & bitMask ? 1 : 0; const deviceComplementBit = deviceBit ^ 1; this.print( `[Search ROM] Bit position: ${bitPosition}, Device bit: ${deviceBit}, Complement bit: ${deviceComplementBit}`, ); this.searchROMReadBits = [deviceBit, deviceComplementBit]; this.searchROMReadBitIndex = 0; } handleSearchROMSelectionBit(masterSelectionBit: number) { const bitPosition = this.searchROMBitIndex; const byteIndex = Math.floor(bitPosition / 8); const bitMask = 1 << bitPosition % 8; const deviceBit = this.deviceROMCode[byteIndex] & bitMask ? 1 : 0; if (masterSelectionBit !== deviceBit) { // Master did not select this device's path; stop responding this.print( `[Search ROM] Master selection bit ${masterSelectionBit} does not match device bit ${deviceBit}. Device stops participating.`, ); this.dataState = DataStateEnum.Idle; // Or any appropriate state to indicate non-participation } else { this.print( `[Search ROM] Master selection bit ${masterSelectionBit} matches device bit ${deviceBit}. Continuing search.`, ); // Prepare bits for next bit position (handled after this function) } } simulateSendingDataBit() { if (this.timer !== null) { this.simulationAPI.timer.stopTimer(this.timer); } let bitValue: number; if ( this.dataState === DataStateEnum.SearchROM && this.searchROMSubState === 'sendingBits' ) { this.print( `[Sending Data Bit] search ROM bit index before: ${this.searchROMReadBitIndex}`, ); if (this.searchROMReadBitIndex < this.searchROMReadBits.length) { bitValue = this.searchROMReadBits[this.searchROMReadBitIndex]; } else { this.print( `[Simulate Sending Data Bit] No more bits to send in this bit position.`, ); return; } } else if (this.dataState === DataStateEnum.SendingData) { const byteIndex = Math.floor(this.bitIndex / 8); const bitPosition = this.bitIndex % 8; if (byteIndex >= this.dataToSend.length) { // All data has been sent this.print(`[Simulate Sending Data Bit] All data bits have been sent.`); this.dataState = DataStateEnum.WaitingForCommand; this.print(`[State Change] Data state changed to WaitingForCommand.`); return; } bitValue = (this.dataToSend[byteIndex] >> bitPosition) & 1; this.bitIndex++; } else if (this.dataState === DataStateEnum.ConvertingTemperature) { // During temperature conversion, the device sends '0' until conversion is complete bitValue = this.temperatureConversionComplete ? 1 : 0; } else if (this.dataState === DataStateEnum.ReadingPowerSupply) { // Handle the READPOWERSUPPLY command bitValue = this.powerSupplyMode === PowerSupplyModeEnum.Parasite ? 0 : 1; this.print( `[Sending Data Bit] READPOWERSUPPLY response: ${bitValue ? 'Normal Power' : 'Parasite Power'}`, ); // After sending this bit, transition back to WaitingForCommand this.dataState = DataStateEnum.WaitingForCommand; this.print(`[State Change] Data state changed to WaitingForCommand.`); } else { this.print( `[Simulate Sending Data Bit] Unexpected data state: ${DataStateEnum[this.dataState]}`, ); return; } const t_RDV = 3; // ?s, delay before slave responds // Start a timer to reset isTransmitting after t_SLOT this.isTransmitting = true; const t_SLOT = 55; // ?s, time slot duration const transmissionTimer = this.simulationAPI.timer.createTimer(() => { this.isTransmitting = false; this.print( `[Transmission Timer] isTransmitting set to false after t_SLOT (${t_SLOT} ?s).`, ); }); this.simulationAPI.timer.startTimer(transmissionTimer, t_SLOT, false); if (bitValue === 1) { // For '1' bit, the slave leaves the line high. this.print(`[Sending Data Bit] Sending bit 1, line remains high`); // Schedule any necessary state transitions after the master has sampled the line. const t_SAMPLE = 15; // ï¿½s, time by which the master has sampled the line this.timer = this.simulationAPI.timer.createTimer(() => { this.print(`[Sending Data Bit] Completed sending bit 1`); // Transmission is complete; set isTransmitting to false this.isTransmitting = false; // Increment indices or change states as needed if ( this.dataState === DataStateEnum.SearchROM && this.searchROMSubState === 'sendingBits' ) { this.searchROMReadBitIndex++; if (this.searchROMReadBitIndex >= this.searchROMReadBits.length) { // All bits sent for this bit position, move to receiving selection bit this.searchROMSubState = 'receivingSelectionBit'; this.print(`[Search ROM] Waiting for master selection bit.`); } } // Handle other states as necessary // Proceed to send the next bit or handle next operation }); this.simulationAPI.timer.startTimer(this.timer, t_SAMPLE, false); // Proceed after 15 ï¿½s return; } // For '0' bit: // Wait t_RDV, then pull line low this.timer = this.simulationAPI.timer.createTimer(() => { // Pull line low this.simulationAPI.pin.updatePinToDigitalOutput( this.pinDq, /* highVoltage= */ 5, DigitalVoltageLevelEnum.LOW, ); this.print(`[Sending Data Bit] Sending bit 0, line pulled low`); // Hold line low for t_LOW0 const t_LOW0 = 47; // ?s // Schedule to release the line after t_LOW0 this.timer = this.simulationAPI.timer.createTimer(() => { // Release line this.simulationAPI.pin.updatePinToInput(this.pinDq); this.print(`[Sending Data Bit] Released line after sending bit 0`); // Transmission is complete; set isTransmitting to false this.isTransmitting = false; // Increment indices or change states as needed if ( this.dataState === DataStateEnum.SearchROM && this.searchROMSubState === 'sendingBits' ) { this.searchROMReadBitIndex++; if (this.searchROMReadBitIndex >= this.searchROMReadBits.length) { // All bits sent for this bit position this.searchROMSubState = 'receivingSelectionBit'; this.print(`[Search ROM] Waiting for master selection bit.`); } } // For other data states, handle as needed }); this.simulationAPI.timer.startTimer(this.timer, t_LOW0, false); }); this.simulationAPI.timer.startTimer(this.timer, t_RDV, false); } startTemperatureConversion() { this.print(`[Start Conversion] Starting temperature conversion.`); // Simulate conversion delay (depends on resolution, here using 750 ms) const conversionDelayMicros = 700000; // 750 ms in ?s if (this.conversionTimer !== null) { this.print( `[Start Conversion] Stopping existing temperature conversion timer before starting a new one.`, ); this.simulationAPI.timer.stopTimer(this.conversionTimer); } this.conversionTimer = this.simulationAPI.timer.createTimer(() => { this.print(`[Start Conversion] Temperature conversion complete.`); // Mark that temperature conversion is complete this.temperatureConversionComplete = true; // Transition dataState to WaitingForCommand this.dataState = DataStateEnum.WaitingForCommand; this.print(`[State Change] Data state changed to WaitingForCommand.`); this.conversionTimer = null; }); this.print( `[Start Conversion] Starting temperature conversion timer for ${conversionDelayMicros} ?s.`, ); this.simulationAPI.timer.startTimer( this.conversionTimer, conversionDelayMicros, false, ); this.temperatureConversionComplete = false; this.dataState = DataStateEnum.ConvertingTemperature; this.print(`[State Change] Data state changed to ConvertingTemperature.`); } prepareScratchpadData() { this.print(`[Prepare Scratchpad Data] Preparing scratchpad data.`); // Simulate the scratchpad data // The first two bytes are temperature LSB and MSB const temperature = this.simulationState.getIntegerState('temperature') || 25; // For example, 25 degrees Celsius // DS18B20 stores temperature in 1/16 degrees C as a signed 16-bit integer. const tempRaw = temperature * 16; // Multiply by 16 to convert to 1/16 degrees const tempLSB = tempRaw & 0xff; const tempMSB = (tempRaw >> 8) & 0xff; this.print( `[Prepare Scratchpad Data] Temperature: ${temperature}ï¿½C, Raw: ${tempRaw}, LSB: 0x${tempLSB.toString( 16, )}, MSB: 0x${tempMSB.toString(16)}`, ); // Rest of scratchpad bytes (setting default values) // [TEMP_LSB, TEMP_MSB, TH_REGISTER, TL_REGISTER, CONFIG_REGISTER, RESERVED[3], CRC] const scratchpad = [tempLSB, tempMSB, 0x4b, 0x46, 0x7f, 0xff, 0x0c, 0x10]; // Example values // Compute CRC for scratchpad const crc = this.calculateCRC(scratchpad.slice(0, 8)); scratchpad.push(crc); this.print( `[Prepare Scratchpad Data] Scratchpad: [${scratchpad .map((b) => `0x${b.toString(16).padStart(2, '0')}`) .join(', ')}], CRC: 0x${crc.toString(16)}`, ); this.dataToSend = scratchpad; this.bitIndex = 0; } // Function to calculate the CRC8 for the ROM code calculateCRC(data: number[]): number { let crc = 0; for (let byte of data) { crc ^= byte; for (let i = 0; i < 8; i++) { if (crc & 0x01) { crc = (crc >> 1) ^ 0x8c; // Polynomial used for CRC8 } else { crc >>= 1; } } } return crc; } generateROMCode(): number[] { const romCode = [0x28]; // Start with the family code for DS18B20 // Generate 6 random bytes for the unique identifier for (let i = 0; i < 6; i++) { romCode.push(Math.floor(Math.random() * 256)); } // Calculate the CRC for the first 7 bytes romCode.push(this.calculateCRC(romCode)); return romCode; } print(message: string) { if (this.isDebugLoggingEnabled === false) { return; } this.log(`%c${message}`); } } const colors = ['blue', 'red', 'green', 'orange', 'purple', 'cyan', 'brown']; // Only normal power supply mode is currently supported. enum PowerSupplyModeEnum { Normal, Parasite, }

DS18B20 (SIM TEST) Simulation Source Code Example